javascript 함수 라이브러리-수집 Framework_javascript 기술

클래스:
컬렉션
배열
ArrayList
SortedList는 ArrayList를 확장합니다.
HashMap
HashSet
*/

/****************
컬렉션
참고:sort()는 새 목록을 반환합니다.
******************/
function 컬렉션(){}
Collections.sort=function(){
if(arguments.length==1){
 var s=new SortedList();
 s.addAll(arguments[0]);
 반품 s;
}
else if(arguments.length==2){
 var s=new SortedList();
 s.setComparator(arguments[1]);
 s.addAll(arguments[0]);
 반품 s;
}
그렇지 않으면 
 "IllegalArgument"를 던집니다.
}
/***************
배열
*****************/
function Arrays(){}
Arrays.asList=function(arr){
return new ArrayList(arr);
}


//ListIterator
함수 ListIterator(table,len){
   this.table=table;
this.len=len;                          
   this.index=0;
 
this.hasNext=function() {
 return this.index   }

   this.next=function() { 
 if(!this.hasNext())
  throw "해당 요소 없음!";
return this.table[this.index ];
   }
}

/********************
ArrayList
*********************/
function ArrayList(){
this.buffer=new Array();
if(arguments.length>0) this.buffer=arguments[0];
this.length=this.buffer.length;
}
ArrayList.prototype.hashCode=function(){
var h=0;
for(var i=0;i h =this.buffer[i].hashCode();
h를 반환합니다.
}

ArrayList.prototype.size=function(){
return this.length;
}

ArrayList.prototype.clear=function(){
for(var i=0;ithis.buffer.length=0;
this.length=0;
}

ArrayList.prototype.isEmpty=function(){
return this.length==0;
}

ArrayList.prototype.toArray=function(){
var copy=new Array();
for(var i=0;i copy[i]=this.buffer[i];
}
사본 반환;
}
ArrayList.prototype.get=function(index){
if(index>=0 && index return this.buffer[index];
null을 반환합니다.
}

ArrayList.prototype.remove=function(param){
var index=0;
 
if(isNaN(param)){
 index=this.indexOf(param);
}
else index=param;
  
if(index>=0 && index for(var i=index;i  this.buffer[i]= this.buffer[i 1];
  this.length-=1;
  반환 true;
}
그렇지 않으면 false를 반환합니다.
}
 
ArrayList.prototype.add=function(){
var args=arguments;
if(args.length==1){
 this.buffer[this.length ]=args[0];
 true를 반환합니다.
}
else if(args.length==2){
 var index=args[0];
 var obj=args[1];
 if(index>=0 && index  for(var i=this.length;i>index;i--)
   this.buffer[i]=this. 버퍼[i-1];
  this.buffer[i]=obj;
  this.length =1;
  반환 true;
 }
}
false를 반환합니다.
}

ArrayList.prototype.indexOf=function(obj){
for(var i=0;i if(this.buffer[i ].equals(obj)) return i;
}
return -1;
}

ArrayList.prototype.lastIndexOf=function(obj){
for(var i=this.length-1;i>=0;i--){
 if( this.buffer[i].equals(obj)) return i;
}
return -1;
}

ArrayList.prototype.contains=function(obj){
return this.indexOf(obj)!=-1;
}

ArrayList.prototype.equals=function(obj){
if(this.size()!=obj.size()) return false;
for(var i=0;i if(!obj.get(i).equals(this.buffer[i])) return false;
}
true를 반환합니다.
}

ArrayList.prototype.addAll=function(list){
var mod=false;
for(var it=list.iterator();it.hasNext();){
 var v=it.next();
 if(this.add(v)) mod=true;
}
모드 반환;  
}

ArrayList.prototype.containsAll=function(list){
for(var i=0;i if(!this. 포함(list.get(i))) 반환 false;
}
true를 반환합니다.
}

ArrayList.prototype.removeAll=function(list){
for(var i=0;i this.remove(this .indexOf(list.get(i)));
}
}

ArrayList.prototype.retainAll=function(list){
for(var i=this.length-1;i>=0;i--){
 if(!list.contains (this.buffer[i])){
  this.remove(i);
 }
}
}

ArrayList.prototype.subList=function(begin,end){
if(beginif(end>this.length) end=this.length;
var newsize=end-begin;
var newbuffer=new Array();
for(var i=0;i newbuffer[i]=this.buffer[begin i];
}
새 ArrayList(newbuffer)를 반환합니다.
}
ArrayList.prototype.set=function(index,obj){
if(index>=0 && index temp=this.buffer[index];
 this.buffer[index]=obj;
 반품 온도;
}
}

ArrayList.prototype.iterator=function iterator(){
return new ListIterator(this.buffer,this.length);
}

/*****************************
SortedList는 ArrayList를 확장합니다.
**************** ***************/
함수 SortedList(){
  this.com=null;
}
SortedList.prototype=new ArrayList();
SortedList.prototype.setComparator=function(comp){
if(this.length!=0) throw "목록이 비어 있을 때만 설정할 수 있음";
this.com=comp;
}

SortedList.prototype.getComparator=function(){
return this.com;
}

//재정의
SortedList.prototype.add=function(obj){
var index = this.indexOf(obj);
for(var i=this.length;i>index;){
 this.buffer[i]=this.buffer[--i];
}

this.buffer[index]=obj;
this.length ; 
}
//재정의
SortedList.prototype.indexOf=function(obj){
if(this.length==0) return 0;
 
var min=0,max=this.length-1;
var mid=0;
while(min  
 mid = (min max) >> 1;
 var c=0;
 if(this.com==null) c=obj.compareTo(this.buffer[mid]);
 else c=this.com.compare(obj,this.buffer[mid]);
  
 if(c==0){
  return mid;
 }
 else if(c  max=mid-1;
 }
 else{
  min=mid 1;
 }
}
중간 =(최소 최대) >>1;
1시 중반에 반납;
}
//재정의
SortedList.prototype.contains=function(obj){
if(this.length==0) return false;
var min=0,max=this.length-1;
var mid=0;
while(min mid = (min max) >> 1;
 var c=0;
 if(this.com==null) c=obj.compareTo(this.buffer[mid]);
 else  c=this.com.compare(obj,this.buffer[mid]);
 if(c==0){
  return true;
 }
 else if(c  max=mid-1;
 }
 else{
  min=mid 1;
 }
}
false를 반환합니다.
}
//재정의
SortedList.prototype.subList=function(begin,end){
var sl=new SortedList();
s1.setComparator(this.com);
var sub=ArrayList.prototype.subList(begin.end);
sl.addAll(sub);
반품 sl;
}


/****************************
해시맵
******************** ***********/

함수 항목(h,k,v,n){
  this.value = v; 
  this.next = n;
  this.key = k;
  this.hash = h;

  this.getKey=function(){
 return this.key;
  }

  this.getValue=function() {
 return this.value;
  }
  this.setValue=function(newValue) {
 var oldValue = this.value;
 this.value = newValue;
 return oldValue;
  }

  this.equals=function(o){
  var e = o;
  var k1 = this.getKey();
  var k2 = e.getKey();
  var v1 = this.getValue();
  var v2 = e.getValue();
  반환 (k1.equals(k2) && v1.equals(v2));
  }

  this.hashCode=function() {
   return this.key.hashCode() ^ this.value.hashCode();
  }

  this.toString=function() {
 return this.getKey()   "="   this.getValue();
  }
}

함수 HashIterator(table,index,ne){

this.table=table;
this.ne=ne;                  
this.index=index;            
this.current=null;

this.hasNext=function() {
 return this.ne != null;
}

this.next=function() { 
 
 var e = this.ne;
 if (e == null) 
  '해당 요소 없음'을 발생시킵니다.
   
 var n = e.next;
 var t = this.table;
 var i = this.index;
 while (n == null && i > 0)
  n = t[--i];
 this.index = i;
 this.ne = n;
 this.current=e;

 return this.current;
}
}


함수 HashMap()
{
this.len=8;
this.table=new Array();
this.length=0;
}
//java.util.HashMap 참조
HashMap.hash=function(x){
   var h = x.hashCode();
   h  = ~(h    h ^=  (h >>> 14);
   h  =  (h    h ^=  (h >>> 10);
   return h;
}

HashMap.prototype.rehash=function(){       
   var oldTable = this.table;   
   this.table=new Array();
       
//transfer        
   for (var i = 0; i       var e = oldTable[i];
       if (e != null) {
          oldTable[i] = null;
          do {
             var next = e.next;
              var j = this.indexFor(e.hash);  
              e.next = this.table[j];
              this.table[j] = e;
              e = 다음;
           } while (e != null);
       }
   }
}

HashMap.prototype.indexFor=function(h) {
var index= h & (this.len-1);
반환 색인;
}

HashMap.prototype.size=function() {
return this.length;
}

HashMap.prototype.isEmpty=function() {
return this.length == 0;
}

HashMap.prototype.get=function(key) {
var hash =HashMap.hash(key);
var i = this.indexFor(hash);

var e = this.table[i]; 

while (true) {
 if (e ==null)
  return null;
 if (e.hash == hash && key.equals(e.key)) 
  return e.value;
 e = e.다음;
}
}

HashMap.prototype.containsKey=function(key) {
var hash =HashMap.hash(key);
var i = this.indexFor(hash);
var e = this.table[i]; 

while (e != null) {
 if (e.hash == hash && key.equals(e.key)) 
  return true;
 e = e.다음;
}
false를 반환합니다.
}

HashMap.prototype.put=function(key,value) {
var hash = HashMap.hash(key);
var i = this.indexFor(hash);


for (var e = this.table[i]; e != null; e = e.next) {
 if (e.hash == hash && key.equals(e .key)) {
  var oldValue = e.value;
  e.value = 가치;
  return oldValue;
 }
}

this.addEntry(hash, 키, 값, i);

var r=Math.ceil(this.length * 1.5);

if(r > this.len){
 this.len= this.len  this.rehash();
}
null을 반환합니다.
}


HashMap.prototype.putAll=기능 (맵){
var mod=false;
for(var it=map.iterator();it.hasNext();){
 var e=it.next();
 if(this.put(e.getKey(),e.getValue())) mod=true;
}
}

HashMap.prototype.remove=function(key) {
   var e = this.removeEntryForKey(key); 
   return (e ==null ? null : e.value);
}

HashMap.prototype.removeEntryForKey=function(key) {
var hash = HashMap.hash(key);
var i = this.indexFor(hash);

var prev = this.table[i];
var e = prev;

while (e != null) {
 var next = e.next;
 if (e.hash == hash && key.equals(e.key)) {
  this.length--;
  if (prev.equals(e)) 
   this.table[i] = next;
  else
   prev.next = 다음;
  return e;
 }
 이전 = e;
 e = 다음;
}
e를 반환합니다.
}

HashMap.prototype.clear=function() {
   for (var i = 0; i        this.table[i] = 널;
   this.length = 0;
}

HashMap.prototype.containsValue=function(value) {
if (value == null) return false;

var tab = this.table;
for (var i = 0; i  for (var e = tab[i] ; e != null ; e = e.next)
 if (value.equals (e.값))
   return true;
false를 반환합니다.
}

HashMap.prototype.addEntry=function(hash, key, value, bucketIndex) {
this.table[bucketIndex] = new Entry(hash, key, value, this.table[ 버킷 인덱스]);
this.length ;
}

HashMap.prototype.iterator=function(){
var i=this.table.length;

var next=null;
while(i>0 && next==null){
 next=this.table[--i];
}

새 HashIterator(this.table,i,next)를 반환합니다.
}


HashMap.prototype.hashCode=function(){
var h=0;
for(var it=this.iterator();it.hasNext();){
 h =it.next().hashCode();
}
h를 반환합니다.
}

HashMap.prototype.equals=function(map){
if(!this.typeMatches(map)) return false;
if(map.size()!=this.size()) 반환 false;

for(var it=this.iterator();it.hasNext();){ 
 var e=it.next();
 var key=e.getKey();
 var value=e.getValue();

 if(!value.equals(map.get(key))) false 반환

}
true 반환;
}


/*************************
해시세트
******************** ******/

함수 HashSetIterator(ite){
   this.it=ite;
 
this.hasNext=function() {
 return this.it.hasNext();
   }

   this.next=function() { 
 return this.it.next().getKey();
   }
}

함수 HashSet(){  
this.map=new HashMap();
}
HashSet.NULL=new Number("!THIS는 NULL입니다!");


HashSet.prototype.size=function(){
return this.map.size();
}

HashSet.prototype.isEmpty=function() {
return this.map.isEmpty();
}

HashSet.prototype.contains=function(o) {
return this.map.containsKey(o);
}

HashSet.prototype.add=function(o){
return this.map.put(o,HashSet.NULL)==null;
}

HashSet.prototype.addAll=function(set){
var mod=false;
for(var it=set.iterator();it.hasNext();){
 if(this.add(it.next())) mod=true;
}
모드 반환;
}

HashSet.prototype.remove=function(o) {
return this.map.remove(o).equals(HashSet.NULL);
}

HashSet.prototype.clear=function() {
this.map.clear();
}

HashSet.prototype.iterator=function(){
새 HashSetIterator(this.map.iterator()) 반환;
}

HashSet.prototype.equals=function(o) {
if(!this.typeMatches(o)) return false;
if (o.size() != this.size()) false를 반환합니다.
for(var it=this.iterator();it.hasNext();){
 if(!o.contains(it.next())) return false;
}
true를 반환합니다.
}

HashSet.prototype.hashCode=function() {
var h=0;
for(var it=this.iterator();it.hasNext();){
 h =it.next().hashCode();
}
h를 반환합니다.
}

HashSet.prototype.toArray=function(){
var arr=new Array();
var i=0;
for(var it=this.iterator();it.hasNext();){
 arr[i ]=it.next();
}
return arr;
}