Java集合框架

集合框架

程序开发并不是解决了业务的基本功能就完成了，很多时候程序运行的环境是有限制的。比如内存小，CPU频率低，或者是像手机这样的设备，能源供应有限。在这种环境下，就需要程序能够在有限的环境中提升效率。这就需要使用数据结构和算法。
但是数据结构与算法即便是学过，也未必在工作时能够用好，而且通用性、性能等等也都是问题。加上学习程序开发的受众群体越来越广，让程序员全部自己实现数据结构与算法不是一个好的主意。所以现在很多语言为了能够提升学习效率，降低学习门槛，同时也为了让程序有更好的执行效率和通用性，就自带了各种实现了数据结构与算法的API集合。在Java中，这就是我们现在要学习的「集合框架」与现在常见到的数据结构类库一样，Java也是将集合类库的接口（interface）与实现（implementation）分离。所以我们的学习方式一般都是先搞明白接口的分类和关系，然后根据不同的接口来学习对应的实现类。

使用集合做什么

1. 搬运数据，集合可以存储数据，然后通过API调用很方便就可以传递大量数据
2. 数据处理，集合中可以直接对数据进行操作，比如统计、去重

3. 排序，可以将数据按照需求进行各种排序，然后再传递给调用者

   
   
   
   
   

   Java的集合从 Collection 接口和 Map 接口入手

Map 接口和 Collection 没有交集，它有自己的方式，只要标准库后缀不是Map 结尾的，都是直接或者间接实现了Collection接口。

Collection 接口中常见的操作是数据的添加、删除

1. add / addAll
2. remove / removeAll / removeIf

借助 Iterator 接口，Collection 还具备了数据的循环

public interface Collection<E> extends Iterable<E>{ 
    //... 
    //  对数据循环
    Iterator<E> iterator();
}

通过 Iterable 接口， 标准库中的集合都可以使用 forEach 循环。

具体的实现类

集合类型	描述
ArrayList	一种可以动态增长和缩减的索引序列
LinkedList	一种可以在任何位置进行高效地插人和删除操作的有序序列
ArrayDeque	一种用循环数组实现的双端队列
HashSet	一种没有重复元素的无序集合
TreeSet	一种有序集
EnumSet	一种包含枚举类型值的集
LinkedHashSet	一种可以记住元素插人次序的集
PriorityQueue	一种允许高效删除最小元素的集合
HashMap	一种存储键/ 值关联的数据结构
TreeMap	一种键值有序排列的映射表
EnumMap	一种键值属于枚举类型的映射表
LinkedHashMap	一种可以记住腱/ 值项添加次序的映射表
WeakHashMap	一种其值无用武之地后可以被垃圾回收器回收的映射表
IdentityHashMap	一种用 == 而不是用equals 比较键值的映射表

Collection

Map

虽然类很多 ，但是我们在教授中只需要交几个类就可以了，分别是下面：

1. ArrayList
2. LinkedList
3. HashSet
4. HashMap
5. TreeMap

然后加上工具类2个：

1. Collections
2. Arrays

List

有序集合，可以精确控制列表中每个元素的插入位置。通过整数索引获取列表中的元素。List允许出现重复的值 ， 并可以精确控制列表中每个元素的插入位置，通过整数索引获取列表中的元素。

方法名	说明
add(E e)	增加单个数据
addAll(Collection<extends E> c)	将一个 Collection 集合的数据添加到现在的集合中
remove(Object o)	删除指定的元素
contains(Object o)	判断集合是否包含指定的元素
size()	得到集合的数据总数
isEmpty()	判断集合是否有数据
get(int index)	通过索引获取对应的数据元素
set(int index, E element)	通过索引和新的元素替换原有内容
clear()	清空数据
toArray()	将List转为对象数组

ArrayList

ArrayList 是List 接口的大小可变数组的实现。实现了所有可选列表操作， 并允许包括null 在内的所有元素。除了实现List 接口外， 此类还提供一些方法来操作内部用来存储列表的数组的大小（ 此类大致上等同于 vector 类， 但 vector 是同步的） 。

