资料来源：https://www.bilibili.com/video/BV1do4y1f7GL?p=210
https://www.bilibili.com/video/BV1do4y1f7GL?p=257&spm_id_from=pageDriver

一、Java集合框架概述

1. 集合概述

一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态地把多个对象的引用放入容器中。这里的存储指的是内存层面的存储，而不是持久化存储。
Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。
1）集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中）
2）数组在存储多个数据方面的特点：

  1.   - 一旦初始化以后，其**长度就确定**了。
  2.   - 数组一旦定义好，其**元素的类型也就确定**了。我们也就只能操作指定类型的数据了。
  4.         比如：String[] arr;  int[] arr1;  Object[] arr2;<br />3）数组在存储多个数据方面的缺点：
  6.   - 一旦初始化以后，其长度就不可修改，不便于扩展。
  7.   - 数组中提供的**方法非常有限**，对于添加、**删除、插入数据等操作效率低**
  8.   - 数组没有现成的属性或方法可用于获取数组中实际元素的个数的需求
  9.   - 数组存储数据的特点：**有序、可重复**。对于无序、不可重复的需求，不能满足。

4）Java集合可分为Collection和Map两种体系

  1.   - Collection接口：单列集合，定义了存取一组对象的方法的集合
  3.              List：元素有序、可重复的集合   --- “动态”数组<br />                 Set：元素无序、不可重复的集合  ---  高中讲的“集合”
  5.   - Map接口：双列集合，保存具有映射关系“key-value对”的集合    ---  高中函数：y = f(x)

2. 集合的使用场景

image.png

3. Collection接口继承树

image.png

4. Map接口继承树

image.png

二、Collection接口方法

常用方法1：add、size、clear、isEmpty

  1. // 创建对象：接口不能创建对象，利用实现类创建对象
  2. Collection coll = new ArrayList();
  4. // 1、add(Object e)：将元素e添加到集合coll中
  5. coll.add("AA");
  6. coll.add("BB");
  7. coll.add(123);         // 自动装箱：只能存放引用数据类型，不能是基本数据类型
  8. coll.add(new Date());
  10. // 2、size():获取添加的元素的个数
  11. System.out.println(coll.size());     //4
  13. // 3、addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中
  14. Collection coll1 = new ArrayList();
  15. coll1.add(456);
  16. coll1.add("CC");
  17. coll.addAll(coll1);
  19. System.out.println(coll.size());    //6
  20. System.out.println(coll);            //[AA, BB, 123, Sat Jul 31 09:51:56 CST 2021, 456, CC]
  22. // 4、clear()：清空集合元素
  23. coll.clear();
  25. // 5、isEmpty()：判断当前集合是否为空
  26. System.out.println(coll.isEmpty());     //true

常用方法2：contains、containsAll

  1. // 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
  2. Collection coll = new ArrayList();
  3. coll.add(123);
  4. coll.add(456);
  5. Person p = new Person("kid",30);
  6. coll.add(p);
  7. coll.add(new Person("Jerry",20));
  8. coll.add(new String("Tom"));
  9. coll.add(false);
  11. // 1.contains(Object obj)：判断当前集合中是否包含obj
  12. // 我们在判断时会调用obj对象所在类的equals()
  13. boolean contains = coll.contains(123);
  14. System.out.println(contains);                           //true
  15. System.out.println(coll.contains(new String("Tom")));   //true
  16. System.out.println(coll.contains(p));                   //true
  17. System.out.println(coll.contains(new Person("kid",30)));   //false -->true （重写equals方法，输出true）
  19. // 2.containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中
  20. Collection coll1 = Arrays.asList(123,"Tom");
  21. System.out.println(coll.containsAll(coll1));   //true 
  23. Collection coll1 = Arrays.asList(123,4567);
  24. System.out.println(coll.containsAll(coll1));   //false

常用方法3：remove、removeAll、retainAll、equals

  1. // 1.remove(Object obj)：从当前集合中移除obj元素。
  2. Collection coll = new ArrayList();
  3. coll.add(123);
  4. coll.add(456);
  5. coll.add(new Person("Jerry",20));
  6. coll.add(new String("Tom"));
  7. coll.add(false);
  9. coll.remove(123);
  10. System.out.println(coll);     //[456, Person{name='Jerry', age=20}, Tom, false]
  12. coll.remove(new Person("Jerry",20));
  13. System.out.println(coll);     //[456, Tom, false]
  15. // 2. removeAll(Collection coll1)：差集：从当前集合中移除coll1中所有的元素。
  16. Collection coll1 = Arrays.asList(123,456);
  17. coll.removeAll(coll1);
  18. System.out.println(coll);     //[Tom, false]
  20. Collection coll = new ArrayList();
  21. coll.add(123);
  22. coll.add(456);
  23. coll.add(new Person("Jerry",20));
  24. coll.add(new String("Tom"));
  25. coll.add(false);
  27. // 3.retainAll(Collection coll1)：交集：获取当前集合和coll1集合的交集，并返回给当前集合
  28. Collection coll1 = Arrays.asList(123,456,789);
  29. coll.retainAll(coll1);
  30. System.out.println(coll);    // [123, 456]
  32. // 4.equals(Object obj)：要想返回true，需要当前集合和形参集合的元素都相同
  33. Collection coll2 = new ArrayList();
  34. coll2.add(456);
  35. coll2.add(123);
  36. coll2.add(new Person("Jerry",20));
  37. coll2.add(new String("Tom"));
  38. coll2.add(false);
  40. System.out.println(coll.equals(coll2));    //false（ArrayList有序导致，若为hashSet则为true）

