Java复习十：集合的使用

Collection集合

collection接口的常用方法

package com.xiazhui.java1;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * TODO
 * 集合
 *
 * 1 集合，数组都是对多个数据进行存储操作的结构，简称Java容器
 *      此时的存储,主要指的时内存层面的存储，不涉及到持久化（txt,jpg,avi,数据库）的存储
 * 2.1 数组在存储数据方面的特点
 *      >一旦初始化后，长度就确定了
 *      >数组一旦定义好之后，元素的类型也就确定了。但数组可以表现多态性（用Object）
 * 2.2 数组在存储数据方面的缺点
 *      >一旦初始化以后，其长度就不可修改
 *      >数组中提供的方法很有限，对于添加,删除,插入数据等操作,非常不方便,效率不高。
 *      >获取数组中实际元素的个数的需求，数组没有现成属性或方法可用
 *      >数据存储数据的特点：有序，可重复。对于无序，不可重复的需求，不能满足
 *
 *二 集合框架
 *       /----Collection接口：单列集合，用来存储一个一个的对象
 *              /----List接口：存储有序的，可重复的数据。   -->"动态"数组
 *                  /----ArrayList,LinkedList,Vector
 *              /----Set接口: 存储无序的，不可重复的数据。
 *                  /----HashSet,LinkedHashSet,TreeSet
 *       /----Map接口：双列集合，用来存储一对（key-value）一对的数据
 *                  /----HashMap,LinkedHashMap,TreeMap,HashTable,Properties
 *
 * 三 Collection接口中的方法的使用
 *      1 boolean add(E e)
 *      2 boolean addAll(Collection coll)
 *      3 void clear()
 *      4 boolean isEmpty()
 *      5 int size()
 *      6 boolean contains(Object obj) 调用equals()方法依次和Collection中的元素比较，找到就停止
 *              向Collection接口的实现类的对象中添加obj时，要求obj所在的类(基本数据类型自动装箱)要重写equals()
 *      7 boolean containsAll(Collection cool1) 判断形参cool1中的数据是否都在当前对象中
 *      8 boolean remove(Collection coll1)  差集。删除共有的元素，并返回ture,未删除false
 *      9 retainAll(Collection coll) 当前集合保留当前集合和coll集合的交集
 *      10 equals(Object obj) 判断当前集合是否和obj相同，如果有序则顺序应该也相同
 *      11 hashCode() 返回当前对象的hash值
 *      12 toArray() 将集合转化为Object数组
 *                   使用基本数据类型数组会默认为一个数组，包装类则不会
 *      13 iterator(): 返回Iterator接口的实例，用户遍历集合元素
 *  @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/14/16:15
 */
public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(Object e)
        coll.add("AA");
        coll.add(123);  //自动装箱
        coll.add(new Date());

        //size()获取添加的元素的个数
        System.out.println(coll.size());

        //addAll(Collection coll)讲coll集合中的全部元素添加到当前集合中
        Collection coll1=new ArrayList();
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.addAll(coll);

        System.out.println(coll1.size());
        System.out.println(coll1);

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

        //clear()清空集合元素
       // coll1.clear();
        System.out.println(coll1.isEmpty());

        //contains() 使用的equals方法
        System.out.println(coll1.contains(456));
        System.out.println(coll1.contains(new String("Tom")));

        coll1.add(new People("小明",17));
        System.out.println(coll1.contains(new People("小明",17)));

        System.out.println(coll1.containsAll(Arrays.asList(123, "Tom")));
    }

    @Test
    public void test2(){
        Collection coll = new ArrayList();

        coll.add("AA");
        coll.add(123);  //自动装箱
        coll.add(new Date());
        coll.add(new People("小明",17));
        coll.add(new String("Tom"));

        //boolean remove(Object obj):从当前集合中移除obj元素
        System.out.println(coll.remove(134));
        System.out.println(coll.remove(new People("小明", 17)));

        //boolean remove(Collection coll1)  差集。删除共有的元素，并返回ture,未删除false
        //System.out.println(coll.removeAll(Arrays.asList("AA", 123,"CC")));
        System.out.println(coll);

        //retainAll(Collection coll) 当前集合保留当前集合和coll集合的交集，
        coll.retainAll(Arrays.asList("AA",123,"CC"));
        System.out.println(coll);

        //equals(Object obj)判断当前集合是否和obj相同，如果有序则顺序应该也相同
        Collection coll2=Arrays.asList(123,"AA");
        System.out.println(coll.equals(coll2));

        //toArray() 集合--->数组
        //list[] asList 输入--->集合
        Object[] objects = coll2.toArray();

        //使用基本数据类型数组会默认为一个数组
        List ints = Arrays.asList(new int[]{123, 456});
        System.out.println(ints.size());//1

        List integers = Arrays.asList(new Integer[]{123, 456});
        System.out.println(integers.size());//2

        //iterator(): 返回Iterator接口的实例，用户遍历集合元素
    }
}

