JavaSE进阶集合

数组声明了它容纳的元素的类型，而集合不声明。
数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了。而集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求。
数组的存放的类型只能是一种（基本类型/引用类型）,集合存放的类型可以不是一种(不加泛型时添加的类型是Object）。（疑惑：如果数组定义为Object[]的，也可以存放多类型）
数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的。

有什么用？

集合为什么说在开发中使用较多?集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

存储内容的内存图

集合不能直接存储基本数据类型，另外集合也不能直接存储java对象,集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）

list.add(100);    //自动装箱Integer

注意∶集合在java中本身是一个容器，是一个对象。集合中任何时候存储的都是"引用"。

对象引用和对象的区别

java--对象引用与对象的区别_王小的博客-CSDN博客_java 对象指向

不同的数据结构

在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构?数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。例如∶数组、二叉树、链表、哈希表...以上这些都是常见的数据结构。

new ArrayList();    //创建一个集合，底层是数组
new LinkedList();   //创建一个集合对象，底层是链表 
new Treeset();      //创建一个集合对象，底层是二叉树

在java JDK中哪个包下?

java.util.*;所有的集合类和集合接口都在java.util包下

集合继承结构图

Collection

能存放什么元素？

没有使用"泛型"之前，Collection中可以存储object的所有子类型。使用了"泛型"之后，Collection中只能存储某个具体的类型。

Collection常用的方法

boolean add(E e);   
//返回值为boolean是因为通过源码我们可以看到它通过是否修改原有集合来返回true或者false
int size();
void clear();
boolean contains(Object o);
boolean remove(Object o);
boolean isEmpty();
Object[] toArray();

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

public class Test {

    public static void main(String[] args) {
        //Collection c=new Collection(); 接口是抽象的，无法实例化
        //创建一个集合对象
        Collection c = new ArrayList();
        c.add(1200);//自动装箱，实际上是放进去了一个对象的内存地址
        c.add(3.14);
        c.add(new Object());
        c.add(new Student());
        c.add(true);

        //获取集合中元素的个数
        System.out.println("集合中元素个数是：" + c.size());//5

        //清空集合
        c.clear();
        System.out.println("集合中元素个数是："+c.size());//0

        //再添加元素
        c.add("Hello");
        c.add("World");
        c.add("浩克");
        c.add("绿巨人");

        //判断当前集合中是否包含“绿巨人”
        boolean flag=c.contains("绿巨人");
        System.out.println(flag);//true
        System.out.println(c.contains("奇异博士"));//false
        System.out.println("集合中元素个数是："+c.size());//4

        //删除集合中某个元素
        c.remove("World");
        System.out.println("集合中元素个数是："+c.size());//3

        //判断集合是否为空
        System.out.println(c.isEmpty());//false
        c.clear();
        System.out.println(c.isEmpty());//true

        c.add("asd");
        c.add("qwe");
        c.add("浩克");
        c.add("绿巨人");
        //String和Integer都重写了toString方法，而Student没有
        c.add(new Student());

        //转换为数组
        Object[] objs=c.toArray();
        for(int i=0;i< objs.length;i++){
            System.out.println(objs[i]); //最后一个是Test.Student@1b6d3586
        }

    }

}
class Student{
    
}

迭代器Iterator

该迭代方式是是所有 Collection 通用的一种方式，在 Map 中不能用，在所有 Collection 以及所有子类中使用
集合结构只要发生改变，迭代器必须重新获取
在迭代集合元素过程中，不能调用集合对象的 remove 方法删除对象，会发生异常（即第二点），这时可以用 Iterator 中的 remove 方法

//Iterator中的方法：
boolean hasNext();
Object next();
void remove();

上图画存储的对象不准确，明白意思就行

public class CollectionTest02 {

    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //添加元素
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new Object());
        c.add(100);
        //对集合Colletion进行迭代/遍历
        //第一步：获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();
        //第二步：通过以上获取的迭代器对象开始遍历集合

        while (it.hasNext()){

            //不管当初存进去什么，取出来统一为Object
            Object obj=it.next();
            //输出结果有序可重复
            System.out.println(obj);
        }

        Collection c2 = new HashSet();
        c2.add(1);
        c2.add(2);
        c2.add(5);
        c2.add(1);
        c2.add(3);
        c2.add(4);

        Iterator it2 = c2.iterator();
        while (it2.hasNext()){

            //输出结果无序不可重复
            System.out.println(it2.next());
        }
    }
}

