Java 集合

Java集合框架概述

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。

使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。

数组在存储多个数据方面的特点：

一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
比如：String[] arr; int[] arr1; Object[] arr2;

数组在存储多个数据方面的缺点：

一旦初始化以后，其长度就不可修改。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数需求，数组没有现成的属性或方法可用。
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

集合框架

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

|---Collection接口：单列集合，用来存储一个一个的对象。
|---List接口：存储有序的、可重复的数据。 --> “动态”数组
|---ArrayList、LinkedList、Vector
|---Set接口：存储无序的、不可重复的数据 --> 高中的“集合”
|---HashSet/LinkedHashSet/TreeSet
|---Map接口：双列集合，用来存储一对(key : value)一对的数据 --> 高中函数：y = f(x)
|---HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

——实线是继承关系，--虚线是实现类

Collection 接口方法

add(Object e): 将元素e添加到集合list中
size():返回此集合中的元素数。
addAll():将指定集合中的所有元素添加到此集合中。
clear():从此集合中删除所有元素.此方法返回后，集合将为空。
isEmpty():如果此集合不包含任何元素，则返回true。
contains(Object o):如果此集合包含指定的元素，则返回true.

在判断时会调用obj对象所在类的equals().
containsAll(Collection c):如果此集合包含指定集合中的所有元素，则返回true.
remove(Object obj):从此集合中移除指定元素的单个实例(如果存在),如果找到并删除返回 true
removeAll(Collection coll):删除此集合中所有与指定集合相同的元素。如果找到任意一个并删除返回 true
retainAll(Collection c):保留此集合与指定集合的交集，其余删除.如果集合发生更改返回 true
equals(Object obj):比较指定对象与此集合是否相等。
hashCode():返回此集合的哈希码值。
iterator():返回此集合中元素的迭代器。
toArray():集合 ---> 数组

@Test
public void test1() {
    Collection list = new ArrayList();
    //1. add(Object e): 将元素e添加到集合list中
    list.add("AA");
    list.add("BB");
    list.add(123);
    list.add(new Date());
  
    //2. size():返回此集合中的元素数。
    System.out.println(list.size());// 4
  
    //3. addAll():将指定集合中的所有元素添加到此集合中。
    Collection list1 = new ArrayList();
    list1.add(334);
    list1.add("CC");
    list.addAll(list1);
    System.out.println(list.size()); // 6
    System.out.println(list);// [AA, BB, 123, Mon May 31 21:13:46 CST 2021, 334, CC]
  
    //4. clear():从此集合中删除所有元素.此方法返回后，集合将为空。
    list.clear();
    System.out.println(list);// []
  
    //5. isEmpty():如果此集合不包含任何元素，则返回true。
    System.out.println(list.isEmpty());// true
}

@Test
public void test1() {
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(123);
    coll.add(456);
    coll.add(456);
    coll.add(new String("Tom"));
    coll.add(false);
    coll.add(new Person("Link", 21));
    System.out.println(coll);
  
    //6. contains(Object o):如果此集合包含指定的元素，则返回true.
    // 在判断时会调用obj对象所在类的equals().
    boolean contains = coll.contains(456);
    System.out.println(contains); // true
    // 这时如果 new的方法中存在equals() 返回true 反之false
    System.out.println(coll.contains(new Person("Link", 21)));
  
    //7. containsAll(Collection c):如果此集合包含指定集合中的所有元素，则返回true.
    Collection coll1 = Arrays.asList(123, 456);
    System.out.println(coll.containsAll(coll1)); // true
  
    //8. remove(Object obj):从此集合中移除指定元素的单个实例(如果存在),如果找到并删除返回 true
    coll.remove(123); // true
    System.out.println(coll);
  
    //9. removeAll(Collection coll):删除此集合中所有与指定集合相同的元素。如果找到任意一个并删除返回 true
    coll.removeAll(coll1);
    System.out.println(coll);
}
@Test
public void test2() {
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(123);
    coll.add(456);
    coll.add(new String("Tom"));
    coll.add(false);
    coll.add(new Person("Link", 21));
    System.out.println(coll);
    Collection coll1 = Arrays.asList(123, 456);
  
    //10. retainAll(Collection c):保留此集合与指定集合的交集，其余删除.如果集合发生更改返回 true
    coll.retainAll(coll1);
    System.out.println(coll);
  
    //11. equals(Object obj):比较指定对象与此集合是否相等。
    System.out.println(coll.equals(123)); // false
  
    //12. hashCode():返回此集合的哈希码值。
    System.out.println(coll.hashCode()); // 5030299
  
    //13. iterator():返回此集合中元素的迭代器。
    System.out.println(coll.iterator());
  
    //14. toArray():集合 ---> 数组
    Object[] arr = coll.toArray();
    System.out.println("*******************");
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
    //拓展：数组 ---> 集合：调用Arrays类的静态方法asList()
    List<String> list = Arrays.asList(new String[]{"AA", "DD", "GG"});
    System.out.println(list); // [AA, DD, GG]
}