class People{
    private String name;
    private int age;

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

    public People() {
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        People people = (People) o;
        return age == people.age && Objects.equals(name, people.name);
    }

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

List接口和常用实现类，方法

package com.xiazhui.java;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * TODO
 *
 * 1 /----Collection接口：单列集合，用来存储一个一个的对象
 *      /----List接口：存储有序的，可重复的数据。   -->"动态"数组
 *               /----ArrayList 作为List的主要实现类:线程不安全，效率高，底层用Object[] elementDate保存
 *               /----LinkedList 对于频繁的插入，删除操作.使用此类比ArrayList高，因为底层用双向链表实现
 *               /----Vector     作为List的古老实现类:线程安全，效率低,底层用Object[] elementDate保存
 *
 *  2 ArrayList,LinkedList,Vector三者的异同:
 *      同：三个类都实现了List接口，存储数据的特点相同，存储有序的可重复的数据
 *      异：ArrayList 作为List的主要实现类:线程不安全，效率高，底层用Object[] elementDate保存
 *         LinkedList 对于频繁的插入，删除操作.使用此类比ArrayList高，因为底层用双向链表实现
 *         Vector     作为List的古老实现类:线程安全，效率低,底层用Object[] elementDate保存
 *
 *  3 ArrayList源码分析
 *      jdk7:底层创建长度为10的Object[]数组ElementDate,如果添加导致数组容量不足，
 *           则扩容,默认扩容1.5倍,如果扩后仍不够，则直接用需要的内存，如果超过最大限制，
 *           则会使用jdk定义的最大的容量
 *      jdk8:声明对象时创建长度为0的数组，添加时才创建，扩容操作相同
 *
 *  4 LinkedList源码分析
 *      底层为双向链表，有一个内部类node
 *   Vector源码分析
 *      通过构造器默认创建长度为10的Object[]数组，扩容扩为2倍
 *
 *  5 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 formIndex,int toIndex):返回从fromIndex到toIndex位置的子集合
 *
 *    总结：常用方法
 *          增  add(Object obj)
 *          删 remove(int index),remove(Object obj)
 *          改 set(int index,Object obj)
 *          查 get(int index)
 *          插 add(int index,Object ele)
 *          长度 size()
 *          遍历 iterator(),forEach
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/16/17:04
 */
public class ListTest {
    @Test
    public void test2(){
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add("AA");

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

        for (Object arrayList1:
             arrayList) {
            System.out.println(arrayList1);
        }

        for (int i=0;i<arrayList.size();i++){
            System.out.println(arrayList.get(i));
        }
    }
    @Test
    public void test1(){
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add("AA");
        System.out.println(arrayList);
        arrayList.add(2,2.45);
        System.out.println(arrayList);

        List integers = Arrays.asList(1, 2, 3);
        arrayList.addAll(integers);
        System.out.println(arrayList);

        System.out.println(arrayList.get(0));
        System.out.println(arrayList.indexOf(999));
        System.out.println(arrayList.lastIndexOf(2));

        //remove方法重载,如果是坐标则返回坐标元素，否则返回同个元素
        Object remove = arrayList.remove(2);
        Object obj=2;
        //arrayList.remove(obj);
        //也可能使用装箱解决
        arrayList.remove(new Integer(2));
        System.out.println(arrayList);
        System.out.println(remove);

        //set
        arrayList.set(2,34);
        System.out.println(arrayList);

        //subList(int fromIndex,int toIndex)
        List list = arrayList.subList(2, 4);
        System.out.println(arrayList);
        System.out.println(list);

    }
}

