Java基础（三）—— 集合

开始记录集合啦！

首先看看整体的

集合框架图

从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
集合框架体系如图：
在这里插入图片描述

首先开始讲解详细的用法：

List集合

方法细节可以参考官网上的描述： List
首先开始讲解ArrayList，底层采用的数组。该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。

方法细节如下代码：

package list;

import java.util.ArrayList;
import java.util.Iterator;

public class ArraylistDemo {
    
    
    public static void main(String[] args){
    
    
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");
        list.add("HAHAHAHA");

        //从集合中获取元素：get。索引值从0开始
        String getString = list.get(2);

        //从集合中删除元素：remove。索引值从0开始
        String removeString = list.remove(2);

        //获取集合长度
        int size = list.size();

        //ArrayList遍历
        //第一种遍历方法使用 For-Each 遍历 List
        for (String str : list){
    
            //也可以改写 for(int i=0;i<list.size();i++) 这种形式
            System.out.println(str);    //System.out.println(list.get(i));
        }
        //第二种遍历，把链表变为数组相关的内容进行遍历
        String[] strArray = new String[list.size()];
        list.toArray(strArray);
        for (int i=0; i < strArray.length; i++){
    
     //这里也可以改写为  for(String str:strArray) 这种形式
            System.out.println(strArray[i]);
        }
        //第三种遍历 使用迭代器进行相关遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
    
    
            System.out.println(iterator.next());
        }
    }
}

再来介绍LinkedList，底层采用链表实现，可参考官方文档LinkedList
该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：

List list=Collections.synchronizedList(newLinkedList(...));

切记一定不要使用普通for循环去遍历LinkedList。因为LinkedList在get任何一个位置的数据的时候，都会把前面的数据走一遍。使用迭代器或者foreach循环（foreach循环的原理就是迭代器）去遍历LinkedList即可，这种方式是直接按照地址去找数据的，将会大大提升遍历LinkedList的效率。（LinkedList 查找效率低。）

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {
    
    
    public static void main(String[] args){
    
    
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        //在该列表开头插入指定的元素
        linkedList.addFirst("first");
        //将指定的元素追加到死列表的末尾
        linkedList.addLast("last");

        //返回此列表中的第一个元素
        String strFirst = linkedList.getFirst();
        //返回此列表中的最后一个元素
        String strLast = linkedList.getLast();

        //从列表中删除并返回第一个元素
        String removeFirst = linkedList.removeFirst();
        //从列表中删除并返回最后一个元素
        String removeLast = linkedList.removeLast();

        //LinkedList遍历方式(只记录常用的)
        //第一种遍历方法使用 For-Each 遍历 List
        for (String str : linkedList){
    
    
            System.out.println(str);
        }
        //第二种遍历 使用迭代器进行相关遍历
        Iterator<String> iterator = linkedList.iterator();
        while (iterator.hasNext()){
    
    
            System.out.println(iterator.next());
        }
    }
}

Set集合

Set集合不包含重复元素的集合；没有带索引的方法，所以不能使用普通的for循环遍历
下面讲解的是Set集合的实现类：HashSet.
HashSet
该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。

具体实现方法可参考官方文档：HashSet

import java.util.Iterator;
import java.util.Set;

public class HashSetDemo {
    
    
    public static void main(String[] args){
    
    
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("world");
        set.add("java");

        //Set遍历方式
        //第一种遍历方法使用 For-Each 遍历 Set
        for (String str : set){
    
    
            System.out.println(str);
        }
        //第二种遍历 使用迭代器进行相关遍历
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
    
    
            System.out.println(iterator.next());
        }
    }
}

那么HashSet为什么集合是如何保证元素唯一的呢？以下是根据部分源码进行简单的分析：

//HashSet如何保证元素唯一
//点开add()进行跟进
  public boolean add(E e) {
    
    
        return map.put(e, PRESENT)==null;
    }

  public V put(K key, V value) {
    
    
        return putVal(hash(key), key, value, false, true);
    }

  static final int hash(Object key) {
    
    
          int h;
          return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
      }

  //Hash值和元素的HashCode()方法相关
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                     boolean evict) {
    
    
          Node<K,V>[] tab; Node<K,V> p; int n, i;
          //如果哈希表未初始化，就对其进行初始化
          if ((tab = table) == null || (n = tab.length) == 0)
              n = (tab = resize()).length;

          //根据对象的哈希值进行计算对象的存储位置，如果该位置没有元素，就存储元素
          if ((p = tab[i = (n - 1) & hash]) == null)
              tab[i] = newNode(hash, key, value, null);
          else {
    
    
              Node<K,V> e; K k;
              /*
              存入的元素和以前的元素进行比较哈希值
                 如果哈希值不相同，会继续向下执行，把元素添加到集合
                 如果哈希值相同,会继续调用对象的equals()方法比较
                    如果返回false，会继续向下执行，把元素添加到集合
                    如果返回true，说明元素重复，不存储
              */
              if (p.hash == hash &&
                  ((k = p.key) == key || (key != null && key.equals(k))))
                  e = p;
              else if (p instanceof TreeNode)
                  e = ((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;
                      }
                      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;
              }
          }
          ++modCount;
          if (++size > threshold)
              resize();
          afterNodeInsertion(evict);
          return null;
      }

