• 【JavaSE】Java集合

    文章目录

    Java集合

    集合框架概述

    概述

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

    • 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)

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

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

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

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

    集合框架

    |—Collection接口：单列集合，用来存储一个个对象

    • |—List接口：存储有序的、可重复的数据。 -->"动态"数组
      • |—ArrayList、LinkedList、Vector
    • |—Set接口：存储无序的、不可重复的数据。–>高中数学的集合
      • |—HashSet、LinkedHashSet、TreeSet

    |—Map接口：双列集合，用来存储一对对(key-value)数据 -->高中函数：y=f(x)

    • |—HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

    Collection接口方法

    1. add(Object e)：将元素e添加到集合中
    2. size()方法：获取添加的元素的个数
    3. addAll()：添加另一个Collection类
    4. clear():清空集合元素
    5. isEmpty():判断当前集合是否为空
    6. contains(Object obj)：当前集合中是否包含obj
    7. containsAll(Collection col1):判断形参col1中额的所有元素是否都存在与col中
    8. remove(Object obj)：从当前集合中移除元素obj，返回true则表示删除成功，false表示删除失败
    9. removeAll(Collection col1)：从当前集合中移除公有的元素，差集操作
    10. retainAll(Collection col1)：获取当前集合和col1的交集，并返回给当前结合
    11. equals(Object obj)：比较两个Collection中的所有元素是否相等
    12. hashCode()：返回当前对象的哈希值
    13. 集合 —> 数组：toArray()
      拓展：数组 —> 集合 ：调用Arrays类的静态方法asList()
    14. iterator()：返回Iterator接口的实例，用于遍历集合元素。
    package com.zeta;

import org.junit.Test;

import java.time.LocalDateTime;
import java.util.*;

/* @author zeta
 * @date 2022/7/13 - 9:55
 */
@SuppressWarnings("all")
public class CollectionTest {
    @Test
    public void test1(){
        Collection col = new ArrayList<>();
        //add(Object e)：将元素e添加到集合中
        col.add("abcd");
        col.add(123);
        col.add(true);
        col.add(1000000L);

        //size()方法：获取添加的元素的个数
        System.out.println(col.size());//4

        //addAll()：添加另一个Collection类
        Collection col1 = new ArrayList<>();
        col1.add("456");
        col1.add("true");
        col1.add(LocalDateTime.now());
        col.addAll(col1);

        System.out.println(col.size());//7
        System.out.println(col);

        //clear():清空集合元素
        col.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(col.isEmpty());

    }

    /*
    向Collection接口的实现类对象中添加数据obj时，要求obj所在的类重写equals()方法
     */
    @Test
    public void test2(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add(new Date());
        //1.contains(Object obj)：当前集合中是否包含obj
        System.out.println(col.contains(false));
        System.out.println(col.contains(new String("Tom")));//判断的是内容：equals()方法
        System.out.println(col.contains("T"+"o"+"m"));

        //2.containsAll(Collection col1):判断形参col1中额的所有元素是否都存在与col中
        Collection col1 = Arrays.asList(123,4567);
        System.out.println(col.containsAll(col1));

    }

    @Test
    public void test3(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");
        //3.remove(Object obj)：从当前集合中移除元素obj，返回true则表示删除成功，false表示删除失败
        col.remove(1234);
        System.out.println(col);

        //4.removeAll(Collection col1)：从当前集合中移除公有的元素，差集操作
        Collection col1 = Arrays.asList(123,4567);
        col.removeAll(col1);
        System.out.println(col);
    }

    @Test
    public void test4(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");

        //5.retainAll(Collection col1)：获取当前集合和col1的交集，并返回给当前结合
        Collection col1 = Arrays.asList(123,456,789);
//        col.retainAll(col1);
        System.out.println(col);

        //6.equals(Object obj)：比较两个Collection中的所有元素是否相等
        Collection col2 = new ArrayList();
        col2.add(456);
        col2.add(123);
        col2.add(new String("Tom"));
        col2.add(false);
        col2.add("jack");
        System.out.println(col.equals(col2));
    }