Iterator迭代器

package com.xiazhui.java;

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

/**
 * TODO
 * 使用Iterator遍历集合元素
 *
 * Iterator仅用于遍历集合
 * 集合对象每次调用iterator本身并不提供装载对象的能力
 * 每次调用iterator方法都会产生一个新的迭代器，总位于首个元素
 *
 * 1 next() 迭代器后移并输出当前位置元素
 * 2 hasNext() 判断是否还有下一个元素有元素
 * 3 remove() 移除当前元素 如果还未调用next()或者
 *            已经调用remove()之后未调用next()再次调用remove()会抛IllegalStateException
 *
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/16/16:29
 */
public class IteratorTest {
    public static void main(String[] args) {

        Collection coll = new ArrayList();

        //add(Object e)
        coll.add("AA");
        coll.add(123);  //自动装箱
        coll.add(new Date());

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

Set接口+常用实现类

package com.xiazhui.java;

import org.junit.jupiter.api.Test;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Set;

/**
 * /----Collection接口：单列集合，用来存储一个一个的对象
 *              /----Set接口: 存储无序的，不可重复的数据。
 *                  /----HashSet:作为Set接口的主要实现类；线程不安全：可以存储null值
 *                      /----LinkedHashSet：作为HashSet的子类:遍历内部数据时，可以按照添加的顺序遍历
 *                                          对于频繁的遍历，LinkedHashSet的效率要高于HashSet
 *                  /----TreeSet：可以按照添加对象的指定属性，进行排序
 *
 * 1 Set接口中没有额外定义新的方法，使用的都是Collection中声明的方法
 * 2 Set中添加的数据，其所在的类一定要重写hashCode()和equals()
 *  重写的hashCode()和equals()要保持一致，相等的对象必须要相等的散列值
 *         重写原则：1 当程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值
 *              2 当两个对象的equals()方法比较返回true时，这两个对象的hashCode()方法返回的值也应相等
 *              3 对象中用作equals()方法比较的Field,都应该用来计算hashCode值
 *
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/17/0:51
 */
public class SetTest {
    /**
     * 一、Set:存储无序的，不可重复的数据
     * 1. 无序性：不等于随机性。存储的数据在底层数组中
     *          并非按数组索引的顺序添加。而是根据数据的hash值决定的
     * 2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true
     *
     * 二、添加元素的过程：以HashSet为例：
     *      向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值
     *      此哈希值通过散列函数计算出在HashSet底层数组中的存放位置，判断数组此位置上是否已有元素，
     *          如果没有其他元素，则元素a添加成功
     *          如果有其他元素，则比较a，b的hash值
     *              如果值不同，则添加成功
     *              如果值相同，则再调用元素a所在的equals()方法
     *                     equals()返回true,则添加失败
     *                     equals()返回false,则添加成功
     *      对于冲突，冲突的元素使用链式法解决
     *       jdk7:a放在数组中，b进入链表
     *       jdk8:a进入链表，b在数组中指向a
     *
     *
     */
    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new People("Tom",12));
        set.add(new People("Tom",12));
        set.add(129);

        for (Object obj:
             set) {
            System.out.println(obj);
        }
    }

    /**
     * LinkedHashSet的使用
     * LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用
     *    用于记录前一个数据和后一个数据
     * 优点：对于频繁的遍历操作LinkedHashSet效率要高于HashSet
     */
    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new People("Tom",12));
        set.add(new People("Tom",12));
        set.add(129);

        for (Object obj:
                set) {
            System.out.println(obj);
        }
    }
}
class People implements Comparable{
    private String name;
    private int age;

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

    public People() {
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        People people = (People) o;
        return age == people.age && Objects.equals(name, people.name);
    }

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

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


    @Override
    public int compareTo(Object o) {
        if (o.getClass()==this.getClass()){
            People p=(People) o;
            if (this.name.compareTo(p.name)==0){
                return Integer.compare(this.age,p.age);
            }
            return this.name.compareTo(p.name);
        }else
            throw new RuntimeException("类型不匹配");
    }
}

TreeSet

package com.xiazhui.java;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/17/16:31
 */