常用方法4：toArray、asList

  1. Collection coll = new ArrayList();
  2. coll.add(123);
  3. coll.add(456);
  4. coll.add(new Person("Jerry",20));
  5. coll.add(new String("Tom"));
  6. coll.add(false);
  8. // 1、集合 ---> 数组：toArray()
  9. Object[] arr = coll.toArray();
  10. for(int i = 0; i < arr.length; i++){
  11.      System.out.println(arr[i]);
  12. }
  14. // 2、拓展：数组 ---> 集合：调用Arrays类的静态方法asList()
  15. List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
  16. System.out.println(list);            // [AA, BB, CC]
  18. List arr1 = Arrays.asList(new int[]{123, 456});
  19. System.out.println(arr1.size());   // 1
  21. List arr2 = Arrays.asList(new Integer[]{123, 456});
  22. System.out.println(arr2.size());   // 2
  24. List arr3 = Arrays.asList(123, 456);
  25. System.out.println(arr3.size());   // 2

三、Iterator迭代器接口

1. Iterator概述

1）Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
2）GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。
3）Collection接口继承java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
4）Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建Iterator对象，则必须有一个被迭代的集合。
5）集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前

2. Iterator的使用

在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常

  1. Collection coll = new ArrayList();
  2. coll.add(123);
  3. coll.add(new Person("Jerry",20));
  4. coll.add(new String("Tom"));
  5. coll.add(false);
  7. Iterator iterator = coll.iterator();
  9. // 方式一：
  10. System.out.println(iterator.next());
  11. System.out.println(iterator.next());
  12. System.out.println(iterator.next());
  13. System.out.println(iterator.next());
  14. System.out.println(iterator.next());
  16. // 报异常：NoSuchElementException
  17. System.out.println(iterator.next());
  20. // 方式二：不推荐
  21. for(int i = 0; i < coll.size(); i++){
  22.     System.out.println(iterator.next());
  23. }
  26. // 方式三：推荐
  27. // hasNext()：判断是否还有下一个元素
  28. while(iterator.hasNext()){
  29.     //next()：① 指针下移 ② 将下移以后集合位置上的元素返回
  30.     System.out.println(iterator.next());
  31. }

3. Iterator的执行原理

image.png

4. 遍历集合的两种错误写法

  1. Collection coll = new ArrayList();
  2. coll.add(123);
  3. coll.add(456);
  4. coll.add(new Person("Jerry",20));
  5. coll.add(new String("Tom"));
  6. coll.add(false);
  8. // 错误方式一：
  9. Iterator iterator = coll.iterator();
  10. while((iterator.next()) != null){
  11.     System.out.println(iterator.next());   //456、Tom（跳着输出），同时报错NoSuchElementException
  12. }
  14. // 错误方式二：
  15. // 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
  16. while (coll.iterator().hasNext()){
  17.     System.out.println(coll.iterator().next());  //无限输出第一个元素123
  18. }

5. remove()方法

1）Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对的remove方法。
2）如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。

  1. Collection coll = new ArrayList();
  2. coll.add(123);
  3. coll.add(456);
  4. coll.add(new Person("Jerry",20));
  5. coll.add(new String("Tom"));
  6. coll.add(false);
  8. // 删除集合中"Tom"
  9. Iterator iterator = coll.iterator();
  10. while (iterator.hasNext()){
  11. //  iterator.remove();               // 报错IllegalStateException
  12.     Object obj = iterator.next();
  13.     if("Tom".equals(obj)){
  14.         iterator.remove();
  15. //      iterator.remove();           // 报错IllegalStateException
  16.     }
  17. }
  19. // 遍历集合
  20. iterator = coll.iterator();          // 回到起点
  21. while (iterator.hasNext()){
  22.     System.out.println(iterator.next());
  23. }

6. foreach循环（增强for循环）

1）Java 5.0 提供了 foreach 循环迭代访问 Collection和数组。
2）遍历操作不需获取Collection或数组的长度，无需使用索引访问元素。
3）遍历集合的底层调用Iterator完成操作。
4）foreach还可以用来遍历数组。

  1. Collection coll = new ArrayList();
  2. coll.add(123);
  3. coll.add(456);
  4. coll.add(new Person("Jerry",20));
  5. coll.add(new String("Tom"));
  6. coll.add(false);
  8. // for(集合元素的类型 局部变量 : 集合对象)
  9. for(Object obj : coll){
  10.     System.out.println(obj);
  11. }
  13. int[] arr = new int[]{1,2,3,4,5,6};
  14. // for(数组元素的类型 局部变量 : 数组对象)
  15. for(int i : arr){
  16.     System.out.println(i);
  17. }
  20. String[] arr = new String[]{"MM","MM","MM"};
  22. //方式一：普通for赋值
  23. for(int i = 0;i < arr.length;i++){
  24.     arr[i] = "GG";
  25. }
  27. for(int i = 0;i < arr.length;i++){
  28.     System.out.println(arr[i]);      //GG、GG、GG
  29. }
  32. String[] arr1 = new String[]{"MM","MM","MM"};
  34. //方式二：增强for循环
  35. for(String s : arr1){
  36.     s = "DD";
  37. }
  39. for(int i = 0;i < arr1.length;i++){
  40.     System.out.println(arr1[i]);     //MM、MM、MM
  41. }