ArrayList 的底层是使用数组实现的，看下面的图

可以看到，数组中的每一个元素，都存储在内存单元中，并且元素之间紧密排列，既不能打乱元素的存储顺序，也不能跳过某个存储单元进行存储。

ArrayList 底层既然是使用数组实现，那么特点就和数组一致：查询速度快，增删速度慢

每个ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小， 它总是至少等于列表的大小。随着向Array L ist 中小断添加元素， 其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。我们可以使用默认构造函数创建容量为 10 的列表， 也可以初始化指定容量大小。

ArrayList 指定初始容量大小的构造器方法

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}

常用的操作

public static void main(String[] args) {

    ArrayList<Integer> list = new ArrayList<>();

    //  添加数据
    list.add(123);
    list.add(346);

    //  替换数据
    list.set(1, 777);

    //  将list中的所有数据放到 list2 中
    List<Integer> list2 = new ArrayList<>();
    list2.addAll( list );

    //  循环list2中所有的数据
    for (Integer integer : list2) {

        System.out.println( integer );

        //  删除循环出的对象
        list2.remove(integer);
    }

    //  list 集合是否有数据
    if( !list.isEmpty() ) {

        System.out.println("list.size = "+ list.size());

        //  清空 list
        list.clear();
    }

    //  在清空list后，再看list现在有多少数据
    System.out.println("list.size = "+ list.size());
}

    DEFAULT_CAPACITY = 10   默认容量 = 10  初始化容量
    

LinkedList

LinkedList 是一个链表结构，可当作堆栈、队列、双端队列 。链表是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。

单链表

单向链表的每一个节点包含两部分，一部分是存放数据的变量data，另一部分是指向下一个节点的指针next。正如地下党的联络方式，一级一级，单线传递：

private static class Node {
    int data;
    Node next;
}

双链表

双向链表比单向链表稍微复杂一些，它的每一个节点除了拥有data和next指针，还拥有指向前置节点的prev指针

和数组不同，链表存储数据的时候，则采用了见缝插针的方式，链表的每一个节点分布在内存的不同位置，依靠next指针关联起来。这样可以灵活有效地利用零散的碎片空间。

LinkedList 做数据的添加和删除操作时速度很快，但是做查询的时候速度就很慢，这和 ArrayList 刚好相反。

适用 LinkedList 独有的方法，在集合前后做数据插入

public static void main(String[] args) {

    LinkedList<Integer> list = new LinkedList<>();

    list.add(123);
    //  添加相同的数据
    list.add(123);
    list.add(456);
    list.add(789);
    list.add(101);

    //  将数据 111 添加到 list 的末尾
    list.addLast(111);
    //  将数据 999 添加到 list的最前面
    list.addFirst(999);

    for (int i = 0; i < list.size(); i++) {
        System.out.println( list.get(i) );
    }

}

注意代码中声明和实现都是 LinkedList ， 如果声明的是 List 接口 ， addFirst 和 addLast 方法是不可见的

Set

Set 的特点是去重，如果相同的数据只会保留一个。集合内的数据是一个无序的状态，。当然也有例外，TreeSet就是有序的。

方法名	说明
add(E e)	增加单个数据
addAll(Collection<extends E> c)	将一个 Collection 集合的数据添加到现在的集合中
remove(Object o)	删除指定的元素
contains(Object o)	判断集合是否包含指定的元素
size()	得到集合的数据总数
isEmpty()	判断集合是否有数据
clear()	清空数据
toArray()	将List转为对象数组

可以看到，Set 和 List 中的方法都是相同的，作用也一致。但是 Set 是没有直接获取数据的方法。我们更多的时候使用的是 List 和 Map。

Has hSet 由哈希表（ 实际上是一个HashM ap 实例） 支持， 为基木操作提供了稳定性能， 这些基本操作包括add() 、remove() 、contains() 和size() ， 假定哈希函数将这些元素正确地分布在桶中。对此 set() 进行迭代所需的时间与HashSet 实例的大小（ 元素的数量） 和底层HashMap 实例（ 桶的数量）的“ 容量” 的和成比例。因此， 如果迭代性能很重要， 则不要将初始容量没置得太高（ 或将加载因了设置得太低） 。