public class TreeSetTest {
    /**
     * 1 向TreeSet中添加数据，要求是相同类的对象
     * 2 两种排序方式：自然排序 和 定制排序
     *
     * 3 自然排序中，比较两个对象是否相同的标准为CompareTo()是否返回为0，而不是equals()
     */
    @Test
    public void test1(){
        Set set=new TreeSet();
//        set.add(34);
//        set.add(24);
//        set.add(454);
//        set.add(33);

        set.add(new People("Tom",12));
        set.add(new People("Jerry",18));
        set.add(new People("Nick",23));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test2(){
        TreeSet set=new TreeSet(new Comparator() {

            @Override
            public int compare(Object o1, Object o2) throws RuntimeException{
                if (o1 instanceof People&&o2 instanceof People){
                    return ((People) o1).compareTo(o2);
                }
                throw  new RuntimeException("数据类型不匹配");
            }
        });

        set.add(new People("Tom",12));
        set.add(new People("Jerry",18));
        set.add(new People("Nick",23));
        set.add(new People("Mary",23));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        set.forEach(System.out::println);
    }
}

Map

package com.xiazhui.java;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 *  一：/----Map:双列数据，存储key-value对的数据
 *      /----HashMap: 作为map的主要实现类，线程不安全，效率高。可以存储null的key和value
 *           /----LinkedHashMap: 保证在遍历map元素时，可以按添加顺序实现遍历
 *                   原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素
 *                   对于频繁的遍历操作，此类执行效率高于HashMap
 *      /----TreeMap:保证按照添加的key-value进行排序，实现排序遍历。按照key实现排序
 *                   底层使用红黑树
 *      /----Hashtable: 作为map的古老实现类，线程安全，效率低。不可以存储null的key和value
 *          /----Properties:常用来处理配置文件。  key和value都是String类型
 *
 *
 *  1 hashMap的底层实现原理?
 *  2 HashMap和HashTable的异同?
 *  3 CurrentHashMap与Hashtable的异同?
 *
 *  二：Map结构的理解
 *      Map中的key:无序的,不可重复的,使用Set存储搜友的key--->key所在的类需要重写equals()和hashCode()方法
 *      Map中的value:无序的，可重复的,使用Collection存储所有的value--->value所在的类要重写equals()
 *      一个键值对：key-value构成了一个Entry对象
 *      Map中的entry:无序的，不可重复的，使用Set存储所有的entry
 *
 *  三 ：HashMap的底层实现原理?
 *      无参构造器之后，底层创建了一个一位数组Entry[] table。
 *      放入map.put(key1,value1)时
 *      首先，调用key1的hashCode()，计算key1的哈希值，经过散列函数之后，得到Entry数组中的存放位置
 *      如果此位置上的数据为空，此时的key1-value1添加成功
 *      如果位置上的数据不为空，比较key1和已经存在的一个或多个数据的hash值
 *          如果key1的hash值和已经存在的数据hash值都不相同，则key1-value1添加成功
 *          如果key1的哈希值和已经存在的某个数据的哈希值相同，继续比较：调用key1所在类的equals()方法
 *              如果equals()返回false：此时key1-value1添加成功
 *              如果equals()返回true：使用value1替换value2
 *
 *      在不断的添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空）时，默认的扩容方式：扩容为原来容量的二倍，并将原有的数据复制进来
 *
 *      jdk8 相较于jdk7在底层实现方面的不同：
 *      1 new HashMap():底层没有创建一个长度为16的数组
 *      2 jdk8底层的数组时:Node[]，而非Entry[]
 *      3 首次调用put()方法时，底层创建长度为16的数组
 *      4 jdk7底层的结构：数组+链表 jdk8中底层结构：数组+链表+红黑树
 *         当数组的某一个索引上的元素以链表形式存在的数据个数>8且当前数组的长度>64时
 *         此时此索引位置上的所有数据改为使用红黑树存储
 *
 *      DEFAULT_INITIAL_CAPACITY: HashMap的默认容量 16
 *      DEFAULT_LOAD_FACTOR: HashMap的默认加载因子: 0.75
 *      threshold: 扩容的临界值，=容量*加载因子：16*0.75=12
 *      TREEIFY_THRESHOLD: Bucket中链表长度大于改默认值，转化为红黑树：8
 *      MIN_TREEIFY_CAPACITY: 桶中的Node被树化时最小的hash表容量:64
 *
 * 四：LinkedHashMap的底层实现原理
 *      源码中继承父类HashMap的node结点，但增加了before,after引用，使得有一条链表可以使用
 *
 * 五：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构成的Collections集合
 *    Set entrySet(): 返回所有key-value对构成的Set集合
 *
 *    常用方法：
 *    增 Object put(Object key,Object value); 如果修改返回原值，否则返回null
 *    删 Object remove(Object key)
 *    修改 Object put(Object key,Object value)
 *    查询 Object get(Object key)
 *    长度 int size()
 *    遍历 Set keySet()/Collection values()/Set entrySet()
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/18/10:34
 */
public class MapTest {