结论：向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().

public class Person {

    private String name;
    private int age;

    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {
        this.age = age;}
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';}

  // 重写 equals 方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

//    @Override
//    public int hashCode() {
//        return Objects.hash(name, age);
//    }
}

Iterator 迭代器接口

GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

Iterator 仅用于遍历集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象。

Iteration 接口方法

next(): 返回迭代中的下一个元素。(游标下移，将下移后游标所在位置的元素返回)。
hasNext(): 如果next() 可以返回的是一个元素而不是异常，返回true。
remove(): 将迭代器返回的元素删除。

注意：

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。

如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。

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

@Test
public void test1(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add("Tom");
    
    // 获取迭代器
    Iterator iterator = coll.iterator();
    // next(): 返回迭代中的下一个元素。(游标下移，将下移后游标所在位置的元素返回)
    System.out.println(iterator.next());
    // hasNext(): 如果next() 可以返回的是一个元素而不是异常，返回true
    System.out.println(iterator.hasNext());
    // 输出更多数据
    //next()必须要和hasNext()一起使用,否则 nest()找不到下一个元素回报NoSuchElementException异常
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

@Test
public void test2(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(12);
    coll.add(1);
    coll.add(17);
    coll.add(35);
    Iterator it = coll.iterator();
    // 删除集合中小于20 的元素
    while (it.hasNext()) {
        Integer i = (Integer) it.next();
        if (i < 20) {
            it.remove();
        }
    }
    System.out.println(coll);
}

使用 foreach 循环遍历集合元素

遍历集合的底层调用Iterator完成操作。

// 练习题
    @Test
    public void test2() {
        String[] arr = {"AA", "AA", "AA"};

        //方式一：普通for循环
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = "CC";
//        }

        // 方式二：增强for循环
        for (String s : arr) {
            s = "GG";
        }

        /*
        通过普通循环改变的是原有数组
        增强for循环改变的是数组赋的值 s ,对原数组没有改变
         */
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

List 接口

Collection接口：单列集合，用来存储一个一个的对象。
- List接口：存储有序的、可重复的数据。 --> “动态”数组。
  - ArrayList: 作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储。
  - LinkedList: 对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
  - Vector: 作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储。(不常用)

ArrayList 的源码分析

jdk 7 情况下

ArrayList list = new ArrayList();// 底层创建了长度是10的Object[] 数组elementData
list.add(123); //elementData[0] = new Integer(123);
...

list.add(11); //如果此次的添加导致底层elementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据赋值到新的数组中。

结论：建议开发中使用代参的构造器：ArrayList = newArrayList(int capacity)
jdk 8 中ArrayList的变化

ArrayList list = new ArrayList(); //底层Object[] elementData初始化为{}，并没有创建长度为10的数组
list.add(123); //第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]

...

后续的添加和扩容操作与jdk 7 无异。
小结：
- JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组.
- JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组.

LinkedList 的源码分析

LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值null
list.add(123); //将123封装到Node中，创建了Node对象。

其中，Node定义为：体现了LinkedList 双向链表的说法：

  private static class Node<E> {
   E item;
   Node<E> next;
   Node<E> prev;
   Node(Node<E> prev, E element, Node<E> next) {
       this.item = element;
       this.next = next;
       this.prev = prev;
   }
 }

Vector 的源码分析

jdk7 和 jdk8 中通过Vector() 构造器创建对象时，底层都创建了长度为10 的数组，在扩容方面，默认扩容为原来数组长度的2倍。

面试题：

请问ArrayList/LinkedList/Vector的异同？谈谈你的理解？ArrayList底层是什么？扩容机制？Vector和ArrayList的最大区别?

ArrayList和LinkedList的异同
二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

ArrayList和Vector的区别
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用 ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。

List 接口方法

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

@Test
public void test1() {
    ArrayList list = new ArrayList();
    list.add(123);
    list.add(456);
    list.add("AA");
    list.add(new Person("Tom", 12));
    list.add(456);
    System.out.println(list); //[123, 456, AA, Person{name='Tom', age=12}, 456]
    //1. void add(int index, Object ele):在index位置插入ele元素
    list.add(2, "CC");
    System.out.println(list); //[123, 456, CC, AA, Person{name='Tom', age=12}, 456]
    //2. boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
    List list1 = Arrays.asList(11, 22);
    list.addAll(2, list1);
    System.out.println(list); //[123, 456, 11, 22, CC, AA, Person{name='Tom', age=12}, 456]
    //3. Object get(int index):获取指定index位置的元素
    System.out.println(list.get(3)); //22
    //4. int indexOf(Object obj):返回obj在集合中首次出现的位置;如果不存在返回 -1
    System.out.println(list.indexOf(456)); //1
    //5. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
    System.out.println(list.lastIndexOf(456)); //7
    //6. Object remove(int index):移除指定index位置的元素，并返回此元素
    Object remove = list.remove(6);
    System.out.println(remove); //Person{name='Tom', age=12}
    System.out.println(list); //[123, 456, 11, 22, CC, AA, 456]
    //7. Object set(int index, Object ele):设置指定index位置的元素为ele
    list.set(0, "XXX");
    System.out.println(list); //[XXX, 456, 11, 22, CC, AA, 456]
    //8. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex(不包括)位置的子集合
    List sub = list.subList(1, 4);
    System.out.println(sub); //[456, 11, 22]
}

/* 遍历ArrayList */
@Test
public void test2() {
    ArrayList list = new ArrayList();
    list.add(123);
    list.add(456);
    list.add("AA");
    // 方式一: Iteration迭代器
    Iterator iterator = list.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
    System.out.println("------------------");
    // 方式二：foreach 增强for循环
    for (Object obj : list) {
        System.out.println(obj);
    }
    System.out.println("------------------");
    // 方式三：普通for循环
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

/* remove 小练习*/
@Test
public void testListRemove() {
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    updateList(list);
    System.out.println(list);//
}
private void updateList(List list) {
    //list.remove(2); // 默认删除index索引位置
    list.remove(Integer.valueOf(2));
}

Set 接口

Set 接口的框架：

Collection接口：单列集合，用来存储一个一个的对象。
- Set接口：存储无序的、不可重复的数据 --> 高中的“集合”
  - HashSet: 作为Set接口的主要实现类；线程不安全；可以存储null值。
    - LinkedHashSet: 作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
  - TreeSet：可以按照添加对象的指定属性，进行排序

Set 接口中没有额外定义新的方法，使用的都是Collocation中声明过的方法。
要求：向Set中添加数据，其所在的类一定要重写equals()和hashCode()，重写的hashCode()和equals() 尽可能保持一致性：相等的对象必须具有相等的散列码。

重写两个方法的小技巧：对象中用作equals() 方法比较Field，都应该用来计算hashCode值。

实现类：HashSet

HashSet 具有以下特点：

不能保证元素的排列顺序
HashSet 不是线程安全的
集合元素可以是 null

Set：存储无序性、不可重复的数据

以HashSet为例说明：

无序性：不等于随机性，存储的数据底层数据中并非按照数组索引的顺序添加，而是根据数据的哈希值
不可重复性：保证添加的元素按照equals()判断时，不能返回true，即：相同的元素只能添加一个。

对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

添加元素的过程

以HashSet为例：

向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为：索引位置)，判断
数组此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功。 ---> 情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的哈希值:
- 如果哈希值不相同，则元素a添加成功。 ---> 情况2
- 如果哈希值相同，进而需要调用元素a所在类的equals()方法:
  - equals()返回true，元素a添加失败，
  - equals()返回false，则元素a添加成功。 ---> 情况3

对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。

jdk 7：元素a放到数组中，指向原来的元素。
jdk 8：原来的元素在数组中，指向元素a。
总结：七上八下

Eclipse/IDEA工具里hashCode()的重写

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    User user = (User) o;
    if (age != user.age) return false;
    return name != null ? name.equals(user.name) : user.name == null;
}

@Override
public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + age;
    return result;
}