    @Test
    public void test5(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");

        //7.hashCode()：返回当前对象的哈希值
        System.out.println(col.hashCode());

        //8.集合 ---> 数组：toArray()
        Object[] objects = col.toArray();
        System.out.println(Arrays.toString(objects));

        //拓展：数组 ---> 集合？:调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"a", "b", "c"});
        System.out.println(list);

        //9.iterator()：返回Iterator接口的实例，用于遍历集合元素。
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130

    Iterator迭代器接口

    集合元素的遍历，使用迭代器Iterator接口

    1. 内部的方法：hasNext()和next()
    2. 集合对象每次调用iterator()方法都将得到一个全新的迭代器对象，指针默认在集合的第一个元素之前
    3. Iterator内部定义了remove()，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调remove()
    package com.zeta;

import org.junit.Test;

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

/**
 * @author zeta
 * @date 2022/7/14 - 15:26
 */
@SuppressWarnings("all")
public class IteratorTest {
    @Test
    public void test1(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");

        Iterator iterator = col.iterator();
        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next()); //报异常：NoSuchElementException
        //方式二：不推荐
//        for (int i=0;i<5;i++){
//            System.out.println(iterator.next());
//        }
        //方式三：推荐
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test2(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");
        Iterator iterator = col.iterator();
        //删除"Tom"
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();//直接删除col中的元素
            }
        }
//        System.out.println(col); "Tom"被删除
        //重新遍历
        iterator = col.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    补充：Collection的forEach遍历方法

    col.forEach(System.out::println); //Java8新特性

    @Test
    public void test6(){
        /*
        Collection的forEach遍历方法
         */
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new User("Tom",20));
        col.add(false);
        col.add(new User("Jack",21));
        col.forEach(System.out::println);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    Collection子接口一：List

    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);//如果此次添加导致底层数组容量不够，则扩容。

    默认情况下扩容为原来长度的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

    结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int initialCapacity);

    jdk 8中ArrayList的变化

    ArrayList list = new ArrayList();//底层elementData初始化为{}。并没有创建长度为10的数组

    list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData中

    …

    后续的添加和扩容与jdk7无异。

    小结

    jdk7中的ArrayList的对象的创建类似于单例的饿汉式；

    jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省了内存。

    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    Vector的源码分析

    jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组

    在扩容方面，默认扩容为原来数组长度的2倍

    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位置的左闭右开区间的子集合

    总结：常用方法
    增：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循环
    ③普通的循环

    package com.zeta;

import org.junit.Test;

import java.util.*;

/*
 * @author zeta
 * @date 2022/7/15 - 9:16
 */
@SuppressWarnings("all")
public class ListTest {
    
    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("jack");
        list.add("AA");
        //方式一：Iterator迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("**********************");
        //方式二：增强for循环
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("**********************");

        //方式三：普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }

    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("jack");
        list.add("tom");
        list.add(456);
        list.add(new StringBuilder(new String("ζ")));
        System.out.println(list);

        //int indexOf(Object obj)：返回obj在集合中首次出现的位置。如果不存在，返回-1
        int index = list.indexOf(4567);
        System.out.println(index);//-1

        //int lastIndexOf(Object obj)：返回obj在当前集合中末位出现的位置
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);

        //Object remove(int index)：移除指定index位置的元素，并返回此元素
        Object obj = list.remove(4);
        System.out.println(obj);
        System.out.println(list);

        //Object set(int index,Object ele)：设置指定index位置的元素为ele
        list.set(1,"AA");
        System.out.println(list);

        //List subList(int fromIndex,int toIndex)：返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
    }

    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("jack");
        list.add(new String("tom"));
        System.out.println(list);

        //void add(int index,Object ele):在index位置插入ele元素
        list.add(1,"ζ");
        System.out.println(list);

        //boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
        List<Integer> list1 = Arrays.asList(1, 2, 3);
        list.addAll(0,list1);
        System.out.println(list);
        System.out.println("list的长度为："+list.size());//8

        //Object get(int index)：获取指定index位置的元素
        System.out.println(list.get(4));
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95

    面试题

    区分list中的remove(int index)和remove(Object obj)方法

    当直接输入数字时，默认调用remove(int index)，当对数字进行封装(new Integer(num))时，调用remove(Object obj)方法。

    package com.exer;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @author zeta
 * @date 2022/7/15 - 19:51
 */