public static void main(String[] args) {

    HashSet set = new HashSet<>();
        
    set.add( new Object() );
    set.add( new Object() );
    set.add( "hello" );
    set.add( "hello" );
    set.add( "你好" );
    set.add( 123 );
    set.add( 123 );
    set.add( 234 );
    set.remove("你好");
    set.remove( new Object() );
    for (Object object : set) {
        System.out.println( object );
    }
}

以上代码经输出可以看到：输出的内容没有按照输入时的顺序进行输出。

李四
8890
张三
azxcv
ABC

TreeSet

Set 集合中的另类，存储的数据时有序的

public static void main(String[] args) {

    TreeSet<String> set = new TreeSet<>();
    set.add("8890");
    set.add("123");
    set.add("张三");
    set.add("李四");
    set.add("ABC");
    set.add("azxcv");

    for (String string : set) {
        System.out.println( string );
    }
}

输出的结果：

123
8890
ABC
azxcv
张三
李四

可以发现数据是按照数字、大写字母、小写字母、汉字进行排序的，但是汉字相关的数据本身没有排序，可以尝试将李四放在张三的数据上面看输出的结果。

Map

Map 是一种把键对象和值对象进行关联的容器， 而一个值对象又可以是一个Map, 依次类推，这样就可形成一个多级映射。

想想学习英语使用的词典软件，输入英文（key）后，软件会显示出对应的中文（value）。Map就是在内存中的这种结构。

Key（键）：

1. 和 set— 样，键对象不允许重复，这是为了保持查找结果的一致性。 如果有两个键对象一样， 那你想得到那个键对象所对应的值对象时就有问题了。
2. 在使用过程中某个键所对应的值对象可能会发生变化， 这时会按照最后一次修改的值对象与键对应（就是key同一个key有多次值绑定，最后一个就会覆盖之前的）
3. 可以使用 null 作为 Key

Value（值）:

1. 值对象没有唯一性的要求， 你可以将任意多个键都映射到一个值对象上， 这不会发生任何问题（ 不过对使用却可能会造成不便， 你不知道你得到的到底是那一个键所对应的值对象，所以请不要这样做）
2. 可以使用 null 作为 Value

Map 有两种比较常用的实现： HashMap 和 TreeMap

常用的方法

方法名	说明
put(key , value)	储存数据
get(key)	通过key得到值
remove(key)	通过key删除对应的值（key当然也会删除）
entrySet()	获取Map所有的Key，返回一个Set集合
values()	获取Map所有的value，返回一个List 集合
containsKey(key)	判断Map中是否有输入的参数：key
containsValue(value)	判断Map中是否有输入的参数：value
size()	判断Map中数据的总数
clear()	清空Map中所有的数据
isEmpty()	判断Map中是否有数据

HashMap

HashMap 用到了哈希码的算法， 以便快速查找一个键。

public static void main(String[] args) {

    HashMap<String, String> zsInfo = new HashMap<>();

    zsInfo.put("name", "张三");
    zsInfo.put("height", "173CM");
    zsInfo.put("sex", "男性");

    for (Map.Entry<String, String> info : zsInfo.entrySet()) {
        System.out.println( info );
    }
}
    DEFAULT_INITIAL_CAPACITY = 1 << 4   默认的初始化容量 = 2^4 =16
    aka: Also Known As  也被称作
    DEFAULT_LOAD_FACTOR = 0.75f 默认加载因子 = 0.75 = 75%
    TREEIFY_THRESHOLD = 8       树化_阈值 = 8 

TreeMap

TreeMap 是对键按序存放， 因此它便有一些扩展的方法， 比如 firstKey() 、lastKey() 等， 可以从TreeMap 中指定一个范围以取得其子Map