结果：无序指的是存进去的顺序和取出来的顺序不一样

如果集合结构发生改变，迭代器没有重新获取时，会发生异常，以下是错误程序及其结果：

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

public class Test01 {

    public static void main(String[] args) {

        Collection c = new ArrayList();

        //不能在还没添加元素之前就获取迭代器
        //Iterator it = c.iterator();

        c.add(111);
        c.add(222);
        c.add(333);

        //需要添加元素后再获取迭代器
        Iterator it = c.iterator();
        
        while (it.hasNext()){

            Object o=it.next();
            //错误删除元素方式:通过用Collection中的remove方法
            c.remove(o);
            //正确的是迭代器的:it.remove()方法
            System.out.println(o);
        }
        //如果用正确的删除元素方法,得到的结果是0
        System.out.println("经过迭代器的remove后剩下的元素个数："+c.size());

    }
}

无论是还没添加元素前获取迭代器还是用错误删除元素的方法，都是得到以下报错：

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at Test.Test01.main(Test01.java:24)

可以理解为迭代器像一台照相机，拍下来的那一刻的照片后，编译器底层会时不时把当前最新状态的迭代器与照片对比，一旦最新状态的迭代器的结构发生变化就和照片对不上了，这时就会报错。直接通过集合去删除元素，没有通知迭代器（导致迭代器与原集合状态不同）迭代器去删除时，会自动更新迭代器

contains方法

boolean contains(Object o);    //判断集合中是都包含某个对象o

存放在集合中的类型，一定要重写equals方法

public class CollectionTest03 {

    public static void main(String[] args) {
        //boolean contains(Object o),判断集合中是都包含某个对象o
        //创建集合对象
        Collection c = new ArrayList();

        //向集合中存储元素
        String s1 = new String("abc");
        c.add(s1);

        String s2 = new String("def");
        c.add(s2);

        //元素个数
        System.out.println(c.size());

        String x = new String("abc");
        //c集合中是否包含x?
        //先说结果：true
        System.out.println(c.contains(x));

        Integer y =new Integer(10000);
        c.add(y);
        Integer z = new Integer(10000);
        System.out.println(c.contains(z));//true,因为Integer有重写equals方法

    }
}

内存图如下：注意x并没被add进集合，这时要看源代码是比较内容还是内存地址？（看底层有没调用equals）

ArrayList源码中有 o.equals(es[i]) 这一行，可以看到底层调用的是存放在集合中的元素的equals()方法，以上面例子来说明的话，这里的o就是x(是String类型，equals有重写)，es[i]就是s1


