Java集合类汇总

一、集合与数组

数组（储存多个相同类型数据的集合）

集合（只能存储对象）

二、集合框图

Collection接口是最基本的集合类接口，其继承和产生了两个接口List和Set。

Map是一个映射接口，用于存储一组键值对象，Map不能包含重复的key，但是可以包含相同的value

Interator是一个用于遍历集合的接口，通常包含有以下三个方法：

1.hasNext():是否有下一个元素。

2.next():返回迭代的下一个元素。

3.remove():从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

三、主要接口和类的介绍

1.List(有序、可重复)

List中存放的对象是有序且可以重复，集合中的每一个元素都有它的索引，查询速度快，增删数据时比较慢。List的实现类有LinkedList, ArrayList, Vector, Stack。

2.Set(无序，不可重复)

Set中存放的对象是无序且不可以重复，Set的实现类有AbstractSet，HastSet，TreeSet。

3.Map（键值对）

Map集合中存储的是键值对，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

四、遍历

1.Interator:迭代输出。

2.foreach(元素变量 x:遍历对象 Obj):for加强循环。

3.for:循环输出。

五、List接口

1ArrayList和LinkList

ArrayList是一个动态数组，LinkList是一个双向链表，ArrayList适用于对对象的查询操作，LinkList适用于对对象的增删操作。ArrayList、LlinkList是非同步的。

ArrayList 底层实现原理

public class SxtArrayList<E>{
    private Object[] elementData;
    private int  size;
    private static final int DERALT_CAPACITY=10;
    public SxtArrayList() {
        elementData = new Object[DERALT_CAPACITY];
        
    } 
    public SxtArrayList(int capacity) {
        if(capacity < 0) {
            throw new RuntimeException("容器的容量不能为负数");
        }
        if(capacity == 0) {
            elementData = new Object[DERALT_CAPACITY];
        }else {
        elementData = new Object[capacity];
        }
        
    } 
    public void add(E element) {
        
        if(size == elementData.length) {
            Object[] newArray = new Object[elementData.length+(elementData.length>>1)];
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);
            elementData = newArray;
        }
        elementData[size++] = element;
    }
    public E get(int index) {
         checkRange(index);
        return (E) elementData[index];
    }
    public void set(E element,int index) {
              checkRange(index);
             elementData[index]=element;
    }
    public void checkRange(int index) {
        if(index < 0 || index > size-1) {
            throw new RuntimeException("索引不合法:"+index);
            }
    }
    
    public void remove(E element) {
        for(int i = 0; i < size; i++) {
            if(element.equals(get(i))) {
                remove(i);
            }
        }
    }
    public void remove (int index) {
        int numMoved = elementData.length-index-1;
        if(numMoved > 0) {
         System.arraycopy(elementData, index+1, elementData, index, numMoved);
        }
        elementData[--size] = null;

    }
    public  int size() {
        
        return size;
    }
    public boolean isEmpty() {
        return size == 0 ? true : false;
    }
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i = 0;  i < size; i++) {
            sb.append(elementData[i]+",");
        }
         sb.setCharAt(sb.length()-1, ']');
        return sb.toString();
    }

Vector于ArrayList的用法相似，是同步的，所以Vector是线程安全的。

2.Map接口

HashMap是最常用的Map，它根据键的HashCode值存储数据，遍历时，取得数据的顺序是完全随机的。

map中键不能重复，如果重复会覆盖原来的值。

存数据过程put(key-value)

HashMap底层实现了哈希表（数组加链表）

 //核心数组默认初始化的大小为16,(数组大小必须为2的整数幂)
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //负载因子(核心数组被占用超过0.75,则开始扩容)
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
   //阀值，当链表长度超过8时，链表会转化成红黑树，提高查询效率
    static final int TREEIFY_THRESHOLD = 8;
    static final int UNTREEIFY_THRESHOLD = 6;
    static final int MIN_TREEIFY_CAPACITY = 64;
    //核心数组(根据需要可以扩容),数组长度必须始终为2的整数幂
    transient  Node[] table;

常用hash算法：hash值=hashcode&(数组长度-1）数组长度必须为2的整次幂

Map存值过程:当添加一个元素(key-value)，首先计算key的hash值，以此确定插入数组中的位置，若数组中的该位置已经存在了值，

则该值插入在已存在值后面，形成链表，同一个链表上的hash值是相同的。

取数据过程get（key）

 （1）获得key的hashcode,通过hash()散列算法得到hash值，进而定位到数组的位置。

   (2)在链表上挨个比较key对象，调用equals()方法，将key对象和链表上所有节点的key对象进行比较，直到碰到返回true的节点为止。

   (3)返回equals()为true的节点对象的value对象。

java中规定，两个内容相同(equals()为true)的对象必须具有相等的hashcode,因为如果equals()为true而两个对象的hashcode不同，那在存出

过程中就发生了悖论。

六、List的遍历

List <String>list =new ArrayList <String>();
list.add("Hello");
list.add("World");
//foreach取值
for(String str:list){
System.out.println(str);
//把链表变为数据相关的内容进行遍历
String[] strArray=new String[list.size()];
list.toArray(strArray);
for(int i=0;i<=strArray.length-1;i++){
System.out.println(strArray[i]);
//使用迭代器进行遍历
Iterator <String> ite=list.iterator();
while(ite.hasNext()){
System.out.println(ite.next());

七、Map的遍历

第一种：keySet();

Map map = new HashMap();
map.put("1","Hello");
map.put("2","World");
Iterator it = map.keySet().iterator();
while(it.hasNext()){
Object key = it.next();
System.out.println(map.get(key));

第二种：entrySet（）
Map map = new HashMap();
map.put("1","Hello");
map.put("2","World");
Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry e =(Entry) it.next();
System.out.println("键"+e.getKey () + "的值为" + e.getValue());

(

Map <String,String>map = new HashMap<String,String>();
map.put("1","Hello");
map.put("2","World");

Iterator <Map.Entry<String,String>it = map.entrySet().iterator();

while(it.hasNext()){
Map.Entry<String,String> =it.next();
System.out.println("键"+e.getKey () + "的值为" + e.getValue());

)