@SuppressWarnings("all")
public class ListExer {
    @Test
    public void testListRemove(){
        /*
        区分list中的remove(int index)和remove(Object obj)方法
         */
        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);//list确实被改变了，index为2的位置被删除
        System.out.println(list);//[1,2]
    }
    public static void updateList(List list){
//        list.remove(2);//2 是索引，不是数据
        list.remove(new Integer(2));
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    Collection子接口二：Set

    Set接口的框架结构

    |—Collection接口：单列集合，用来存储一个个对象

    ​ |—Set接口：存储无序的、不可重复的数据。–>高中数学的集合

    ​ |—HashSet:作为Set接口的主要实现类；线程不安全；可以存储null值。

    ​ |—LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。

    对于频繁的遍历操作，LinkedHashSet效率高于HashSet

    ​ |—TreeSet:可以按照添加对象的指定属性进行排序。

    Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法

    要求

    • 向Set中添加数据时，其所在的类一定要重写hashCode()和equals()
    • 重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码（哈希值）

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

    一、存储无序的、不可重复的数据

    ​ 以HashSet为例说明：
    ​ 1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

    2.不可重复性：保证添加的元素按照equals()判断时，不能返回true. 即相同的元素只能添加一个。

    二、添加数据的过程（以HashSet为例）：

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

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

    对于添加成功的情况2和情况3而言：元素a与已经存在的指定索引位置上的元素以链表的方式存储：
    jdk7：元素a放到数组中，指向原来的元素
    jdk8：原来的元素放在数组中，指向元素a
    总结：“七上八下”
    HashSet底层：数组+链表的结构。

    HashSet的使用

    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(123);
        set.add(456);
        set.add("jack" );
        set.add("ζ");
        set.add(new User("Tom",20));
        set.add(new User("Tom",20));

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    LinkedHashSet的使用

    LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
    优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(123);
        set.add(456);
        set.add("jack" );
        set.add("ζ");
        set.add(new User("Tom",20));
        set.add(new User("Tom",20));

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    TreeSet的使用

    1.向TreeSet中添加的数据，要求是相同类的对象。
    2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator），定制排序的优先级高于自然排序（即同时存在时，定制排序会覆盖自然排序）
    3.自然排序中比较两个对象是否相同的标准为：compareTo()方法返回0，不再是equals()方法
    4.定制排序中比较两个对象是否相同的标准为：compare()方法返回0，不再是equals()方法

     @Test
    public void test1(){
        TreeSet set = new TreeSet();
        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("ζ");
//        set.add(new User("Tom",20));
        //举例一：从小到大输出
//        set.add(123);
//        set.add(234);
//        set.add(987);
//        set.add(654);
//        Iterator iterator = set.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        //举例二：
        set.add(new User("Tom",20));
        set.add(new User("Marry",19));
        set.add(new User("John",21));
        set.add(new User("George",18));
        set.add(new User("George",20));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /* 
        结果：
        User{name='Tom', age=20}
        User{name='Marry', age=19}
        User{name='John', age=21}
        User{name='George', age=18}
        User{name='George', age=20}
        */
    }

    @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);//传入Comparator对象的参数，实现定制排序
        set.add(new User("Tom",20));
        set.add(new User("Marry",19));
        set.add(new User("John",21));
        set.add(new User("George",18));
        set.add(new User("George",20));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
         /* 
        结果：
        User{name='George', age=18}
        User{name='Marry', age=19}
        User{name='Tom', age=20}
        User{name='John', age=21}
        */
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    User类

    public class User implements Comparable{//继承Comparable接口，实现自然排序
    private  String name;
    private int age;

/*
......（Constructor & getter and setter）
*/

    @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("输入的类型不匹配");
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    Map接口

    Map接口的框架结构

    |—Map：双列数据，存储key-value对的数据 --类似于高中数学的函数

    ​ |—HashMap：作为Map的主要实现类；线程不安全，效率高；可以存储null的key和value

    ​ |—LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序进行遍历

    ​ 原因：在原有的HashMap底层结构的基础上，添加了一对指针，指向前一个和后一个键值对，对于频繁的遍历操作，此类执行效率高于HashMap

    ​ |—TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序和定制排序。

    ​ 底层使用红黑树

    ​ |—Hashtable：作为古老的实现类；线程安全，效率低；不能存储null的key和value

    ​ |—Properties：常用来处理配置文件。key和value都是String类型

    HashMap的底层：数组+链表（jdk7及以前）

    数组+链表+红黑树（jdk8）

    Map结构的理解

    Map中的key：无序的、不可重复的，使用Set存储所有的key —> key所在的类要重写equals()和hashCode()方法 （以HashMap为例）

    Map中的value：无序的、可重复的，使用 Collection存储所有的value —> 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的哈希值和已经存在的某一个数据的哈希值相同，继续比较：调用key1所在类的equals方法，比较：

        • 如果equals()返回false：此时key1-value1添加成功； —情况3

        • 如果equals()返回true：使用value1替换相同key的value值。（覆盖）

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

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

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

    1. new HashMap()：底层没有创建一个长度为16的数组

    2. jdk8底层的数组是：Node[],而非Entry[]

    3. 首次调用put()方法时，底层创建长度为16的数组

    4. jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树

    5. 当数组的某一个索引位置上的元素以链表存在的数据个数 > 8 且当前数组的长度 > 64,此时此索引位置上的所有数据改为用红黑树存储。

    一些参数：

    • DEFAULT_INITIAL_CAPACITY：HashMap的默认容量：16

    • DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75

    • threshold：扩容的临界值（=容量填充因子）：160.75 => 12

    • TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8

    • MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64

    LinkedHashMap的底层实现原理

    源码中：

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    Map接口中定义的方法

    添加、删除、修改操作：

    • 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中的所有数据

    元素查询的操作：

    • 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是否相等

    元视图的操作方法：

    • Set keySet()：返回所有key构成的Set集合
    • Collection values()：返回所有value构成的Collection集合
    • Set entrySet()：返回所有key-value对构成的Set集合

    总结：常用方法

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

import org.junit.Test;

import java.util.*;

/**
 * @author zeta
 * @date 2022/7/20 - 14:24
 */
@SuppressWarnings("all")
public class MapTest {
    /*
    元视图的操作方法：
    Set keySet()：返回所有key构成的Set集合
    Collection values()：返回所有value构成的Collection集合
    Set entrySet()：返回所有key-value对构成的Set集合
     */
    @Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("ZZ",1234);
        map.put("BB",332);
        map.put("CC",456);

        //遍历所有的key集：keySet()
        map.keySet().forEach(System.out::println);

        System.out.println("*****************");
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj:values){
            System.out.println(obj);
        }
        System.out.println("*****************");
        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+" ---> "+entry.getValue());
        }
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator1 = keySet.iterator();
        while (iterator1.hasNext()){
            Object key = iterator1.next();
            Object value = map.get(key);
            System.out.println(key+" ==> "+value);
        }
    }


    /*
    元素查询的操作：
    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(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("ZZ",123);
        map.put("BB",332);
        map.put("CC",456);
        //Object get(Object key)
        System.out.println(map.get("AA"));
        //boolean containsKey(Object key)
        boolean bb = map.containsKey("BB");
        System.out.println(bb);
        //boolean containsValue(Object value)
        bb = map.containsValue(123);
        System.out.println(bb);

        System.out.println(map.size());
        map.clear();
        System.out.println(map.isEmpty());
        System.out.println(map.size());

    }

    /*
    添加、删除、修改操作：
    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(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put("ZZ",123);
        map.put("BB",332);
        map.put("CC",456);
        //修改
        map.put("AA",55);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("EE",123);
        map1.put("GG",123);
        map.putAll(map1);
        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear();
        System.out.println(map.size());
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new LinkedHashMap();
        map.put(123,"AA");
        map.put(345,"BB");
        map.put(12,"CC");
        map.entrySet().forEach(System.out::println);

    }
    @Test
    public void test1(){
        Map map = new HashMap();
//        map = new Hashtable();
        map.put(null,123);

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144

    TreeMap介绍

    TreeMap在原理上类似于TreeSet；向TreeMap中添加key-value，要求key必须是由同一个类创建的对象，因为要按照key进行排序（自然排序、定制排序）。

    package com.map;

import org.junit.Test;

import java.util.Comparator;
import java.util.TreeMap;

/**
 * @author zeta
 * @date 2022/7/20 - 18:31
 */