以Eclipse/IDEA为例，在自定义类中可以调用工具自动重写equals和hashCode。问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？

选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的 “冲突”就越少，查找起来效率也会提高。（减少冲突）

并且31只占用5bits,相乘造成数据溢出的概率较小。

31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）

31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)

实现类：LinkedHashSet

LinkedHashSet 是 HashSet 的子类
LinkedHashSet插入性能略低于 HashSet，对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

Set set = new LinkedHashSet();
set.add("AA");
set.add(456);
set.add(new User("Tom",21));

实现类：TreeSet

TreeSet底层使用红黑树结构存储数据。
向TreeSet 中添加的数据，要求是相同类的对象。
两种排序方式：自然排序(实现Comparable接口) 和 定制排序。
1. 自然排序中，比较两个对象是否相同的标准为：compareTo()返回值为0，而不再是equals().
2. 定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals().

自然排序

自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。
如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。
对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 方法比较返回值。

定制排序

Comparator接口可以实现自定义排序，实现Comparator接口时，要重写compare方法：
int compare(Object o1, Object o2) 返回一个基本类型的整型

如果要按照升序排序,则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序,则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

public class User implements Comparable{
    private String name;
    private int age;

    public User() {}
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //按照姓名从小到大排列,年龄从小到大排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof User){
            User user = (User) o;
            //return this.name.compareTo(user.name);
            int compare = this.name.compareTo(user.name);
            if (compare != 0){
                return compare;
            }else {
                return Integer.compare(this.age,user.age);
            }
        }else {
            throw new RuntimeException("输入类型不匹配");
        }
    }
}