public static void main(String[] args) {

    TreeMap<String, String> tree = new TreeMap<>();

    tree.put("name", "Jack");
    tree.put("age", "22");
    tree.put("身高", "173");
    tree.put("sex", "man");
    tree.put("体重", "70KG");

    System.out.println("-------------------");
    for (Map.Entry<String, String> entry : tree.entrySet()) {
        System.out.println( entry );
    }
    System.out.println("-------------------");

    System.out.println("firstKey = "+ tree.firstKey());
    System.out.println("firstEntry = "+ tree.firstEntry());
    System.out.println("lastKey = "+ tree.lastKey());
    System.out.println("lastEntry = "+ tree.lastEntry());

}   

数组、List、Set、Map的数据转换

不同类型的集合相互转换在程序开发中都是非常常见的 API 操作，这些基础操作一定要熟悉。

数组转 List

/*
 * 数组转List，但是这里要注意，Arrays.asList方法转出来的虽然也叫ArrayList，
 * 但不是java.util.ArrayList，而是Arrays中的一个内部类ArrayList。两者之间并不相等。
 * 内部类ArrayList没有实现remove、add等方法，使用的话会报错。
 */
System.out.println("使用Arrays.asList将数组转换为List--------------------------------");
String str[] = { "中文", "计算机", "ABC", "123", "qq@qq.com" };

List<String> strList = Arrays.asList(str);

for (String string : strList) {
    System.out.println(string);
}

System.out.println("使用ArrayList构造器方式再由Arrays.asList将数组转换为List----------");
// 使用下面的代码的写法就不会有问题了。
ArrayList<String> stringsList = new ArrayList<String>(Arrays.asList(str));
// 使用remove方法
stringsList.remove(3);

for (String string : stringsList) {
    System.out.println(string);
}

System.out.println("使用List.toArray方法将一个List转换为数组(默认为Object数组)----------");
Object[] strArr = stringsList.toArray();
for (Object object : strArr) {
    System.out.println(object.toString());
}

数组和Set

System.out.println("使用Arrays.asList将数组转换为List--------------------------------");
String str[] = { "中文", "计算机", "ABC", "123", "qq@qq.com" };

System.out.println("下面是数组转Set ----------------------------------");

Set<String> strSet = new HashSet<String>(Arrays.asList(str));
for (String string : strSet) {
    System.out.println(string);
}
System.out.println("下面是将Set集合转换为数组-------------");
Object[] objArr = strSet.toArray();
for (Object string : objArr) {
    System.out.println(string);
}

从Map中得到Set和List

Map<String, String> map = new HashMap<String, String>();
map.put("1", "A");
map.put("2", "B");
map.put("3", "C");

// 输出所有的key , keySet()方法其实返回的就是一个Set集合。
System.out.println("通过keySet输出所有的key：" + map.keySet());

// 把map的值转为一个List
List<String> stringList = new LinkedList<String>(map.values());
for (String string : stringList) {
    System.out.print(string + " ");
}

散列表（哈希表）的基本原理

上面 HashSet 和 HashMap 都使用了 散列表来做数据的检索，那么什么是散列表 ，这个又有什么优点呢 ？

散列表也叫作哈希表（hash table），这种数据结构提供了键（Key）和值（Value）的映射关系。只要给出一个Key，就可以高效查找到它所匹配的Value，时间复杂度接近于O(1)。

是不是想到了 Map ？

散列表是如何根据Key来快速找到它所匹配的 Value 呢 ？

在目前所学的数据结构中，数组的查询效率是最高的。散列表本质就是一个数组。不同的是数组的下标是数字，但是散列表的下标是字符串。这就需要设计一个中转站，通过某种方式，把Key和数组下标进行转换。这个中转站就叫作哈希函数。

在不同的语言中，哈希函数的实现是不一样的。我们以Java的HashMap为例，来看看哈希函数的实现。

在Java及大多数面向对象的语言中，每一个对象都有属于自己的hashcode，这个hashcode是区分不同对象的重要标识。无论对象自身的类型是什么，它们的hashcode都是一个整型变量。

既然都是整型变量，想要转化成数组的下标也就不难实现了。最简单的转化方式是什么呢？是按照数组长度进行取模运算

index = HashCode (Key) % Array.length

其实JDK中的哈希函数为了提升效率，使用的是位运算。我们就假设使用的是模运算