@SuppressWarnings("all")
public class TreeMapTest {
    //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    //因为要按照key进行排序：自然排序、定制排序
    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",20);
        User u2 = new User("Jerry",18);
        User u3 = new User("Mike",21);
        User u4 = new User("George",19);
        map.put(u1,78);
        map.put(u2,95);
        map.put(u3,89);
        map.put(u4,80);

        map.entrySet().forEach(System.out::println);
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(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());
                }
                throw new RuntimeException("输入的数据类型不匹配");

            }
        });
        User u1 = new User("Tom",20);
        User u2 = new User("Jerry",18);
        User u3 = new User("Mike",21);
        User u4 = new User("George",19);
        map.put(u1,78);
        map.put(u2,95);
        map.put(u3,89);
        map.put(u4,80);

        map.entrySet().forEach(System.out::println);
    }
}


//User类
package com.map;

/**
 * @author zeta
 * @date 2022/7/18 - 19:41
 */
public class User implements Comparable{
    private  String name;
    private int age;

    /*
    构造器、getter、setter方法
    */

    @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("输入的类型不匹配");
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119

    Properties类

    Properties：常用来处理配置文件：key和value都是String类型

    package com.map;

import java.io.FileInputStream;
import java.util.Properties;

/**
 * @author zeta
 * @date 2022/7/20 - 19:09
 */
@SuppressWarnings("all")
public class PropertiesTest {
    //Properties：常用来处理配置文件：key和value都是String类型
    public static void main(String[] args) throws Exception {
        Properties pros = new Properties();
        FileInputStream fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//加载流对应的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");
        System.out.println("name = "+name+",password = "+password);
        fis.close();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    jdbc.properties

    name=zeta
password=123456

    • 1
    • 2

    Collections工具类

    Collections：操作Collection、Map的工具类

    Collection和Collections的区别:

    • Collection为单例集合的接口
    • Collections为操作Collection、Map的工具类

    Collections中的一些方法

    reverse(List list)：反转List中元素的顺序
    shuffle(List list)：对List随机排序
    sort(List list [,Comparator])：对List自然排序/定制排序
    swap(List list,int i,int j)：交换list中索引i和索引j处的元素
    Object max(List list,[Comparator]) / min(…) : 求list(自然排序或定制排序)中的最大值/最小值
    frequency(List list ,Object o)：返回元素o在list中出现的次数
    Collections.copy(List dest,List src) : 拷贝src中的元素到dest中

    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(3);
        list.add(12);
        list.add(12);
        list.add(456);
        list.add(4);

        //错误：报异常IndexOutOfBoundsException
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
        //正确
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list);
        System.out.println(dest);
    }

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(3);
        list.add(12);
        list.add(12);
        list.add(456);
        list.add(4);
        list.add(56);
        list.add(78);
        list.add(89);
        System.out.println(list);
        //reverse(List list)：反转List中元素的顺序
        Collections.reverse(list);
        System.out.println(list);
        //shuffle(List list)：对List随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //sort(List list)：对List自然排序
        Collections.sort(list);
        System.out.println(list);
        //swap(List list,int i,int j)：交换list中索引i和索引j处的元素
        Collections.swap(list,2,3);
        System.out.println(list);
        //Object max(List list,[Comparator]) / min(...)