7. ListIterable迭代器

解决迭代器对象与list对象同时操作集合而产生的并发修改异常。
ListIterable：迭代和添加元素操作都是考ListIterable对象来完成
image.png

  1. ArrayList<String> list = new ArrayList<>();
  2. list.add("aa");
  3. list.add("bb");
  4. list.add("cc");
  6. // 在"bb"之后添加一个字符串"kk"
  7. ListIterator<String> it = list.listIterator();
  8. while (it.hasNext()){
  9.     if("bb".equals(it.next())){
  10.         list.add("kk");
  11.     }
  12. }
  15. // 逆向遍历
  16. while (it.hasPrevious()){
  17.     System.out.println(it.previous());
  18. }

8. 面试题

7.1 Iterable接口、iterator方法、Iterator接口之间的关系
image.png
7.2 迭代器中hasNext()、next()的具体实现
image.png

四、Collection子接口一：List

1. List接口概述

1）鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
2）List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引
3）List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中元素

JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector
相同点：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同点：

  • ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
  • LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储

  • Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

    2. List实现类一：ArrayList

    1) ArrayList 是 List 接口的典型实现类、主要实现类
    2) 本质上，ArrayList是对象引用的一个”变长”数组
    3) ArrayList的JDK1.8之前与之后的实现区别？

    1. - JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组
    2. - JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，**当添加第一个元素时再创建一个始容量为10的数组**

4）建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
5）Arrays.asList(…)方法返回的List集合，既不是ArrayList实例，也不是Vector实例。 Arrays.asList(…)返回值是一个固定长度的List集合
image.png
6）JDK1.7原理解析

  1. // 底层创建了长度是10的Object[]数组elementData
  2. ArrayList list = new ArrayList();   
  4. list.add(123);        // elementData[0] = new Integer(123);
  5. .....
  6. list.add(11);        // 如果此次的添加导致底层elementData数组容量不够，则扩容。
  8. 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
  10. 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

image.png
image.png
image.png
7）JDK1.8原理解析

  1. // 底层Object[] elementData初始化为{}.并没有创建长度为10的数组
  2. ArrayList list = new ArrayList();
  4. // 第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
  5. list.add(123);
  6. ...
  8. 后续的添加和扩容操作与jdk 7 无异

image.png
image.png

3. List实现类二：LinkedList

1）对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
2）LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。
同时，定义内部类Node，作为LinkedList中保存数据的基本结构。
3）Node除了保存数据，还定义了两个变量：

  • prev变量记录前一个元素的位置
  • next变量记录下一个元素的位置

image.png

3.1 常用方法

增加：addFirst(E e) addLast(E e) offer(E e) offerFirst(E e) offerLast(E e)
删除：removeFirst(E e) removeLast(E e) poll(E e) pollFirst(E e) pollLast(E e)
查看：element getFirst(E e) getLast(E e) indexOf(Object o)
lastIndexOf(Object o) peek() peekFirst() peekLast() 

  1. LinkedList<String> list = new LinkedList<>();
  3. list.addFirst("aa");         // 添加元素在头部
  4. list.addFirst("bb");
  6. list.addLast("dd");          // 添加元素在尾部
  7. list.addLast("ee");
  8. System.out.println(list);   // [bb, aa, dd, ee]
  10. System.out.println("--------------------------");
  11. list.clear();
  13. list.offer("11");            // 添加元素在尾部
  14. list.offer("22");
  15. list.offer("33");
  17. list.offerFirst("44");       // 添加元素在头部
  18. list.offerFirst("55");
  19. list.offerFirst("66");
  21. list.offerLast("77");        // 添加元素在尾部
  22. list.offerLast("88");
  23. list.offerLast("99");
  24. list.offerLast("88");                      // 删除尾部的元素并将元素输出
  25. System.out.println(list);                // [66, 55, 44, 11, 22, 33, 77, 88, 99, 88]
  27. System.out.println(list.poll());         // 66：删除头上的元素并将元素输出
  28. System.out.println(list.pollFirst());    // 55：删除头上的元素并将元素输出
  29. System.out.println(list.pollLast());     // 88：删除尾部的元素并将元素输出
  31. System.out.println(list.removeFirst());  // 44
  32. System.out.println(list.removeLast());   // 99
  34. System.out.println(list);                // [11, 22, 33, 77, 88]
  36. list.clear();                            // 清空集合
  37. System.out.println(list);                // 返回：[]
  38. System.out.println(list.pollFirst());    // 返回：null，JDK1.6以后新出的方法，提高了代码健壮性
  39. System.out.println(list.removeFirst());  // 报错：java.util.NoSuchElementException

3.2 四种遍历方法

  1. // 普通for循环
  2. for (int i = 0; i < list.size(); i++){
  3.     System.out.println(list.get(i));
  4. }
  5. System.out.println("---------------");
  7. // 增强for循环
  8. for (String s : list){
  9.     System.out.println(s);
  10. }
  11. System.out.println("---------------");
  13. // 迭代器
  14. // 迭代器iterator对象需要整个方法执行结束后才被回收
  15. Iterator<String> iterator = list.iterator();
  16. while (iterator.hasNext()){
  17.     System.out.println(iterator.next());
  18. }
  19. System.out.println("---------------");
  21. // 迭代器it对象在for循环结束后就被回收了。节省内存
  22. for (Iterator<String> it = list.iterator(); it.hasNext() ;){
  23.     System.out.println(it.next());
  24. }

