集合

集合

• 定义：集合类是Java数据结构的实现。

• 介绍：Java集合主要由2大体系构成，分别是 Collection体系和Map体系，其中Collection和Map分别是2大体系中的顶层接口。

  Collection主要有三个子接口，分别为List(列表)、Set(集)、Queue(队列)。其中，List、Queue中的元素有序可重复，而Set中的元素无序不可重复；

  List中主要有ArrayList、LinkedList两个实现类；Set中则是有HashSet实现类；而Queue是在JDK1.5后才出现的新集合，主要以数组和链表两种形式存在。

  Map同属于java.util包中，是集合的一部分，但与Collection是相互独立的，没有任何关系。Map中都是以key-value的形式存在，其中key必须唯一，主要有HashMap、HashTable、TreeMap三个实现类。

• List和LinkedHashSet是按照存储顺序保存的，Set集合中HashSet不是按照存储的顺序保存，具有不确定性；TreeSet按照自然顺序保存

List

ArrayList<String > names=new ArrayList<String>();
        //ArrayList变量.add("~")：添加数据
        names.add("张安顺");
        names.add("tom");
        names.add("jim");
        
        System.out.println(names.get(0));//ArrayList变量.get(int型数值):返回下标为该数的存的值
        //ArrayList变量.add(index,"##"):表示把##插入到下标为index的位置，后面的值下标顺次后移
        names.add(1, "李银霞");  
        
        //ArrayList变量.set(Index,"##")：把下标为index的地方替换成"##"
        names.set(0, "王卓");  
        
        //ArrayList变量.remove(index)：表示把下标为index的值删掉，后面的值下标向前移动
        names.remove(1);
      
        //第三种遍历方法：用迭代器方法。Arraylist变量.iterator()把数组中的值放到了迭代器中，然后在迭代器中遍历
        Iterator<String> order = names.iterator();  
        while (order.hasNext()) {//先判断下一个是否为空，若有，指针下移
            System.out.println(order.next());
        }
        
        //ArrayList变量.clear():清除所有数据
        names.clear();
        System.out.println(names.isEmpty());//判断是否为空 输出值为true和false  
        
        System.out.println(names.contains("jim"));//boolean 是否包含jim
        System.out.println(names.remove("jim")); //如果存在，则从此列表中删除指定元素的第一次出现。 输出值为逻辑型，即是否存在  
        
        

HashSet

• HashSet是Set接口典型实现，它按照Hash算法来存储集合中的元素，具有很好的存取和查找性能。主要具有以下特点：

  1.不维持插入顺序
  2.HashSet不是同步的，如果多个线程同时访问一个HashSet，要通过代码来保证其同步
  3.存储唯一元素并允许空值
  4.无下标，需要用迭代器进行遍历

        Set<String> names = new HashSet<String>();
        names.add("jim");//基于哈希表实现的--数组加链表
        names.add("tom");
        names.add("Jimmy");
        names.add("linken");
        
        Iterator<String> order = names.iterator();  
        while (order.hasNext()) {
            String string = (String) order.next();
            System.out.println(string);
        }

• Hashset的add解析
  主要思路：
  先看hashCode()值是否相同
  相同:继续走equals()方法
  返回true：说明元素重复，就不添加
  返回false：说明元素不重复，就添加到集合
  不同：就直接把元素添加到集合
  如果类没有重写这两个方法，默认使用的Object()。一般来说不会相同。
  而String类重写了hashCode()和equals()方法，所以，它就把内容相同的字符串去掉，只留下一个。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    HashMap.Node<K, V>[] tab; //临时节点
    HashMap.Node<K, V> p;
    int n, i;
    //判断当前hash表是否是空，如果为空，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;//扩容后饭后hash表大小
    //判断当前桶位置是否为空并且将值赋值于p，减一的原因是因为数组下标从0开始
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {

        HashMap.Node<K, V> e;
        K k;

        //判断当前桶节点和新节点的key的hash值和key值是否相同
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //不相同是否为红黑树节点
        else if (p instanceof HashMap.TreeNode)
            e = ((HashMap.TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
        else {
            //追加到链表
            for (int binCount = 0; ; ++binCount) {
                //如果桶节点不存在下一节点则赋值
                if ((e = p.next) == null)
                {
                    p.next = newNode(hash, key, value, null);
                    //当前链表长度是否超过了红黑树阈值
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果存在判断key是否相同
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //到此处该节点已经插入
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //该变量是指HashMap修改了多少次
    ++modCount;
    //插入新数据后判断是否需要扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

• add中的equals重写

  public boolean equals(Object obj) {//obj值是集合中的某个对象，因为集合中可能存的未必都是学生类，比如集合泛型为Object的时候，既可以存学生对象，还可以存其它对象
      if(obj instanceof Student ){//判断是否为Student的子类
          Student stu = (Student)obj;
          return this.id.equals(stu.id);//this即是当前正在试图被存储的对象
      }
      return false;
  }