java集合

JAVA

版本

javaSE java标准版本 基于桌面应用

javaEE 基于服务器

javaME 基于微软件 — Andriod

集合

interface Collection<E> extends Iterable<E>

interface List<E> extends Collection<E>

interface Set<E> extends Collection<E>

interface Map<K,V>

ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

add(E)

默认为长度为10的object数组

private static final int DEFAULT_CAPACITY = 10;

当数组长度不够时进行扩充

public void add(E obj)
	{
		int len = value.length;
		if(size==len)
		{
			Object[] newArray=new Object[len+(len>>1)];
			System.arraycopy(value, 0, newArray, 0, len);
			value=newArray;	
		}
		value[size++]=obj;
	}

remove(int index)

public E remove(int index) {
  rangeCheck(index);
  modCount++;
  E oldValue = elementData(index);
  int numMoved = size - index - 1;
  if (numMoved > 0){
System.arraycopy(value, index+1, value,index,numMoved);
  }
  elementData[--size] = null; // clear to let GC do its work
  return oldValue;
}

private void check(int index)
    {
		if(index<0|index>size-1)
		{
		throw new RuntimeException("数组越界"+index);
		}
    }

LinkedList

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

add(E)

node(previous,data,next)

采用尾插法

 public void add(E element){
		Node<E> node=new Node<>(last,element,null);
    if(first==null){
    	first=last=node;
    }else {
    	last.next=node;
    	last=node;
    }
    size++;
}

add(int index,E element)

public void add(int index,E element){	
  //abc|
  if(index==size){
    Node<E> temp=new Node<>(last,element,null);
    last.next=temp;
    last=temp;
  }else {
    Node<E> nowNode=getNode(index);
    Node<E> prev=nowNode.previous;
    //|abc
    if(prev==null){
     Node<E> temp=new Node<>(null,element,nowNode);
	nowNode.previous=temp;
 	first=temp;
    }else {
      //a|bc
     Node<E> temp=new Node<>(prev,element,nowNode);
     prev.next=temp;
     nowNode.previous=temp;
    }
  }
  size++;
 }

remove(int index)

public void remove(int index){
check(index);
Node<E> temp=getNode(index);
Node<E> prev = temp.previous;
Node<E> next = temp.next;
  //头一个结点
if(prev==null){
   first=next;
}else if(next==null){//最后一个结点
   last=prev;
}else {
    prev.next=next;
    next.previous=prev;	
}
   size--;
}

get(index)

把数据分为size/2 两份，前半按first向后查找，后半按last向前查找。

public Node<E> getNode(int index)
    {
    		check(index);
		Node<E> temp=null;
  //前半
		if(index<(size>>1))
		{
			temp=first;
    			for(int i=0;i<index;i++)
    			{
    				temp=temp.next;		
    			}
		}
  //后半
		else {
			temp=last;
			for(int i=size-1;i>index;i--)
    			{
    				temp=temp.previous;
    			}
		}
		return temp;
    }

###Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

add

public synchronized boolean add(E e) {     
   elementData[elementCount++] = e;
   return true;
}

HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

链表+数组实现

				final int hash;
        final K key;
        V value;
        Node<K,V> next;
				Node<K,V>[] table;

初始表长16，装载因子0.75，大于8时，转为红黑树存储。

允许key，value为null

hash

private int getHash(k key)
	{
		int h=key.hashCode();
		return h ^ (h >>> 16);//右移 高位为0填充
	}

put(k,v)

public void put(k key,v value)
	{
		int hash=getHash(key)%length;
  	//是否为链表最后一个
		boolean flag = false;
		entry<k,v> temp=e[hash];
		entry<k,v> nowNode = new entry<>(hash,key,value,null);
		entry<k,v> pre = temp;
		if(temp==null)
		{
			e[hash]=nowNode;
		}else {
			while(temp!=null)
			{
				if(temp.key.equals(key))
				{
					flag=true;
					temp.value=value;
					break;
				}else {
					pre = temp;
					temp=temp.next;
				}
			}
			if(flag==false)
			{
				pre.next=nowNode;	
			}
		}
	}

entrySet

		Set<Map.Entry<K,V>> entrySet()
  
		Map<String,String> m=new HashMap<>();
		m.put("2", "A");
		Set<Map.Entry<String,String>> set = m.entrySet(); 
		Iterator<Map.Entry<String,String>> it=set.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> entry= it.next();
			System.out.println(entry.getKey()+" "+entry.getValue());
		}

keySet

Set<K> keySet()

Hashtable

不允许key，value为null

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

public Hashtable() {
        this(11, 0.75f);
    }

作用类似于Iterator

public interface Enumeration<E> {
    boolean hasMoreElements();
    E nextElement();
}

public synchronized Enumeration<K> keys() {
 return this.<K>getEnumeration(KEYS);
}
public synchronized Enumeration<V> elements() {
  return this.<V>getEnumeration(VALUES);
}

hash

int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;

put(K,V)

public synchronized V put(K key, V value)

HashSet

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

Set内部实现为map

private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();
public HashSet() {
        map = new HashMap<>();
}

add(E)

public boolean add(E e) {
  return map.put(e, PRESENT)==null;
}

iterator()

public Iterator<E> iterator() {
 return map.keySet().iterator();
}

Iterator<String> it=set.iterator();
		while(it.hasNext())
		{
			//返回当前游标位置，并移向下一个
			//System.out.println(it.next());
			//删除游标左边的元素，该操作只能执行一次
			//it.remove();
			System.out.println(it.next());
		}

TreeMap

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

内部实现compartor业务实体类

private final Comparator<? super K> comparator;
int compare(T o1, T o2);

TreeSet

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable

内部实现为TreeMap

public TreeSet() {
        this(new TreeMap<E,Object>());
    }

###Collections

//从小到大排序 abef
Collections.sort(list);
//自定义排序 feba
Collections.sort(list,new Comparator<String>(){
					@Override
					public int compare(String o1, String o2) {
						if(o1.compareTo(o2)<0)
						{
							return 1;
						}else {
							return -1;
						}
					}		
				});
		//反转
		Collections.reverse(list);	
		//洗牌
		Collections.shuffle(list);
		//洗牌
		Collections.swap(list,0,2);