3.3 简要底层原理

image.png

  1. LinkedList list = new LinkedList(); // 内部声明了Node类型的first和last属性，默认值为null
  3. list.add(123);        // 将123封装到Node中，创建了Node对象。
  5. 其中，Node定义为：体现了LinkedList的双向链表的说法
  6.     // Node内部类
  7.     private static class Node<E> {
  8.         E item;                // 当前元素
  9.         Node<E> next;        // 指向下一个元素地址
  10.         Node<E> prev;        // 上一个元素地址
  12.         Node(Node<E> prev, E element, Node<E> next) {
  13.             this.item = element;
  14.             this.next = next;
  15.             this.prev = prev;
  16.         }
  17.     }

3.4 源码分析

  1. public class LinkedList<E>    extends AbstractSequentialList<E>
  2.                         implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
  3.     transient int size = 0;        // 集合中元素个数
  5.     transient Node<E> first;    // 链表首节点
  6.     transient Node<E> last;        // 链表尾结点
  8.     // Node内部类
  9.     private static class Node<E> {
  10.         E item;                // 当前元素
  11.         Node<E> next;        // 指向下一个元素地址
  12.         Node<E> prev;        // 上一个元素地址
  14.         Node(Node<E> prev, E element, Node<E> next) {
  15.             this.item = element;
  16.             this.next = next;
  17.             this.prev = prev;
  18.         }
  19.     }
  21.     // 空构造器
  22.     public LinkedList() {
  23.     }
  25.     // 添加元素操作
  26.     public boolean add(E e) {
  27.         linkLast(e);
  28.         return true;
  29.     }
  31.     void linkLast(E e) {    // 添加的元素e
  32.         // 将链表中last节点赋值给l，若是第一个元素，l为null
  33.         final Node<E> l = last;
  34.         // 将元素封装为一个Node具体的对象
  35.         final Node<E> newNode = new Node<>(l, e, null);
  36.         // 将链表的last节点指向新的创建的对象
  37.         last = newNode;
  38.         if (l == null)    // 如果添加的是第一个节点
  39.             first = newNode;    // 将链表的first节点指向为新节点
  40.         else
  41.             l.next = newNode;    // 将l的下一个指向为新的节点
  42.         size++;                    // 集合中元素数量加1操作
  43.         modCount++;
  44.     }
  46.     // 获取集合中元素数量
  47.     public int size() {
  48.         return size;
  49.     }
  51.     // 通过索引得到元素
  52.     public E get(int index) {
  53.         checkElementIndex(index);    // 健壮性考虑
  54.         return node(index).item;
  55.     }
  57.     Node<E> node(int index) {
  59.         // 若index在链表的前半段，则从前往后找
  60.         if (index < (size >> 1)) {
  61.             Node<E> x = first;
  62.             for (int i = 0; i < index; i++)
  63.                 x = x.next;
  64.             return x;
  65.         } else {
  66.             // 若index在链表的后半段，则从后往前找
  67.             Node<E> x = last;
  68.             for (int i = size - 1; i > index; i--)
  69.                 x = x.prev;
  70.             return x;
  71.         }
  72.     }
  73. }

4. List实现类三：Vector

Vector是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。
Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。
image.png
image.png

5. List接口方法

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。
1）void add(int index, Object ele)：在index位置插入ele元素
2）boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
3）Object get(int index)：获取指定index位置的元素

  1. ArrayList list = new ArrayList();
  2. list.add(123);
  3. list.add(456);
  4. list.add("AA");
  5. list.add(new Person("Tom",12));
  6. list.add(456);
  8. //void add(int index, Object ele)：在index位置插入ele元素
  9. list.add(1,"BB");              //[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
  10. System.out.println(list);
  12. boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
  13. List list1 = Arrays.asList(1, 2, 3);
  14. list.addAll(list1);
  15. // list.add(list1);       //把list1当做一个整体
  16. System.out.println(list.size());    //9
  18. // Object get(int index)：获取指定index位置的元素
  19. System.out.println(list.get(0));

4) int indexOf(Object obj)：返回obj在集合中首次出现的位置
5) int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
6) Object remove(int index)：移除指定index位置的元素，并返回此元素
7) Object set(int index, Object ele)：设置指定index位置的元素为ele
8) List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合

  1. ArrayList list = new ArrayList();
  2. list.add(123);
  3. list.add(456);
  4. list.add("AA");
  5. list.add(new Person("Tom",12));
  6. list.add(456);
  7. // int indexOf(Object obj)：返回obj在集合中首次出现的位置。如果不存在，返回-1.
  8. int index = list.indexOf(4567);
  9. System.out.println(index);
  11. //int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
  12. System.out.println(list.lastIndexOf(456));     //4
  14. //Object remove(int index)：移除指定index位置的元素，并返回此元素
  15. Object obj = list.remove(0);
  16. System.out.println(obj);        // 123
  17. System.out.println(list);       // [456, AA, Person{name='Tom', age=12}, 456]
  19. //Object set(int index, Object ele)：设置指定index位置的元素为ele
  20. list.set(1,"CC");
  21. System.out.println(list);       // [456, CC, Person{name='Tom', age=12}, 456]
  23. //List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的左闭右开区间的子集合
  24. List subList = list.subList(2, 4);
  25. System.out.println(subList);   // [Person{name='Tom', age=12}, 456]
  26. System.out.println(list);      // [456, CC, Person{name='Tom', age=12}, 456]