// 自然排序
@Test
public void test1() {
    TreeSet set = new TreeSet();
    //失败：不能添加不同类的对象
    //set.add(123);
    //set.add(456);
    //set.add("AA");
    //set.add(new User("Tom",12));

    //举例二
    set.add(new User("Tom", 22));
    set.add(new User("Chu", 68));
    set.add(new User("Li", 34));
    set.add(new User("Shao", 18));
    set.add(new User("Shao", 45));
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}
/*
User{name='Chu', age=68}
User{name='Li', age=34}
User{name='Shao', age=18}
User{name='Shao', age=45}
User{name='Tom', age=22}
*/

@Test
public void test2() {
    Comparator com = new Comparator() {
        // 按照年龄从小到大排列
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof User && o2 instanceof User) {
                User u1 = (User) o1;
                User u2 = (User) o2;
                return Integer.compare(u1.getAge(), u2.getAge());
            } else {
                throw new RuntimeException("输入的数据类型不匹配");
            }
        }
    };
    TreeSet set = new TreeSet(com);
    set.add(new User("Tom", 22));
    set.add(new User("Chu", 68));
    set.add(new User("Li", 34));
    set.add(new User("CC", 34));
    set.add(new User("Shao", 18));
    set.add(new User("Shao", 45));
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}
/*
User{name='Shao', age=18}
User{name='Tom', age=22}
User{name='Li', age=34}
User{name='Shao', age=45}
User{name='Chu', age=68}
*/

Map 接口

Map接口继承数

一、Map的实现类的结构：

Map接口：双列集合，用来存储一对(key : value)一对的数据 --> 高中函数：y = f(x)
- HashMap: 作为Map的主要实现类；线程不安全的，效率高；可存储null的key和value。
  - LinkedHashMap: 保证在遍历map元素时，可以按照添加的顺序实现遍历。
    
    原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
- TreeMap: 保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树。
- Hashtable: 作为古老的实现类；线程安全的，效率低；不能存储null的key和value
  - Properties: 常用来处理配置文件。key和value都是String类型。