        //frequency(List list ,Object o)：返回元素o在list中出现的次数
        System.out.println(Collections.frequency(list, 12));

    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    Collection的线程同步方法

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

    public void test3(){
        List list = new ArrayList();
        list.add(123);
        list.add(3);
        list.add(12);
        list.add(12);
        list.add(456);
        list.add(4);
        /*
        Collections类中提供了多个synchronizedXxx()方法，
        这些方法可以将指定集合包装成线程同步的集合，从而可以解决
        多线程并发访问集合时的线程安全问题
         */
        //返回值为线程安全的list
        List list1 = Collections.synchronizedList(list);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
  • 相关阅读:
    面了三十个人，说说真实感受
    边学边记——Java数据结构☞ArrayList（顺序表）和LinkedList（链表）的对比总结
    Git_回退到上一次commit与pull
    【npm 错误】：npm ERR! code ERESOLVE、npm ERR! ERESOLVE could not resolve问题
    java计算机毕业设计精准扶贫项目管理系统源码+mysql数据库+系统+lw文档+部署
    Neodynamic ZPLPrinter Web API for Docker
    【前端】学习前端vue框架MVVM模式
    计算机毕业设计-基于SpringBoot疫苗接种反应上报系统-java接种上报信息统计分析系统-远程调试+讲解+文档
    跳台阶游戏(Python排列组合函数itertools.combinations的应用)
    【快乐离散数学】谓词与量词 | 嵌套量词 | 狄摩根定律 | Predicates and Quantifiers | Nested Quantifiers
  • 原文地址：https://blog.csdn.net/a534563/article/details/125899828