总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环

6. 面试题

1）remove(int index)和remove(Object obj)的区别

  1. public void testListRemove() {
  2.     List list = new ArrayList();
  3.     list.add(1);
  4.     list.add(2);
  5.     list.add(3);
  6.     updateList(list);
  7.     System.out.println(list);
  8. }
  10. private void updateList(List list) {
  11.     list.remove(2);                        // 删除索引为2的数据，结果为：[1, 2]
  12.     list.remove(new Integer(2));           // 删除数据为2的值，结果为：[1, 3]
  13. }

2）ArrayList/LinkedList/Vector的异同
(1) ArrayList和LinkedList的异同
二者都线程不安全，相对线程安全的Vector，执行效率高。
此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。
(2) ArrayList和Vector的区别
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。

五、Collection子接口二：Set

1. Set接口概述

1）Set接口是Collection的子接口，set接口没有提供额外的方法，使用的都是Collection中声明过的方法
2）Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败
3）Set判断两个对象是否相同不是使用 == 运算符，而是根据equals()方法
4）分类：

  • HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
  • LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。对于频繁的遍历操作，LinkedHashSet效率高于HashSet

  • TreeSet：可以按照添加对象的指定属性，进行排序

    2. 实现类一：HashSet

    2.1 HashSet概述

    Set的无序性和不可重复性

  • HashSet底层：数组+链表的结构

  • 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。（每次遍历的结果顺序相同）
  • 不可重复性：保证添加的元素按照equals()判断时，不能返回true（需重写equals方法、hashCode方法），即：相同的元素只能添加一个
  • HashSet集合判断两个元素相等的标准：两个对象通过hashCode()方法比较相等，并且两个对象的 equals()方法返回值也相等。
  • 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码” ```java Set set = new HashSet(); set.add(456); set.add(123);
    set.add(123); // 这个数据没有放入集合中 set.add(“AA”); set.add(“CC”); set.add(new User(“Tom”,12)); set.add(new User(“Tom”,12)); // 需要重写equals方法、hashCode方法才会当做相同元素 set.add(129);

Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); }

输出：AA、CC、129、456、123、User{name=’Tom’, age=12}

  1. <a name="wHeAd"></a>
  2. #### 2.2 HashSet添加元素的过程
  3. 当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）<br />如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接l<br />如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功<br />我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，<br />此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），<br />判断数组此位置上是否已经有元素：<br />如果此位置上没有其他元素，则元素a添加成功。  ---> 情况1<br />如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：<br />如果hash值不相同，则元素a添加成功。     ---> 情况2<br />如果hash值相同，进而需要调用元素a所在类的equals()方法：<br />equals()返回true,元素a添加失败<br />equals()返回false,则元素a添加成功。 ---> 情况3<br />对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637847784889-31b53026-aa82-49ac-9bc0-1e55c84aaae2.png#clientId=ud5e1c1c7-c7a6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=252&id=u06d4b621&margin=%5Bobject%20Object%5D&name=image.png&originHeight=252&originWidth=564&originalType=binary&ratio=1&rotation=0&showTitle=false&size=89211&status=done&style=none&taskId=ucdc5bd1d-5cdc-448a-9516-039ebf16634&title=&width=564)
  4. <a name="p8lhT"></a>
  5. #### 2.3 重写hashCode()基本原则
  7.    - 在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值
  8.    - 当两个对象的equals()方法比较返回true时，这两个对象的hashCode()方法的返回值也应相等
  9.    - 对象中用作equals()方法比较的Field，都应该用来计算hashCode值
  10. <a name="XyJAf"></a>
  11. #### 2.4 重写equals()基本原则
  12.       以自定义的Customer类为例，何时需要重写equals()？ 
  14.    - 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。
  15.    - 因此，违反了“相等的对象必须具有相等的散列码”。
  16.    - 结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
  17. <a name="IxR1Y"></a>
  18. #### 2.5 简要原理
  19. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/22523384/1642228499165-dd6e4e9c-2228-4623-ba73-d229b7f6a9ce.png#clientId=u67ec4419-be39-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=322&id=u7739e5b4&margin=%5Bobject%20Object%5D&name=image.png&originHeight=648&originWidth=1576&originalType=binary&ratio=1&rotation=0&showTitle=false&size=331922&status=done&style=none&taskId=u566b1d90-ebae-4af3-992f-630840124d1&title=&width=782)<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/22523384/1642252177126-e274c320-af45-4371-bd33-3bad50e84680.png#clientId=u67ec4419-be39-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=371&id=u09468f97&margin=%5Bobject%20Object%5D&name=image.png&originHeight=371&originWidth=1094&originalType=binary&ratio=1&rotation=0&showTitle=false&size=234872&status=done&style=none&taskId=u35febbd4-5255-4dd4-9882-ce76d972acb&title=&width=1094)
  20. <a name="DrgTU"></a>
  21. ### 3. **实现类二：LinkedHashSet**
  22. 1) LinkedHashSet是HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，**记录此数据前一个数据和后一个数据**<br />2) LinkedHashSet根据元素的hashCode值来决定元素的存储位置，但它同时**使用双向链表维护元素的次序**，这使得元素看起来是以插入顺序保存的<br />3) LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。<br />4) LinkedHashSet不允许集合元素重复<br />5) 对于频繁的遍历操作，LinkedHashSet效率高于HashSet
  23. <a name="q9zPf"></a>
  24. ### 4. **实现类三：TreeSet**
  25. <a name="VM5yK"></a>
  26. #### 4.1 TreeSet概述
  28. - TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
  29. - 特点：唯一，无序（没有按照输入顺序进行输出），有序（按照升序进行遍历输出）
  30. - TreeSet两种排序方法：自然排序（实现Comparable接口，内部比较器）和定制排序（Comparator，外部比较器）。默认情况下，TreeSet采用自然排序。
  31. - 向TreeSet中添加的数据，要求是相同类的对象
  32. ```java
  33. TreeSet set = new TreeSet();
  35. //失败：不能添加不同类型的对象
  36. set.add(123);
  37. set.add(456);
  38. set.add("AA");
  39. set.add(new User("Tom",12));
  41. // 报错：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