HashMap的底层：数组+链表 (jdk7及之前)
数组+链表+红黑树 (jdk8)

面试题：

HashMap的底层实现原理？
HashMap和 Hashtable 的异同？
CurrentHashMap 与 Hashtable 的异同？(暂不论)

二、Map结构的理解：

Map中的key：无序的、不可重复的，使用Set存储所有的key ---> key所在的类要重写equals()hashCode() (以HashMap为例)
Map中的value：无序的、可重复的，使用Collection存储所有的value ---> 所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry：无序的、不可重复的，使用Set存储所有的entry。

三、HashMap的底层实现原理？以jdk7为例说明：

HashMap map = new HashMap();
在实例化以后，底层创建了长度是16的一维数组Entry[] table。
。。。可能已经执行过多次put。。。
map.put(key1,value1);

首先，调用key1所在类的hashCode() 计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。 --- 情况1
如果此位置上的数据不为空，(意味着此位置有一个或多个(以链表形式)数据)，比较key1和已经存在的一个货多个数据的哈希值：
- 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。 --- 情况2
- 如果key1的哈希值与已经存在的某个数据(key2-value2)的哈希值相同，继续比较：调用key1所在的类的equals(key2):
  - 如果equals() 返回false：此时key1-value1添加成功。 --- 情况3
  - 如果equals() 返回true：使用value1替换value2.

补充：关于情况2和情况3：此时key1-value1和原来替换的数据链表的方式存储。

在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时：扩容，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

jdk8 相较于 jdk7 在底层实现方面的不同：

new HashMap(): 底层没有创建一个长度为16的数组
jdk8 底层的数组是：Node[]，而不是Entry[]
首次调用put() 方法时，底层创建长度为16的数组。
jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
当数组的某一个索引位置上的元素一链表形式存在的数据个数 > 8，且当前数组的长度 > 64时。
此时此索引位置上的所有数据改为使用红黑树存储。

HashMap源码中的重要常量：

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量：16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量填充因子：0.7516 --> 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64

四、LinkedHashMap的底层实现原理(了解)

```
 源码中：
```

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after; //能够记录添加的元素的先后顺序
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

五、常用方法

添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据

@Test
public void test3() {
    HashMap map = new HashMap();
    // put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
    // 添加
    map.put("AA", 123);
    map.put("BB", 123);
    map.put("23", 123);
    // 修改
    map.put("AA", 67);
    System.out.println(map);// {AA=67, BB=123, 23=123}
    // putAll(Map m):将m中的所有key-value对存放到当前map中
    HashMap map1 = new HashMap();
    map1.put("CC", 123);
    map1.put("DD", 123);
    map.putAll(map1);
    System.out.println(map);// {AA=67, BB=123, CC=123, DD=123, 23=123}
    // remove(Object key)：移除指定key的key-value对，并返回value
    Object aa = map.remove("AA");
    System.out.println(aa); // 67
    System.out.println(map);// {BB=123, CC=123, DD=123, 23=123}
    // clear()：清空当前map中的所有数据
    map.clear();
    System.out.println(map);// {}
}

元素查询的操作：
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是否相等

@Test
public void test4() {
    HashMap map = new HashMap();
    map.put("AA", 123);
    map.put("BB", 123);
    map.put(23, 123);
    // get(Object key)：获取指定key对应的value
    System.out.println(map.get(23)); //123
    // containsKey(Object key)：是否包含指定的key
    // containsValue(Object value)：是否包含指定的value
    System.out.println(map.containsKey("AA")); //true
    System.out.println(map.containsValue(233));//false
    // size()：返回map中key-value对的个数
    System.out.println(map.size()); //3
    // isEmpty()：判断当前map是否为空
    System.out.println(map.isEmpty()); //false
}

元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

@Test
public void test5() {
    HashMap map = new HashMap();
    map.put("AA", 111);
    map.put(23, 333);
    map.put("BB", 222);
    //遍历所有的key集：keySet()
    Set set = map.keySet();
    System.out.println(set);// [AA, BB, 23]
    //遍历所有的value集：values()
    Collection values = map.values();
    System.out.println(values);// [111, 222, 333]
    //遍历所有的key-value
    Set entrySet = map.entrySet();
    Iterator iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Object next = iterator.next();
        //entrySet集合中的元素都是entry
        Map.Entry entry = (Map.Entry) next;
        System.out.println(entry.getKey() + "--->" + entry.getValue());
    }
}