int indexOfRange(Object o, int start, int end) {
        Object[] es = elementData;
        if (o == null) {
            for (int i = start; i < end; i++) {
                if (es[i] == null) {
                    return i;
                }
            }
        } else {
            for (int i = start; i < end; i++) {
                if (o.equals(es[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

public class CollectionTest04 {
    public static void main(String[] args) {

        Collection c = new ArrayList();

        User u1 = new User("Jack");
        c.add(u1);
        User u2 = new User("Jack");
        //User没有重写equals()，用的是Object中的equals()方法，答案为false
        System.out.println(c.contains(u2));
    }
}
class User{
    private String name;

    public User() {
    }

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

remove方法

remove 和 contains 是一样的，底层都是调用 equals

public class CollectionTest05 {
    public static void main(String[] args) {

        Collection c = new ArrayList();

        String s1 = new String("hello");
        String s2 = new String("hello");

        c.add(s1);
        c.remove(s2);

        System.out.println(c.size());//结果为0
    }
}

ArrayList 下重写的 remove 源码

public boolean remove(Object o) {
        final Object[] es = elementData;
        final int size = this.size;
        int i = 0;
        found: {
            if (o == null) {
                for (; i < size; i++)
                    if (es[i] == null)
                        break found;
            } else {
                for (; i < size; i++)
                    if (o.equals(es[i]))
                        break found;
            }
            return false;
        }
        fastRemove(es, i);
        return true;
    }

List接口

List存储元素特点

有序可重复

有序：List集合中的元素有下标，从0开始，以1递增
可重复：存储1，可再存储1

特有方法

void add(int index, E element);
boolean add(E e)
E get(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
E remove(int index);
E set(int index, E element);

特有遍历

public class ListTest01 {

    public static void main(String[] args) {

        //要调用List的特有方法，应该创建List对象
        List mylist = new ArrayList();

        //默认都是向集合末尾添加元素
        mylist.add("A");
        mylist.add("B");
        mylist.add("C");
        mylist.add("C");
        mylist.add("D");
        //在列表的指定位置插入元素
        //这个方法使用不多，因为对于ArrayList集合来说效率比较低
        mylist.add(1,"KING");

        //迭代
        //结果：A KING B C C D
        Iterator it=mylist.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        //根据下标获取元素
        //这里由于前面都是String类型,也可以使用String来接收
        //但是如果有其他类,用Object
        Object firstObj = mylist.get(0);
        System.out.println(firstObj);

        //因为有下标，所以List有比较特殊的遍历方式
        //通过下标遍历，List集合特有的，set没有
        for(int i=0;i<mylist.size();i++){
            Object obj = mylist.get(i);
            System.out.println(obj);
        }

        //获取指定对象第一次出现处的索引
        System.out.println(mylist.indexOf("KING")); //1

        //获取指定对象最后一次出现处的索引
        System.out.println(mylist.lastIndexOf("C"));//4

        //删除指定下标的元素
        mylist.remove(0);
        System.out.println(mylist.size());//5

        //修改指定位置的元素
        mylist.set(2, "soft");

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

}

ArrayList

初始化容量及扩容

默认初始化容量为10（JDK8：底层先添加了一个长度为0的数组，当添加第一个元素的时候，初始化容量10）
底层是一个Object[ ] 数组
扩容到原容量1.5倍
建议给定一个预估计的初始化容量，减少数组的扩容次数，ArrayList比较重要的优化策略
数组优点：检索效率比较高；缺点：随机增删元素效率比较低
这么多集合中，ArrayList用的最多，因为往（前提是数组容量未满）数组末尾添加元素，效率不受影响，另外，我们检索/查找某个元素的操作比较多

构造方法

public class ArrayListTest01 {
    public static void main(String[] args) {

        //默认初始化容量是10(数组长度)
        List list1 = new ArrayList();
        //指定初始化容量是20（数组长度）
        List list2 = new ArrayList(20);

        for(int i=1;i<=10;i++){
            list1.add(i);
        }
        //自动扩容1.5倍
        list1.add(11);

        Collection c = new HashSet();
        //Set c=new HashSet();也可以
        c.add(1);
        c.add(2);
        c.add(3);
        c.add(4);

        //通过这个构造方法可以将HashSet集合转换成List集合
        List list3 = new ArrayList(c);
        for(int i=0;i<list3.size();i++){
            System.out.println(list3.get(i)); //输出1 2 3 4
        }
        
        
    }
}

LinkedList

单向链表的结构

优点：由于链表上的元素在空间存储上内存地址不连续，所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高（业务需求集合元素增删多时采用）
缺点：不能通过数学表达式计算披查找元素的内存地址，每一次查找部是从头节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率较低

Java代码模拟单向链表

public class Link {

    //头节点
    Node header;
    int size=0;

    public int size(){
        return size;
    }

    //向链表中添加元素的方法
    public void add(Object data){
        //创建一个新的节点对象
        //让之前单链表的末尾节点next指向新节点对象
        //有可能这个元素是第一个，也可能是第二个，也可能是第三个
        if(header==null){
            //说明还没有节点
            //new一个新的节点对象作为头节点对象，此时又是一个末尾节点
            header=new Node(data, null);
        }else{
            //说明头不是空！头节点已经存在
            //找出当前末尾节点，让当前末尾节点的next是新节点
            Node currentLastNode=findLast(header);
            currentLastNode.next = new Node(data, null);
        }
        size++;
    }

    //专门查找末尾节点的方法
    private Node findLast(Node node) {
        if(node.next==null){
            return node;
        }
        //递归
        return findLast(node.next);
    }

    //删除链表中某个数据的方法
    public void remove(Object obj){

    }

    //修改链表中某个数据的方法
    public void modify(Object newObj){

    }

    //查找链表中某个元素的方法
    public int find(Object obj){
        return 1;
    }
}

public class Node {

    //存储的数据
    Object data;

    //下一个节点的内存地址
    Node next;

    public Node() {
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }
}

双向链表

不管是 LinkedList 还是 ArrayList ，以后写代码时不需要关心具体是哪个集合。因为我们要面向接口编程，调用的方法都是接口中的方法。

public class LinkedListTest01 {
    public static void main(String[] args) {

        List list = new LinkedList();
        list.add("a");
        list.add("a");
        list.add("a");

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

Vector

初始化容量及扩容

底层也是一个数组。
初始化容量∶10
扩容之后是原容量的2倍
Vector中所有的方法都是线程同步的，都带有synchronized 关罐字，是线程安全的。效率比较低，使用较少

线程安全转换

怎么将一个线程不安全的 ArrayList 集合转换成线程安全的呢?使历集合工具类∶java.util.Col lections;

java.util.Collection 是集合接口
java.util.Collections 是集合工具类。

public class VectorTest {
    public static void main(String[] args) {

        List vector = new Vector();

        //默认容量10
        for(int i=1;i<=10;i++){
            vector.add(i);
        }

        //满了扩容
        vector.add(11);

        //非线程安全的
        List mylist = new ArrayList();
        //变成线程安全的
        Collections.synchronizedList(mylist);

        mylist.add("111");
        mylist.add("222");
        mylist.add("333");

    }
}

泛型机制

起作用阶段

泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的（运行阶段没用）如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

public class GenericTest01 {

    public static void main(String[] args) {

        //不使用泛型机制，分析程序存在缺点
        List mylist = new ArrayList();

        Cat cat=new Cat();
        Bird bird=new Bird();

        mylist.add(cat);
        mylist.add(bird);

        //遍历集合，取出cat,让它抓老鼠，取出Brid，让它飞！
        Iterator it = mylist.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            if(obj instanceof Cat){
                Cat cat2=(Cat)obj;
                cat2.catchMouse();
            }else{
                Bird bird2=(Bird) obj;
                bird2.fly();
            }
        }

        //接下来使用泛型机制
        List<Cat> mylist2=new ArrayList<Cat>();

        //只能存放Cat类型
        mylist2.add(cat);

        //这个表示的是迭代器迭代的是Cat类型
        Iterator<Cat>it2=mylist2.iterator();
        while(it2.hasNext()){
            //使用泛型以后，每一次迭代返回的数据都是Cat类型,不需要再强转了
            Cat c=it2.next();
            c.catchMouse();
        }

    }
}

class Animal{

}

class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}

class Bird extends Animal{
    public void fly(){
        System.out.println("鸟儿在飞翔！");
    }
}

优点与缺点

优点：集合中存储的元素类型统一了，从集合中取出的元素类型是泛型指定的类型，不需要进行大量的"向下转型"!
缺点：导致集合中存循的元素献乏多样性!但大多数业务中，集合中元素的类塑还是统一的。所以这种泛塑特性极大家所认可

自动类型推断机制

该机制又称为钻石表达式（JDK8以后才允许的）

public class GenericTest02 {
    public static void main(String[] args) {

        //new ArrayList<这里类型会自动推断>
        List<Animal> mylist = new ArrayList<>();

        mylist.add(new Animal());
        mylist.add(new Cat());
        mylist.add(new Bird());

        //遍历
        Iterator<Animal> it = mylist.iterator();
        while (it.hasNext()){
            Animal a = it.next();
            a.move();
        }

    }
}

自定义泛型

java源代码中经常出现的是∶<E>和<T> E是Element单词首字母，T是Type单词首字母

public class GenericTest03 <orangeCat>{

    public void doSome(orangeCat o){

    }

    public static void main(String[] args) {

        //new对象时指定了泛型是：String类型
        GenericTest03<String> gt=new GenericTest03<>();

        //类型不匹配
        //gt.doSome(100);
        gt.doSome("abc");

    }
}
class MyIterator<T>{
    public T get(){
        return null;
    }
}

foreach遍历

public class ForEachTest01 {
    public static void main(String[] args) {

        //int类型数据
        int[] arr={1,2,3,4,5};

        //遍历数组(普通for循环)
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        //增强for(foreach)
        /*for(元素类型 变量名 ：数组或集合){
            System.out.println(变量名);
        }*/

        //foreach有一个缺点，没有下标
        for(int data:arr){
            System.out.println(data);
        }
    }
}

Set

HashSet

无序不可重复

public class HashSetTest {
    public static void main(String[] args) {

        Set<String> strs=new HashSet<>();

        strs.add("hello1");
        strs.add("hello1");
        strs.add("hello2");
        strs.add("hello2");
        strs.add("hello3");
        strs.add("hello4");

        //遍历
        for(String s:strs){
            System.out.println(s);
        }
    }
}

TreeSet

TreeSet 集合中的元素∶无序不可重复，但是可以按照元素的大小顺序自动排序。称为∶可序集合。
TreeSet 集合底层实际上是一个TreeMap，放到 TreeSet 集合中的元素，等同于放到TreeMap集合key部分了，TreeMap 集合底层是一个二叉树。
对自定义类型进行排序需要继承 Compare<>接口，并重写 compareTo（String和Interger已做到这两点）

compareTo 为什么返回正负数就能排序？跟二叉树数据结构有关

返回值>0,会继续在右子树上找
返回值<0,会继续在左子树上找
等于的时候value会覆盖

对自定义的类型来说，TreeSet 可以排序吗 ?以下程序中对于Person类型(没实现java.Lang.Comparable接口)来说，无法排序。因为没有指定Person对象之间的比较规则。谁大谁小并没有说明。

以下程序运行的时候出现了这个异常∶java.Lang.ClassCastException:class com.bjpowernode.javase.collection.Person cannot be cast to class java.lang.Comparable

public class TreeSetTest01 {

    public static void main(String[] args) {

        Person p1 = new Person(11);
        Person p2 = new Person(15);
        Person p3 = new Person(14);
        Person p4 = new Person(13);

        TreeSet<Person> persons = new TreeSet<>();

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);

        for (Person p: persons ) {
            System.out.println(p);
        }

    }
}

//放在TreeSet集合中的元素需要实现java.lang.Comparable接口
//并且实现compareTo方法，equals可以不写
class Person implements Comparable<Person>{
    int age;

    public Person(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person[age="+age+"]";
    }

    //需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较！
    //k.compareTo(t.key)
    //拿着参数k和和集合中的每一个k进行比较，返回值可能是>0  <0  =0
    //比较规则由程序员编写，按年龄升序或者降序
    @Override
    public int compareTo(Person o) {//c1.compareTo(c2);
        //this是c1,c是c2
       /* int age1=this.age;
        int age2 = o.age;
        if(age1==age2){
            return 0;
        }else if(age1>age2){
            return 1;
        }else{
            return -1; 
        }*/

        return this.age-o.age;
    }
}

public class TreeSetTest02 {
    public static void main(String[] args) {

        String s1=new String("zhangsan");
        String s2=new String("lisi");
        String s3=new String("zhaoliu");
        String s4=new String("wangwu");

        Set<String> treeSet01 = new TreeSet<>();

        treeSet01.add(s1);
        treeSet01.add(s2);
        treeSet01.add(s3);
        treeSet01.add(s4);

        for(String s:treeSet01){
            System.out.println(s);
        }

        Integer i1=new Integer(5);
        Integer i2=new Integer(8);
        Integer i3=new Integer(11);
        Integer i4=new Integer(13);

        Set<Integer> treeSet02 = new TreeSet<>();

        treeSet02.add(i1);
        treeSet02.add(i2);
        treeSet02.add(i3);
        treeSet02.add(i4);

        for(Integer i:treeSet02){
            System.out.println(i);
        }

    }
}

//先按照年龄升序，年龄一样再按照姓名进行排序
public class TreeSetTest03 {

    public static void main(String[] args) {

        TreeSet<Vip> vips = new TreeSet<>();
        vips.add(new Vip("zhangsan", 20));
        vips.add(new Vip("lisi", 19));
        vips.add(new Vip("zhaoliu", 20));
        vips.add(new Vip("wangwu", 18));

        for(Vip v:vips){
            System.out.println(v);
        }

    }

}

class Vip implements Comparable<Vip>{

    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Vip[name:"+name+"   age:"+age+"]";
    }

    @Override
    public int compareTo(Vip vip) {

        if(this.age== vip.age){
            //String类型的compareTo已重写
            return this.name.compareTo(vip.name);

        }else{
            return this.age- vip.age;
        }
    }
}

Map

特点

Map和Collection没有继承关系。
Map集合以key和value的方式存储数据∶键值对
key和Value 都是引用数据类型， key和Value 部是存储对象的内存地址，key起到主导的地位.value是key的—个附属品

常用方法

void clear()   //清空Map集合
boolean containsKey(Object key) //判断Map中是否包含某个key
boolean containsValue(Object value) //判断Map中是否包含某个value
V get(Object key) //通过key获得value  
boolean isEmpty() //判断Map集合中元素个数是否为0
Set<K>keySet() //获取Map集合所有的key，HashSet底层是HashMap的key值
V put(K key,V value) //向Map集合中添加键值对
V remove(Object key) //通过key删除键值对
int size()   //获取Map集合中键值对的个数
Collection<V> values() //获取Map集合中所有的value，返回一个Collection
Set<Nap.Entry<K,V>> entrySet()    //将Map集合转换成Set集合

public class MapTest01 {

    public static void main(String[] args) {

        //创建Map集合对象
        Map<Integer, String> map = new HashMap<>();
        //向Map集合中添加键值对
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
        //通过key获取value
        String value = map.get(2);
        System.out.println(value);
        //获取键值对数量
        System.out.println("键值对数量："+map.size());
        //通过key删除key-value
        map.remove(2);
        System.out.println("键值对数量："+map.size());

        //contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法
        System.out.println(map.containsKey(4));
        System.out.println(map.containsValue(new String("wangwu")));

        Collection<String> values= map.values();
        for(String s: values){
            System.out.println(s);
        }

        map.clear();
        System.out.println("键值对数量："+map.size());
        System.out.println(map.isEmpty());

    }
}

Set<Nap.Entry<K,V>> entrySet()

注意∶Map集合通过entrySet（）方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K，V>

Map.Entry和String一样，都是一种类型的名字，只不过∶Map.Entry是静态内部类，是Map中的静态内部类

public class MyClass {

    //声明一个静态内部类
    private static class InnerClass{

        //静态方法
        public static void m1(){
            System.out.println("静态内部类的静态方法执行");
        }
        //实例方法
        public void m2(){
            System.out.println("静态内部类的实例方法执行");
        }

    }

    public static void main(String[] args){

        MyClass.InnerClass.m1();

        //创建静态内部类对象
        MyClass.InnerClass mi=new MyClass.InnerClass();
        mi.m2();

        //该Set集合中存储的对象是：MyClass.InnerClass类型
        Set<MyClass.InnerClass> set = new HashSet<>();

        Set<MyMap.MyEntry<Integer, String>> set3 = new HashSet<>();
        
    }
}

class MyMap{
    public static class MyEntry<K,V>{
        
    }
}

Map集合的遍历

通过key获取value
转换成set集合，这种方式效率比较高，因为获取key积value 都是直接从node对象中获取的属性值。这种方式比较适合于大数据量。

public class MapTest02 {

    public static void main(String[] args) {
        //第一种方式：获取所有的key,通过遍历key,来遍历value
        Map<Integer, String> map = new HashMap<>();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");

        //遍历Map集合
        //获取所有的key,所有的key是一个Set集合
        Set<Integer> keys=map.keySet();
        //遍历key 1.迭代器 2.foreach
        Iterator<Integer> it=keys.iterator();
        while (it.hasNext()){
            Integer key= it.next();
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

        for(Integer key: keys){
            System.out.println(key+"="+map.get(key));
        }

        //第二种方式：Set<Map.Entry<K,V>>entrySet()
        //把Map集合直接全部转换成Set集合
        Set<Map.Entry<Integer,String>> set=map.entrySet();
        //遍历Set集合，每一次取出一个Node
        Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
        while (it2.hasNext()){
            Map.Entry<Integer,String> node=it2.next();
            Integer key= node.getKey();
            String value= node.getValue();
            System.out.println(key+"="+map.get(key));
        }
        //foreach
        for(Map.Entry<Integer,String> node:set){
            System.out.println(node.getKey()+"--->"+ node.getValue());
        }
        
   }
}

HashMap

哈希表数据结构

HashMap 集合底层是哈希表/ 散列表的数据结构
哈希表是一个怎样的数据结构呢？哈希表是一个数组和单向链表的结合体。数组∶在查询方面效率很高，随机增删方面效率很低。单向链表∶ 在随机增删方面效率较高，在查询方面效率很低。哈希表浮以上的两种数据结构融合在一起，充分发挥它们各自的优点。
HashMap集合底层的源代码∶


public class HashMap{
// HashNap底层实际上就是一个数组（一维数组） 
transient Node<K,V>[] table;

// 静态的内部类
static class Node<K, V>{

// 哈希值(哈希值是key的hashCode（）方法的执行结果：hash值通过哈希函数/算法,可以转化存储成数组的下标)
    final int hash;
    final K key;    // 存储到Map集合中的那个key
    V value;     // 存储到Map集合中的那个value
    Node<K,V>next;     // 下一个节点的内存地址
}

拉链法工作原理

参考Github Java教程

HashMap<String, String> map = new HashMap<>();
map.put("K1", "V1");
map.put("K2", "V2");
map.put("K3", "V3");

新建⼀个 HashMap，默认⼤⼩为 16；
插⼊ <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使⽤除留余数法得到所在的桶下标 115%16=3
插⼊ <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使⽤除留余数法得到所在的桶下标 118%16=6
插⼊ <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使⽤除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前⾯

应该注意到链表的插⼊是以头插法⽅式进⾏的（JDK1.8之前是头插法，之后是尾插法，这里用了JDK1.7作为示例了），例如上⾯的 <K3,V3> 不是插在 <K2,V2> 后⾯，⽽是插⼊在链表头部，查找需要分成两步进⾏：

计算键值对所在的桶；
在链表上顺序查找，时间复杂度显然和链表的⻓度成正⽐

存和取

上图中说明的一些验证：

import java.util.HashMap;
import java.util.Map;

public class Test01 {
    public static void main(String[] args) {

        Map<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1,"cat");
        hashMap.put(1,"tiger");
        System.out.println(hashMap.size()); //1
        System.out.println(hashMap.get(1)); //tiger
    }
}

特点

HashMap集合的key部分特点∶无序，不可重复。

为什么无序? 因为不一定挂到哪个单向链表上。
不可重复是怎么保证的? equals方法来保证HashMap集合的key不可重复。如果key重复了，value 会覆盖。
放在HashMap.集合key部分的元素其实就是放到HashSet集合中了。所以HashSet集合中的元素也需要同时重与 hashCode() + equals() 方法
HashMap集合的默认初始化容量是16 ，默认加载因子是0.75,这个默认加载因子是当HashMap.集合底层数组的容量达到75%的时候，数组开始扩容。重点，记住∶ HashMap集合初始化容量必级是2 的倍数，这也是官方规定的，这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。
在JDK8之后，如果哈希表单向链表中元素超过8个，单向链表这种数据结构会变成红黑树数据结构。当红黑树上后节点数量小于 6时，会重新把红黑树变成单向链表数据结构。这种方式也是为了提高检索效率，二叉树的检索会再次缩小扫描范围。提高效率。
允许key和value为null，但只能有一个，HashTable(哈希表结构)的key和value都不能为null，初始化容量为1，默认加载因子是：0.7，扩容*2+1

哈希表 HashMap 使用不当时无法发挥性能！假设疫所有的 hashCode() 方法返回值固定为某个值，那么会导致底层哈希表变成了纯单向链表。这种情况我们成为∶散列分布不均匀，什么是散列分布均匀？假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的，是散列/分布均匀的。假设将所有的 hashCode() 方法返回值部设定为不一样的值，有什么问题？不行，因为这样的话导致底层哈希表就成为一维数组了，没有链表的概念了，也是散列分布不均匀。散列分布均匀需要你重写 hashCode() 方法时有一定的技巧。

public class HashMapTest01 {

    public static void main(String[] args) {
        //测试HashMap集合key部分的元素特点
        //Integer是key,它的hashCode和equals都重写了
        Map<Integer, String> map = new HashMap<>();
        map.put(1111,"zhangsan");
        map.put(2222,"lisi");
        map.put(3333,"wangwu");
        map.put(4444,"zhaoliu");
        map.put(4444, "king"); //key重复时value会覆盖

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

        //遍历Map集合
        Set<Map.Entry<Integer,String>> set=map.entrySet();

        for(Map.Entry<Integer,String> node:set){
            //HashMap的key部分元素：无序不可重复
            System.out.println(node.getKey()+"--->"+ node.getValue());
        }

    }
}

向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！equals方法有可能调用，也有可能不调用。

拿 put(k,v) 举例，什么时候equals不会调用? k.hashCode() 方法返回哈希值，哈希值经过哈希算法转换成数组下标。数组下标位置上如果是null，equals 不需要执行。

拿 get(k) 举例，什么时候equals不会调用? k.hashCode() 方法返回哈希值，哈希值经过哈希算法转换成数组下标。数组下标位置上如果是null，equals 不需要执行。

注意∶ 加果一个类的equals方法重写了，那么 hashCode() 方法必须重写。并且equals方法返回如果是true ，hashCode() 方法返回的值必须一样。equals方法返回true表示两个对象相同，在同一个单向链表上比较。那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的。所以 hashCode() 方法的返回值也应该相同。

public class Student {

    private String name;

    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /*@Override
    public boolean equals(Object obj) {
        if (obj==null||!(obj instanceof Student)) return false;
        if (obj==this) return true;
        Student s=(Student) obj;
        return this.name.equals(s.name);}
        */

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

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

hashCode() 方法和 equals() 方法不用研究了，直接使用IDEA工具生成，但是这两个方法需要同时生成。

public class HashMapTest02 {

    public static void main(String[] args) {

        Student s1=new Student("zhangsan");
        Student s2=new Student("zhangsan");

        //没重写equals是false
        System.out.println(s1.equals(s2));

        System.out.println("s1的hashCode="+s1.hashCode());//2129789493没重写hashCode时
        System.out.println("s2的hashCode="+s2.hashCode());//495053715

        //s1.equals（s2）结果已经是true了，表示s1和s2是一样的，相同的
        // 那么往HashSet集合中放的话，按说只能放进去1个。（ HashSet集合特点∶无序不可重复）
        Set<Student> students = new HashSet<>();
        students.add(s1);
        students.add(s2);
        System.out.println(students.size());

    }
    
}

public class HashMapTest03 {
    public static void main(String[] args) {

        Map map = new HashMap();

        map.put(null,null);
        System.out.println(map.size());

        map.put(null, 100);
        System.out.println(map.size());

        System.out.println(map.get(null));

    }
}

Properties

特点

Properties 是一个Map 集合，继承 Hashtable
Properties 的 key 和 value 都是 String 类型
Properties 披称为属性类对象，是线程安全的

常用方法

public class PropertiesTest01 {

    public static void main(String[] args) {

        Properties properties = new Properties();

        properties.setProperty("ur1", "jdbc:mysql://localhost:3306/bjpowernode");
        properties.setProperty("driver", "com.mysql.jdbc.Driver");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123");

        //通过key，获取value
        String s1 = properties.getProperty("ur1");
        String s2 = properties.getProperty("driver");
        String s3 = properties.getProperty("username");
        String s4 = properties.getProperty("password");

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

    }

}