    /**
     *  TODO
     *  原视图的操作方法：Map的遍历
     *
     *  Set keySet(): 返回所有key构成的Set集合
     *  Collection values(): 返回所有value构成的Collections集合
     *  Set entrySet(): 返回所有key-value对构成的Set集合
     */
    @Test
     public void test4(){
         Map map = new HashMap();
         map.put("AA",123);
         //TreeMap中要求存储元素是同一个类的对象
        Object put = map.put(45, 123);
        map.put("BB",56);
        Object aa = map.put("AA", 87);
        System.out.println(aa);
        System.out.println();

        map.put("CC",1234);

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

        System.out.println();
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }


        System.out.println();
        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()){
            //集合中的元素都是entry
            System.out.println((Map.Entry)iterator1.next());
        }

        System.out.println();
        Set set2 = map.keySet();
        Iterator iterator2 = set2.iterator();
        while (iterator2.hasNext()){
            Object key=iterator2.next();
            System.out.println(key+"==="+map.get(key));
        }
    }

    /**
     *    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 test3(){
        Map map = new HashMap();
        map.put("AA",123);
        //TreeMap中要求存储元素是同一个类的对象
        map.put(45,123);
        map.put("BB",56);
        map.put("AA",87);

        map.put("CC",123);

        System.out.println(map.get("AA"));
        boolean b = map.containsKey("AA");
        boolean b1 = map.containsValue(123);
        System.out.println(b1 == b);

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

    /**
     *    添加，删除，修改操作
     *    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 test2(){
        Map map = new HashMap();
        map.put("AA",123);
        //TreeMap中要求存储元素是同一个类的对象
        map.put(45,123);
        map.put("BB",56);
        map.put("AA",87);

        map.put("CC",123);
        Object cc = map.remove("CC");
        System.out.println(cc);

        System.out.println(map);

        map.clear();
        System.out.println(map);
    }
    @Test
    public void test1(){
        HashMap hashMap = new HashMap();
        hashMap.put(null,null);

//        Hashtable hashtable = new Hashtable();
//        hashtable.put(null,123);
    }
}

Properties

package com.xiazhui.java;

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

/**
 * Properties主要用来处理配置文件
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/19/9:14
 */
public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
        properties.load(fileInputStream);

        System.out.println(properties.getProperty("name"));
        System.out.println(properties.getProperty("password1"));
        System.out.println(properties.getProperty("password"));

    }
}

Collections工具类

package com.xiazhui.java;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * TODO
 * Collections：操作Collection,Map的工具类
 * @Author: xiazhui
 * version 1.0
 * @Date: 2022/08/19/9:38
 */
public class CollectionsTest {
    /**
     * reverse(List):反转List中元素的顺序
     * shuffle(List):对List集合元素进行随机排序
     * sort(List):根据元素的自然顺序对指定List集合元素按升序排序
     * sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
     * swap(List ,int ,int)：将指定list集合中的i处元素和j处元素进行交换
     *
     * 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中的所有旧值
     */
    @Test
    public void test(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);

        System.out.println(list);
//        Collections.reverse(list);
//        Collections.shuffle(list);
//        Collections.sort(list);
//        Collections.swap(list,1,2);

        List dest=Arrays.asList(new Object[list.size()]);
        System.out.println(dest);

        Collections.copy(dest,list);
        System.out.println(list);
        System.out.println(dest);

        //IndexOutOfBoundsException，因为目标size小于源size
//        ArrayList arrayList = new ArrayList();
//        Collections.copy(arrayList,list);

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

        //返回的一个list是线程安全的
        List list1 = Collections.synchronizedList(list);


    }
}