4.2 底层原理

TreeSet底层使用红黑树结构存储数据（TreeMap相同），特点是有序，查询速度比List快
底层原理：实现内部比较器或者外部比较器，所以向TreeSet中放入数据的时候，自定义的类必须实现比较器
TreeSet底层的二叉树的遍历是按照升序的结果出现的，这个升序是靠中序遍历得到的
image.png
image.png

4.3 自然排序（内部比较器）

  1. 自然排序：TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序（默认情况）排列
  2. 如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口。实现Comparable的类必须实现compareTo(Object obj)方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小
  3. Comparable的典型实现：
    • BigDecimal、BigInteger以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
    • Character：按字符的unicode值来进行比较
    • Boolean：true 对应的包装类实例大于false对应的包装类实例
    • String：按字符串中字符的unicode值进行比较
    • Date、Time：后边的时间、日期比前面的时间、日期大
  4. 向TreeSet中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
  5. 因为只有相同类的两个实例才会比较大小，所以向TreeSet中添加的应该是同一个类的对象。
  6. 对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较返回值是否为0，不再是equals()

  7. 当需要把一个对象放入TreeSet中，重写该对象对应的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果：如果两个对象通过equals()方法比较返回true，则通过compareTo(Object obj)方法比较应返回0。否则，让人难以理解

    1. // 实现Comparable接口，重写compareTo方法。按照姓名从大到小排列,年龄从小到大排列
    2. @Override
    3. public int compareTo(Object o) {
    4.  if(o instanceof User){
    5.      User user = (User)o;
    6.      // return -this.name.compareTo(user.name);
    7.      int compare = -this.name.compareTo(user.name);   // 先比较姓名
    8.      if(compare != 0){
    9.          return compare;
    10.      }else{
    11.          return Integer.compare(this.age,user.age);   // 再比较年龄
    12.      }
    13.  }else{
    14.      throw new RuntimeException("输入的类型不匹配");
    15. }}

    4.4 定制排序（外部比较器）

  8. TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。

  9. 定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法l
  10. 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2 l
  11. 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器
  12. 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常
  13. 使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0 ```java Comparator com = new Comparator() { // 按照年龄从小到大排列，年龄相同则保留一条 @Override public int compare(Object o1, Object o2) {
    1.  if(o1 instanceof User && o2 instanceof User){
    2.      User u1 = (User)o1;
    3.      User u2 = (User)o2;
    4.      return Integer.compare(u1.getAge(),u2.getAge());
    5.  }else{
    6.      throw new RuntimeException("输入的数据类型不匹配");
    }}};

// 一旦指定外部比较器，那么就会按照外部比较器来比较 TreeSet set = new TreeSet(com); set.add(new User(“Tom”,12)); set.add(new User(“Jerry”,32)); set.add(new User(“Jim”,2)); set.add(new User(“Mike”,65)); set.add(new User(“Mary”,33)); set.add(new User(“Jack”,33)); set.add(new User(“Jack”,56));

Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); }

  1. <a name="PZYW8"></a>
  2. ## 六、**Map接口**
  3. <a name="rSkHv"></a>
  4. ### 1. **Map接口概述**
  6. 1）Map与Collection并列存在。双列数据，用于保存具有映射关系的数据：key-value；一个键值对：key-value构成了一个Entry对象<br />2）Map中的key和value都可以是任何引用类型的数据<br />3）Map中的**key**：无序的、不可重复的，**使用Set存储所有的key**，即同一个Map对象所对应的类，须重写hashCode()和equals()方法；常用String类作为Map的“键”<br />4）Map中的**value**：无序的、可重复的，**使用Collection存储所有的value**。value所在的类要重写equals()<br />5）key和value之间存在单向一对一关系，即通过指定的key总能找到唯一的、确定的value<br />6）Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties
  8. - HashMap：作为Map的主要实现类；**线程不安全的，效率高**；存储null的key和value
  9. - LinkedHashMap：HashMap的子类，保证在遍历map元素时，可以按照添加的顺序实现遍历。
  11. 原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素<br />对于频繁的遍历操作，此类执行效率高于HashMap
  13. - TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。**底层使用红黑树**
  14. - Hashtable：作为古老的实现类；线程安全的，效率低；不能存储null的key和value
  15. - Properties：Hashtable的子类，常用来处理配置文件。key和value都是String类型
  17.  ![image.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637847972748-2c4436ba-d9a3-49fe-8a4f-90d4562d33a8.png#clientId=ud5e1c1c7-c7a6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=190&id=u0859bd8c&margin=%5Bobject%20Object%5D&name=image.png&originHeight=190&originWidth=391&originalType=binary&ratio=1&rotation=0&showTitle=false&size=32428&status=done&style=none&taskId=u0e26ae48-18e6-4d96-9657-763651d88e3&title=&width=391)
  18. <a name="LeKyK"></a>
  19. ### 2. **Map接口：常用方法**
  20. <a name="CdNnK"></a>
  21. #### 2.1 添加、删除、修改操作
  23. - Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
  24. - void putAll(Map m)：将m中的所有key-value对存放到当前map中
  25. - Object remove(Object key)：移除指定key的key-value对，并返回value
  26. - void clear()：清空当前map中的所有数据
  27. ```java
  28. Map map = new HashMap();
  29. // 添加
  30. map.put("AA",123);
  31. map.put(45,123);
  32. map.put("BB",56);
  33. // 修改
  34. map.put("AA",87);
  35. System.out.println(map);        //{AA=87, BB=56, 45=123}
  37. Map map1 = new HashMap();
  38. map1.put("CC",123);
  39. map1.put("DD",123);
  41. // 将map1中的所有key-value对存放到当前map中
  42. map.putAll(map1);
  43. System.out.println(map);        // {AA=87, BB=56, CC=123, DD=123, 45=123}
  45. // remove(Object key)
  46. Object value = map.remove("CC");
  47. System.out.println(value);     // 123
  48. System.out.println(map);       // {AA=87, BB=56, DD=123, 45=123}
  50. // clear()
  51. map.clear();//与map = null操作不同
  52. System.out.println(map.size());   // 0
  53. System.out.println(map);          // {}