通过哈希函数，我们可以把字符串或其他类型的Key，转化成数组的下标index。如给出一个长度为8的数组，则当
key=001121时

index = HashCode ("001121") % Array.length = 1420036703 % 8 = 7

而当key=this时，

index = HashCode ("this") % Array.length = 3559070 % 8 = 6

散列表的读写操作

有了哈希函数，就可以在散列表中进行读写操作了。

写操作（put）

写操作就是在散列表中插入新的键值对（在JDK中叫作Entry）。如调用hashMap.put("002931", "王五")，意思是插入一组Key为002931、Value为王五的键值对。具体该怎么做呢？

1. 通过哈希函数，把Key转化成数组下标5。

2. 如果数组下标5对应的位置没有元素，就把这个Entry填充到数组下标5的位置
   

   
   
   由于数组的长度是有限的，当插入的Entry越来越多时，不同的Key通过哈希函数获得的下标有可能是相同的。例如002936这个Key对应的数组下标是2；002947这个Key对应的数组下标也是2。
   
   
   这种情况，就叫作哈希冲突

解决哈希冲突的方法主要有两种，一种是开放寻址法，一种是链表法

1. 开放寻址法的原理很简单，当一个Key通过哈希函数获得对应的数组下标已被占用时，我们可以“另谋高就”，寻找下一个空档位置

2. HashMap数组的每一个元素不仅是一个Entry对象，还是一个链表的头节点。每一个Entry对象通过next指针指向它的下一个Entry节点。当新来的Entry映射到与之冲突的数组位置时，只需要插入到对应的链表中即可

   
   
   

读操作（get）

读操作就是通过给定的Key，在散列表中查找对应的Value。例如调用 hashMap.get("002936")，意思是查找Key为002936的Entry在散列表中所对应的值

1. 通过哈希函数，把Key转化成数组下标2。
2. 找到数组下标2所对应的元素，如果这个元素的Key是002936，那么就找到了；如果这个Key不是002936也没关系，由于数组的每个元素都与一个链表对应，我们可以顺着链表慢慢往下找，看看能否找到与Key相匹配的节点。

Iterator

iterator是为了实现对Java容器（collection）进行遍历功能的一个接口。
在iterator实现了Iterator接口后，相当于把一个Collection容器的所有对象，做成一个线性表（List），而iterator本身是一个指针，开始时位于第一个元素之前。

方法	说明
hasNext()	判断 iterator 内是否存在下1个元素，如果存在，返回true，否则返回false。（注意，这时上面的那个指针位置不变）
next()	返回 iterator 内下1个元素，同时上面的指针向后移动一位。如果不断地循环执行next()方法，就可以遍历容器内所有的元素了
remove()	删除 iterator 内指针的前1个元素，前提是至少执行过1次next()

遍历1个ArrayList 和Linklist是十分容易的，遍历1个Tree容器也不难，但是实现机制是完全不同，而遍历1个Set容器就无从下手了。
Iterator 这个接口让各种容器自己去重写里面的hasNext()和next()方法。 不用关心各种容器的遍历机制，只要使用Iterator，会让人觉得各种容器的遍历方法都是一样的，这就是Java接口的重要意义。

HashMap zsInfo = new HashMap<>();

zsInfo.put("name", "张三");
zsInfo.put("height", "173CM");
zsInfo.put("sex", "男性");
zsInfo.put("skin-color", "白色");

zsInfo.put("height", "183CM");
zsInfo.remove("skin-color");

System.out.println("Iterator 循环------------------");
Iterator iterator = zsInfo.entrySet().iterator();

while( iterator.hasNext() ) {
    Map.Entry next = (Entry) iterator.next();
    System.out.println( next );
}

Collections

Collections 是 Java 提供对Set 、List 和Map 等集合操作的工具类。

该工具类里提供了大量方法，除了对集合元素进行排序、查询和修改等操作；还提供了将集合对象设置为不可变、对集合对象实现同步控制等方法。

排序

ArrayList nums = new ArrayList<>();
nums.add(2);
nums.add(0);
nums.add(-5);
nums.add(0);
nums.add(3);
System.out.println( nums );
Collections.reverse( nums );
System.out.println( nums);