HashSet集合添加一个元素的流程：
在这里插入图片描述
LinkedHashSet：
由哈希表和链表实现的Set接口，具有可预知迭代顺序。
由链表保证元素有序，也就是说元素的存储和取出顺序是一致的。是由链表决定。
有哈希表保证元素唯一，也就是说没有重复的元素。由哈希表决定的(hashCode()和equals())。
同样，具体实现方法可以参考官网：LinkedHashSet

import java.util.LinkedHashSet;

public class LinkedHashSetdemo {
    
    
    public static void main(String[] args){
    
    
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");

        for (String str : linkedHashSet) {
    
    
            System.out.println(str);
        }
    }
}

TreeSet集合：
该类实现了Set接口，可以实现排序等功能。
元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体方式取决于构造方法。
TreeSet():根据其元素的自然顺序进行排序
TreeSet(Comparator comparator):根据指定的比较器进行排序
没有带索引的方法，所以不能使用普通for循环遍历。
由于是Set集合，所以不包含重复元素的集合。
同样可以参考官方文档：TreeSet

import java.util.TreeSet;

public class TreeSetDemo {
    
    
    public static void main(String[] args){
    
    
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(10);
        treeSet.add(20);
        treeSet.add(100);
        treeSet.add(25);
        treeSet.add(15);
        treeSet.add(100);
        treeSet.add(200);

        for (Integer number: treeSet){
    
    
            System.out.println(number);
        }
    }
}

输出结果：

如果一个学生对象（姓名，年龄）按照年龄从小到大排序，年龄相同时按照姓名的字母顺序进行排序，需要重写compareTo(to)方法：

public int compareTo(Student s){
    
    
	int num = this.age - s.age;
	int num2 = num == 0 ? this.name.compareTo(s.name):num;
	return num2;
}

同样也可以采用比较器Comparator进行排序，重写compare()方法：

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    
    
    public static void main(String[] args){
    
    
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>(){
    
    
			@override
			public int compare(Student s1, Student s2){
    
    
				int num = s1.getAge() - s2.getAge();
				int num2 = num == 0 ? s.getName.compareTo(s2.getName)) : num;
				return num2;
			}
		});
    }
}

练习题：随机产生在1-20之间的10个不重复的数。

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class TreeSetRandom {
    
    
    public static void mian(String[] args){
    
    
        Set<Integer> set = new HashSet<>();

        Random random = new Random();

        while (set.size() < 10){
    
    
            //产生一个随机数，添加到集合
            int number = random.nextInt(20) + 1; //1-20的随机数
            set.add(number);
        }

        for (Integer integer : set){
    
    
            System.out.println(integer);
        }
    }
}

Map集合

铛铛铛铛，重中之重的map来啦！
现附上官方文档链接： Map
首先讲解HashMap，官方文档： HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null；允许多条记录的值为 Null；不支持线程同步。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMapDemo {
    
    
    public static void main(String[] args){
    
    
        HashMap<String,String> map = new HashMap<>();
        map.put("1","hello");
        map.put("2","world");
        map.put("3","java");

		 //根绝键删除键值对元素
        map.remove("1");

        //判断集合是否包含指定的键
        map.containsKey("1");

        //判断集合是否包含指定的值
        map.containsValue("Java");

        //判断集合是否为空
        System.out.println(map.isEmpty());
        
        //Map遍历方式
        //第一种：普遍使用，二次取值
        System.out.println("通过Map.keySet遍历key和value：");
        for (String key : map.keySet()){
    
    
            System.out.println("key= " + key + " and value=" + map.get(key));
        }

        //第二种
        System.out.println("通过Map.entrySet使用iterator遍历key和value");
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()){
    
    
            Map.Entry<String,String> entry = it.next();
            System.out.println("key= " + entry.getKey() + " and value= "+ entry.getValue());
        }

        //第三种：推荐，尤其是容量大时
        System.out.println("通过Map.entrySet遍历key和value");
        for (Map.Entry<String,String> entry : map.entrySet()){
    
    
            System.out.println("key= " + entry.getKey() + " and value = " +entry.getValue());
        }

        //第四种
        System.out.println("通过Map.value()遍历所有的value，但不能遍历key");
        for (String v : map.values()){
    
    
            System.out.println("value= " + v);
        }
    }
}

有关HashMap源码的详解也可以查看自己的另外一篇博客：HashMap源码详解

再来讲解LinkedHashMap，同样可以参考官方文档：LinkedHashMap
LinkedHashMap也是一个HashMap,但是内部维持了一个双向链表,可以保持顺序。
用法基本上和HashMap是类似的，就不做过多的讲解。
如果想更多了解LinkHashMap，可以参考这篇文章，相对容易理解，但是是基于jdk1.7的：LinkHashMap详解

再来讲解TreeMap，同样可以参考官方文档：TreeMap
TreeMap 可以用于排序, 默认根据其键的自然顺序来排序的，或者根据Comparator在映射创建时提供的来排序，这取决于所使用的构造函数。
如何选择合适的Map
HashMap可实现快速存储和检索，但其缺点是其包含的元素是无序的，这导致它在存在大量迭代的情况下表现不佳。
LinkedHashMap保留了HashMap的优势，且其包含的元素是有序的。它在有大量迭代的情况下表现更好。
TreeMap能便捷的实现对其内部元素的各种排序，但其一般性能比前两种map差。
LinkedHashMap映射减少了HashMap排序中的混乱，且不会导致TreeMap的性能损失。