2.2 元素查询的操作

  • Object get(Object key)：获取指定key对应的value
  • boolean containsKey(Object key)：是否包含指定的key
  • boolean containsValue(Object value)：是否包含指定的value
  • int size()：返回map中key-value对的个数
  • boolean isEmpty()：判断当前map是否为空
  • boolean equals(Object obj)：判断当前map和参数对象obj是否相等 ```java Map map = new HashMap(); map.put(“AA”,123); map.put(45,123); map.put(“BB”,56); System.out.println(map.get(45)); //123

boolean isExist = map.containsKey(“BB”); System.out.println(isExist); //true

isExist = map.containsValue(123); System.out.println(isExist); //true

map.clear(); System.out.println(map.isEmpty()); //true

  1. 2.3 元视图操作的方法
  3. - Set keySet()：返回所有key构成的Set集合
  4. - Collection values()：返回所有value构成的Collection集合
  5. - Set entrySet()：返回所有key-value对构成的Set集合
  6. ```java
  7. Map map = new HashMap();
  8. map.put("AA",123);
  9. map.put(45,1234);
  10. map.put("BB",56);
  12. // 遍历所有的key集：keySet()
  13. Set set = map.keySet();
  14. Iterator iterator = set.iterator();
  15. while(iterator.hasNext()){
  16.     System.out.println(iterator.next());
  17. }
  19. // 遍历所有的value集：values()
  20. Collection values = map.values();
  21. for(Object obj : values){
  22.     System.out.println(obj);
  23. }
  25. // 遍历所有的key-value
  26. // 方式一：entrySet()
  27. Set entrySet = map.entrySet();
  28. Iterator iterator1 = entrySet.iterator();
  29. while(iterator1.hasNext()){
  31.     Object obj = iterator1.next();
  32.     // entrySet集合中的元素都是entry（每个键值对）
  33.     Map.Entry entry = (Map.Entry) obj;
  34.     System.out.println(entry.getKey() + "---->" + entry.getValue());
  35. }
  37. // 方式二：
  38. Set keySet = map.keySet();
  39. Iterator iterator2 = keySet.iterator();
  40. while(iterator2.hasNext()){
  42.     Object key = iterator2.next();
  43.     Object value = map.get(key);
  44.     System.out.println(key + "=====" + value);
  45. }

2.4 总结：常用方法

  • 添加：put(Object key,Object value)
  • 删除：remove(Object key)
  • 修改：put(Object key,Object value)
  • 查询：get(Object key)
  • 长度：size()
  • 遍历：keySet() / values() / entrySet()

    3. 实现类一：HashMap