Collections.sort( nums );
System.out.println( nums );

Collections.shuffle( nums );
System.out.println( nums );

查找

ArrayList nums = new ArrayList<>();
nums.add(2);
nums.add(0);
nums.add(-5);
nums.add(0);
nums.add(3);
System.out.println( nums );

System.out.println( Collections.max( nums ));
System.out.println( Collections.min( nums ));
Collections.replaceAll(nums, 0 , 1);
System.out.println( nums );

System.out.println( Collections.frequency(nums, 1));

Collections.sort(nums);
System.out.println( nums );

System.out.println( Collections.binarySearch(nums, 3 ));

排序（书中没有写，但是课堂上要教授）

集合的排序有2种方式：

1. 集合内部就拥有排序的能力。

   需要排序的能力的类实现 Comparable 接口的方法

2. 集合本身没有排序的能力，可以通过外部指定排序的方式。

   在排序方法中，指定一个实现了 Comparator 接口的类的对象

Comparable是需要比较的对象来实现接口。这样对象调用实现的方法来比较。对对象的耦合度高（需要改变对象的内部结构，破坏性大）。

Comparator相当于一通用的比较工具类接口。需要定制一个比较类去实现它，重写里面的compare方法，方法的参数即是需要比较的对象。对象不用做任何改变，解耦。

List 集合排序

List<Integer> list = new ArrayList<Integer>();

list.add(123);
list.add(999);
list.add(101);
list.add(33);
list.add(76);

Collections.sort(list);

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

直接就可以得到自然升序，我们在上面的代码中没有看到任何接口，原因是List集合中的 Integer 类本身就实现了 Comparable 接口

public final class Integer extends Number implements Comparable<Integer> {
    //...
}

TreeMap 排序

treeMap 的示例中，我们使用了外部指定排序方式：Comparator

TreeMap<String, String> tree = new TreeMap<>(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o2.compareTo(o1) ;   // 
    }
});

tree.put("name", "Jack");
tree.put("age", "22");
tree.put("身高", "173");
tree.put("sex", "man");
tree.put("体重", "70KG");

System.out.println("-------------------");
for (Map.Entry<String, String> entry : tree.entrySet()) {
    System.out.println( entry );
}

自定义类排序

当我们自定义了一个类，也希望能够进行排序的话，就需要实现 Comparator接口或者是 Comparable 接口了。

public class User {
    private Integer uid;
    private String uname;
    //....
}

外部指定排序

User 类没有实现 Comparable 接口，通过 Collections 工具类的 sort 方法进行排序，在 sort 方法的第二个参数上指定排序的规则

List<User> list = new ArrayList<User>();

list.add( new User(110 ,"Mark") );
list.add( new User(101 ,"李四") );
list.add( new User(100 ,"张三") );
list.add( new User(111 ,"Jack") );

//  Comparator 接口因为是外部排序，所以需要知道对比的2个对象
Collections.sort(list , new Comparator<User>() {
    @Override
    public int compare(User o1, User o2) {
        return o2.getUid() - o1.getUid() ;
    }
});

for (User user : list) {
    System.out.println( user );
}

本身拥有排序

因为是内部排序，所以只需要传入被排序的对象即可，另一个排序对象当然是对象本身，使用 this 指向即可。

public class User implements Comparable<User> {

    private Integer uid;
    private String uname;

    public User(int i, String string) {
        this.uid = i;
        this.uname = string;
    }

    @Override
    public int compareTo(User o) {
        return this.getUid() - o.getUid() ;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    @Override
    public String toString() {
        return "User [uid=" + uid + ", uname=" + uname + "]";
    }
}

排序

List<User> list = new ArrayList<User>();

list.add( new User(110 ,"Mark") );
list.add( new User(101 ,"李四") );
list.add( new User(100 ,"张三") );
list.add( new User(111 ,"Jack") );

Collections.sort(list);

for (User user : list) {
    System.out.println( user );
}

输出结果

User [uid=100, uname=张三]
User [uid=101, uname=李四]
User [uid=110, uname=Mark]
User [uid=111, uname=Jack]