Properties

public class PropertiesTest {
    //Properties: 常用来处理配置文件，key和value都是String类型
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            Properties prop = new Properties();

            fis = new FileInputStream("jdbc.properties");
            prop.load(fis);// 加载流对应的文件

            String name = prop.getProperty("name");
            String password = prop.getProperty("password");

            System.out.println("name = " + name + ", password = " + password);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Collections 工具类

Collection：操作Collection、Map的工具类

面试题：Collection 和 Collections的区别？
Collection是存储单列数据的集合接口，常见子接口List、Set;
Collections是个操作Collection的工具类.

排序操作：（均为static方法）
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

@Test
public void test1(){
    List list = new ArrayList();
    list.add(79);
    list.add(63);
    list.add(56);
    list.add(-12);
    list.add(-25);
    System.out.println(list); //[79, 63, 56, -12, -25]
    // reverse(List)：反转 List 中元素的顺序
    Collections.reverse(list);
    System.out.println(list); //[-25, -12, 56, 63, 79]
    // shuffle(List)：对 List 集合元素进行随机排序
    Collections.shuffle(list);
    System.out.println(list); //随机
    // sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
    Collections.sort(list);
    System.out.println(list); //[-25, -12, 56, 63, 79]
    // swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
    Collections.swap(list,1,2);
    System.out.println(list); //[-25, 56, -12, 63, 79]
}

查找、替换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值

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

@Test
public void test2(){
    List list = new ArrayList();
    list.add(79);
    list.add(63);
    list.add(63);
    list.add(63);
    list.add(56);
    System.out.println(list); //[79, 63, 63, 63, 56]
    // int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
    int frequency = Collections.frequency(list, 63);
    System.out.println(frequency); //3
    List list1 = new ArrayList();
    list.add("AA");
    list.add("BB");
    // void copy(List dest,List src)：将src中的内容复制到dest中
    Collections.copy(list,list1);
    System.out.println(list); //[79, 63, 63, 63, 56, AA, BB]
    List dest = Arrays.asList(new Object[list.size()]);
    Collections.copy(dest,list);
    System.out.println(dest); //[79, 63, 63, 63, 56, AA, BB]
    // boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值
    Collections.replaceAll(list,63,"CC");
    System.out.println(list); //[79, CC, CC, CC, 56, AA, BB]
    // 返回的list2即为线程安全的
  	List list2 = Collections.synchronizedList(list);
}

小练习：请从键盘随机输入10个整数保存到List中，并按倒叙、从大到小的顺序显示出来。

public class Exercise {
    public static void main(String[] args) {
        ArrayList list = new ArrayList(10);
        Scanner scanner = new Scanner(System.in);
        System.out.println("您输入的是：");
        for (int i = 0; i < 10; i++) {
            list.add(scanner.nextInt());
        }

        // sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                /*
                如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
                这样颠倒一下，就可以实现降序排序了,反之即可自定义升序排序了
                 */
                return o2 - o1;
            }
        });
        System.out.println(list);
    }
}

posted @ 2021-06-11 21:31 C_Long 阅读(57) 评论(0) 收藏举报

刷新页面返回顶部

C_Long

Java 集合

Java 集合

Java集合框架概述

Collection 接口方法

Iterator 迭代器接口

Iteration 接口方法

使用 foreach 循环遍历集合元素

List 接口

ArrayList 的源码分析

LinkedList 的源码分析

Vector 的源码分析

List 接口方法

Set 接口

实现类：HashSet

Set：存储无序性、不可重复的数据

添加元素的过程

Eclipse/IDEA工具里hashCode()的重写

实现类：LinkedHashSet

实现类：TreeSet

自然排序

定制排序

Map 接口

一、Map的实现类的结构：

二、Map结构的理解：

三、HashMap的底层实现原理？以jdk7为例说明：

四、LinkedHashMap的底层实现原理(了解)

五、常用方法

Properties

Collections 工具类

公告