1）一个key-value构成一个entry
2）所有的entry构成的集合是Set：无序的、不可重复的
3）HashMap判断两个key相等的标准是：两个key通过equals()方法返回true，hashCode值也相等
4）HashMap判断两个value相等的标准是：两个value通过equals()方法返回true
5）面试题：HashMap的底层实现原理？

  1. HashMap的底层实现原理？
  2. 以JDK7为例说明：
  4. 1、HashMap map = new HashMap()：
  5.     在实例化以后，底层创建了长度是16的一维数组Entry[] table。
  6.     ...可能已经执行过多次put...
  7. 2、map.put(key1, value1):
  8.     首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
  9.     如果此位置上的数据为空，此时的key1-value1添加成功。 ---- 情况1
  10.     如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在))，比较key1和已经存在的一个或多个数据
  11.     的哈希值：
  12.         如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。---- 情况2
  13.         如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
  14.             如果equals()返回false：此时key1-value1添加成功。----情况3
  15.             如果equals()返回true：使用value1替换value2
  17.     补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
  19.     在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。
  20.     默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。
  22. JDK8相较于JDK7在底层实现方面的不同：
  23. 1. new HashMap()：底层没有创建一个长度为16的数组
  24. 2. JDK8底层的数组是：Node[]，而非Entry[]
  25. 3. 首次调用put()方法时，底层创建长度为16的数组
  26. 4. JDK7底层结构只有：数组 + 链表。JDK8中底层结构：数组 + 链表 + 红黑树。
  27.     4.1 形成链表时，七上八下（JDK7：新的元素指向旧的元素。JDK8：旧的元素指向新的元素）
  28.     4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。
  30. DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
  31. DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
  32. threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
  33. TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
  34. MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64

3.1 底层原理

image.png

3.2 重要属性

image.png

3.3 构造器

image.png

3.4 put方法

image.png
image.png
image.png
image.png

3.5 面试题

image.png

4. 实现类二：LinkedHashMap

1）LinkedHashMap是HashMap的子类
2）在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序
3）与LinkedHashSet类似，LinkedHashMap可以维护Map的迭代顺序：迭代顺序与Key-Value对的插入顺序一致
image.png

5. 实现类三：TreeMap

1）TreeMap存储Key-Value对时，需要根据key-value对进行排序。TreeMap可以保证所有的 Key-Value对处于有序状态。
2）TreeSet底层使用红黑树结构存储数据
3）TreeMap的Key的排序：

  • 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
  • 定制排序：创建TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口

4）TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回值为0
image.png
image.png
image.png
image.png

6. 实现类四：Hashtable

1）Hashtable是个古老的Map实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的
2）Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
3）与HashMap不同，Hashtable不允许使用null作为key和value
4）与HashMap一样，Hashtable也不能保证其中Key-Value对的顺序
5）Hashtable判断两个key相等、两个value相等的标准，与HashMap一致

7. 实现类五：Properties

1）Properties类是Hashtable的子类，该对象用于处理属性文件
2）由于属性文件里的key、value都是字符串类型，所以Properties里的key和value都是字符串类型
3）存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

  1. FileInputStream fis = null;
  2. try {
  3.     Properties pros = new Properties();
  4.     fis = new FileInputStream("jdbc.properties");
  5.     pros.load(fis);       //加载流对应的文件
  6.     String name = pros.getProperty("name");
  7.     String password = pros.getProperty("password");
  8.     System.out.println("name = " + name + ", password = " + password);
  9. } catch (IOException e) {
  10.     e.printStackTrace();
  11. } finally {
  12.     if(fis != null){
  13.         try {
  14.             fis.close();
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17. }}}

七、Collections工具类

1. Collections工具类概述

1）Collections 是一个操作 Set、List 和 Map 等集合的工具类
2）Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

2. Collections常用方法

2.1 排序操作（均为static方法）

  • reverse(List)：反转List中元素的顺序
  • shuffle(List)：对List集合元素进行随机排序
  • sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
  • sort(List，Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序
  • swap(List，int， int)：将指定list集合中的 i 处元素和 j 处元素进行交换 ```java List list = new ArrayList(); list.add(123); list.add(43); list.add(765); list.add(765); list.add(765); list.add(-97); list.add(0); System.out.println(list); // [123, 43, 765, 765, 765, -97, 0]

Collections.reverse(list); // [0, -97, 765, 765, 765, 43, 123] // Collections.shuffle(list); // 随机排序 // Collections.sort(list); // [-97, 0, 43, 123, 765, 765, 765] // Collections.swap(list,1,2); // [123, 765, 43, 765, 765, -97, 0] // int frequency = Collections.frequency(list, 765); //3

System.out.println(list);

  1. <a name="bqes9"></a>
  2. #### 2.2 查找、替换 
  4. - Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
  5. - Object max(Collection，Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素
  6. - Object min(Collection)
  7. - Object min(Collection，Comparator)
  8. - int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
  9. - void copy(List dest,List src)：将src中的内容复制到dest中
  10. - boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
  11. ```java
  12. List list = new ArrayList();
  13. list.add(123);
  14. list.add(43);
  15. list.add(765);
  16. list.add(-97);
  17. list.add(0);
  19. //报异常：IndexOutOfBoundsException("Source does not fit in dest")
  20. //List dest = new ArrayList();
  21. //Collections.copy(dest,list);
  22. //正确的：
  23. List dest = Arrays.asList(new Object[list.size()]);
  24. System.out.println(dest.size());   //list.size();
  25. Collections.copy(dest,list);
  27. System.out.println(dest);

2.3 同步控制

Collections类中提供了多个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。 

  1. // 返回的list1即为线程安全的List
  2. List list1 = Collections.synchronizedList(list);

八、数据结构简述

1、算法

  • 可以解决具体问题。解题流程 = 算法
  • 有设计解决的具体的流程
  • 有评价算法的具体指标：时间复杂度、空间复杂度

image.png

2、数据结构

在计算机的缓存、内存、硬盘中如何组织管理数据。重点在结构上，是按照什么结构来组织管理我们的数据
2.1 逻辑结构：思想上的结构
2.2 物理结构：真实结构
image.png
image.png
image.png
image.png
image.png
image.png
image.png