11.Java-集合_java 11 集合-CSDN博客

本文链接：https://blog.csdn.net/qq_29294165/article/details/120703748

一、算法

1. 算法说明：

【1】可以解决具体问题
【2】有设计结局的具体流程
【3】有评价这个算法的具体指标

二、数据结构

逻辑结果、物理结构
在计算机的缓存，内存，硬盘如何组织管理数据的。重点在结构上，是按照什么结构来组织管理我们的数据。

1. 逻辑结构

线性表（数组，链表），图，数，栈，队列

2. 物理结构

紧密结构（顺序结构），跳转结构（链式结构）
紧密结构，对应的真实结构如果是紧密结构–>典型就是：数组
数组结构：
优点：查询快
确定：插入慢
在这里插入图片描述
线性表逻辑结构，对应的真实结构如果是跳转结构->典型就是：链表
优点：删除元素，插入元素效率高
缺点：查询元素效率低

三、集合

【1】数组，集合都是对多个数据进行存储操作
ps:这里的存储指的是内存层面的存储，而不是持久化存储（.txt,avi,jpg,数据库）
【2】数组：特点：
（1）数组一旦指定了长度，那么长度就被确定了，不可以更改int[] arr = new int[6];
（2）数组一旦声明了类型以后，数组中只能存放这个类型的数据。数组中只能存放统一类型的数据 int[],arr,String[],s,double[]
【3】数组：缺点：
（1）数组一旦制定了长度，那么长度就被确定了，不可以更改。
（2）删除，增加元素，效率低
（3）数组中实际元素的数量是没有办法获取的，没有提供对应的方法或者属性获取
（4）数组存储：有序，可重复，对于无序的，不可重复的数组不能满足要求
【4】正因为上面的缺点，引入了一个新的存储数据结构—>集合
【5】集合一章我们会学习很多集合，为什么要学习这么多集合呢？
因为不同集合底层数据结构不一样。集合不一样，特点也不一样

1. Conllection

1.Conllection常用方法

package com.fj.aggregate.collection;

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

public class Demo01 {
    public static void main(String[] args) {
        /*
         Collection 接口常用方法：
         增加：add(E e) addAll(Collection<? extends E> c)
         修改：
         查看：iterator() size()
         删除：clear() remove()
         判断：contains(object o) equals(object o) isEmpty()
         */
        //创建对象：接口不能创建对象，类型实现类创建对象
        Collection col = new ArrayList();
        //调用方法
        //集合有一个特点，只能存放引用数据类型，不能是基本数据类型
        //基本数据类型自动装箱，对应包装类。 int---->Integer
        col.add(18);
        col.add(44);
        col.add(45);
        col.add(98);
        System.out.println(col);
        List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1});
        col.addAll(list);
        System.out.println(col);
        //col.clear();
        System.out.println(col);
        System.out.println("集合中的元素数量为："+col.size());
        System.out.println("集合中的元素是否为空："+col.isEmpty());
        boolean isRemove = col.remove(15);
        System.out.println(col);
        System.out.println("集合中数据是否被删除："+isRemove);

        Collection col2 = new ArrayList();
        col2.add(18);
        col2.add(44);
        col2.add(45);

        Collection col3 = new ArrayList();
        col3.add(18);
        col3.add(44);
        col3.add(45);
        System.out.println(col2.equals(col3));
        System.out.println(col2==col3);//地址一定不相等false
        System.out.println(col3.contains(45));


    }
}

2. Conllection集合的遍历

package com.fj.aggregate.collection;

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

public class Demo02 {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(45);
        //方式1：普通for循环 失败
       /* for (int i=0;i<col.size();i++){
            System.out.println(col.);
        }*/
        //方式2：增强for循环
        for(Object o:col){
            System.out.println(o);
        }
        System.out.println("====================");
        //方式3：
        Iterator it = col.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

1.List

List继承Conllection，List扩展方法都和索引有关，所以可以进行普通遍历。

1. List接口常用方法和遍历方式

package com.fj.aggregate.list;

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

public class Demo01 {
    public static void main(String[] args) {
        /**
         * List 接口
         * 增加 add(int index ,E element)
         * 删除 remove(int index) remove(Object o)
         * 修改 set(int index,E element)
         * 查看 get(int index)
         */
        List list = new ArrayList();
        list.add(11);
        list.add(54);
        list.add(36);
        list.add(87);
        list.add(15);
        list.add("abc");
        System.out.println(list);//[11, 54, 36, 87, 15, abc]
        //在下标为3的地方添加数据
        list.add(3, 55);//在下标为3的位置添加55
        System.out.println(list);//[11, 54, 36, 55, 87, 15, abc]
        //set(int index,E element)修改下标为3的位置数据为66
        list.set(3, 66);
        System.out.println(list);//[11, 54, 36, 66, 87, 15, abc]
        //在集合中存入的是Integer类型的数据，调用remove方法调用的是 remove(int index)删除下标为2的位置的数据
        list.remove(2);
        System.out.println(list);//[11, 54, 66, 87, 15, abc]
        //在集合中存入的不是Integer类型的数据，调用remove方法调用的是remove(Object o)删除传入的数据
        list.remove("abc");
        System.out.println(list);//[11, 54, 66, 87, 15]
        //获取下标为0的数据
        Object o = list.get(0);
        System.out.println(o);//11
        //List 集合遍历
        //方式1：普通for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));//
        }
        System.out.println("=============方式1：普通for结束============");
        //方式2：增强for
        for (Object obj : list) {
            System.out.println(obj);
        }
        System.out.println("=============方式1：增强for结束============");
        //方式3：迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("=============方式1：迭代器结束============");

    }
}

2. arrayList

package com.fj.aggregate.list;

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

public class Demo02 {
    public static void main(String[] args) {
        /**
         * arrayList
         */
        //接口 = 实现类
        Collection col = new ArrayList();
        List list = new ArrayList();
        //直接创建实现类对象
        ArrayList al = new ArrayList();
        System.out.println(al.add(111));
        System.out.println(al.add("ddd"));

    }
}

在这里插入图片描述

3. Vector实现类

        Vector v = new Vector();
        v.add("abc");

在这里插入图片描述

4. 泛型

1. 泛型说明

【1】不适用泛型缺点：
什么引用数据类型都可以存入集合，不方便管理
【2】没使用泛型代码

package com.fj.aggregate.generic;

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 泛型
         */
        //创建一个arraylist 集合，想这个集合存入学生成绩
        ArrayList al = new ArrayList();
        al.add(23);
        al.add(54);
        al.add(98);
        al.add(78);
        al.add(14);
        al.add("lll");
        for (Object o:al){
            System.out.println(o);
        }
    }
}

【3】使用泛型代码

package com.fj.aggregate.generic;

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 泛型
         *优点：在编译的时候就会对类型进行检查，不是泛型对应的类型就不可以添加这个集合
         */
        //创建一个arraylist 集合，想这个集合存入学生成绩
        ArrayList<Integer> al = new ArrayList<Integer>();
        al.add(23);
        al.add(54);
        al.add(98);
        al.add(78);
        al.add(14);
        /*al.add("lll");*/
        for (Object o:al){
            System.out.println(o);
        }
    }
}

【4】泛型总结
JDK1.5以后引入
泛型实际就是一个<>引起来的参数类型，这个参数类型具体在使用的时候才会确定具体类型
使用泛型以后，可以确定集合中存放数据的类型，在编译时期就可以检查出来
泛型类型：引用类型，不能是基本数据类型
ArrayList<Integer> al = new ArrayList<Integer>();//JDK1.7之前 ArrayList<Integer> al2 = new ArrayList<>();//砖石运算符 JDK1.7之后
2. 泛型结构自定义
- 【1】泛型雷达定义和实例化

package com.fj.aggregate.generic;

/**
 * Demo02 就是一个普通的类
 * Demo02<A> 就是一个泛型类
 * <>里面就是一个参数类型，但是这个类型现在是不确定的，相当于一个占位
 * 但是现在确定的是这个类型是一个引用类型，而不是基础类型
 */
public class Demo02<E> {
    int age;
    String name;
    E sex;

    public void a(E n) {

    }

    public void b(E[] n) {

    }
}

class Test {
    public static void main(String[] args) {
        //Demo02进行实例化
        //(1)实例化的时候不指定泛型.如果实例化的时候不明确的指定类的泛型，那么认为此泛型为object
        Demo02 d2 = new Demo02();
        d2.a("sss");
        d2.a(17);
        d2.a(9.8);
        d2.b(new String[]{"A", "B", "C"});
        //(2)实例化的时候指定泛型
        Demo02<String> d3 = new Demo02<>();
        d3.a("d");
        d3.a("ff");
        d3.sex = "男";
        

    }
}

【2】父类指定泛型

//继承后子类指定类型
class SubDemo02 extends Demo02<Integer>{

}

class Test1{
    public static void main(String[] args) {
        //指定父类泛型，那么子类就不需要在指定泛型了，可以直接使用
        SubDemo02 sd = new SubDemo02();
        sd.a(1);
    }
}

【3】父类不指定泛型
如果父类不指定泛型，那么子类也会变成一个泛型类，那么这个E的类型可以在创建子类的时候确定

//继承后子类不指定类型
class SubDemo03<E> extends Demo02<E>{

}
class Test2{
    public static void main(String[] args) {
        //指定父类泛型，那么子类就不需要在指定泛型了，可以直接使用
        SubDemo03<Integer> sd3 = new SubDemo03<>();
        sd3.a(1);
    }
}

【4】泛型可以定义多个参数类型

（1）.泛型类多个参数类型正确写法

package com.fj.aggregate.generic;

public class Demo03<A,B,C> {
    A age;
    B name;
    C sex;
    public void a(A m,B n,C x){
        
    }
}

（2）.泛型类的错误写法
（3）不同的泛型类型的引用类型不可以相互赋值
（4）泛型如果不指定，就会被擦除，泛型对象的类型位Object类型
（5）泛型类中的静态方法不能使用类的泛型
（6）不能直接使用E[]的创建
【5】泛型方法

package com.fj.aggregate.generic;

/**
 *
 * @param <E>
 * 1. 什么是泛型方法？
 * 不是带泛型的方法就是泛型方法
 * 泛型方法有要求，这个方法的泛型的参数类似要和当前的类的泛型无关
 * 换个角度
 * 泛型方法对象的泛型参数类型和 当前所在的这个类是否是泛型类，是无关的
 * 2.泛型方法定义，前面要加上<T>
 *     原因：如果不加的话，会把T当做一种数据类型，然而代码中没有这个类型
 *3. T的类型是在调用方法的时候确定的
 * 4. 泛型方法可否是静态方法？可以是
 *
 */
public class Demo04<E> {

    //不是泛型方法(不能是静态方法)
    public void a(E e){

    }
    //是泛型方法
    public static <T>  void b(T t){

    }

}
class Demo{
    public static void main(String[] args) {
        Demo04 d4 = new Demo04();
        d4.a("dd");
        d4.a("abc");
        d4.a(123);
        d4.b("ddd");
        d4.b(true);
    }
}

【6】泛型参数有继承关系，但是泛型不存在，是并列关系

package com.fj.aggregate.generic;

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

public class Demo05 {
    public static void main(String[] args) {
        Object obj = new Object();
        String s = new String();
        obj = s;//多态的一种形式 

        Object[] objArr = new Object[10];
        String[] strArr = new String[10];
        objArr = strArr;//多态的一种形式


        List<Object> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
        //list = list1;报错
        //总结 a 和 b 是子类父类的关系，但是G<a> 和G<b>不存在继承关系，是并列的
    }
}

【7】泛型通配符
在没有通配符的时候，下面的a方法，相当于方法的重新定义，报错

package com.fj.aggregate.generic;

import java.util.List;

public class Demo06 {
    public void a(List<Object> list) {

    }
    public void a(List<String> list) {

    }
    public void a(List<Integer> list) {

    }
}

引入通配符发现：

package com.fj.aggregate.generic;

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

public class Test06 {
    public static void main(String[] args) {
        //A和B是子类父类的关系，G<A>和G<B>不存在子类父类关系，是并列的。加入通配符？后，G<?>就变成了G<A>和G<B>的父类
        List<Object> list1= new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();
        List<?> list = null;
        list = list1;
        list = list2;
        list = list3;
    }
}

使用通配符

package com.fj.aggregate.generic;

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

public class Demo06 {
  /*  public void a(List<Object> list) {

    }
    public void a(List<String> list) {

    }
    public void a(List<Integer> list) {

    }*/
    public void a(List<?> list){
        //内部遍历的时候用Object即可，不用？
        //1. 遍历
        for (Object obj:list){
            System.out.println(obj);
        }
        // 2. 数据写入操作
        //list.add("abc");//出错，不能随意的添加数据
        list.add(null);
        //3.数据的读取操作：
        Object obj = list.get(1);
    }
}
class T{
    public static void main(String[] args) {
        Demo06 d06 = new Demo06();
        d06.a(new ArrayList<Integer>());
        d06.a(new ArrayList<String>());
        d06.a(new ArrayList<Object>());

    }
}

【8】泛型受限

package com.fj.aggregate.generic;

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

public class Demo07 {
    public static void main(String[] args) {
        // a,b,c三个集合是并列关系
        List<Object> a = new ArrayList<>();
        List<Person> b = new ArrayList<>();
        List<Student> c = new ArrayList<>();
        //开始使用泛型受限
        /**
         * 开始使用泛型受限:泛型的上线
         * List<？ extends Person>:
         * 就相当于
         * List<? extends Person> 是List<Person>的父类，是List<Person的子类>的父类
         */
        //person及person的子类
        List<? extends Person> list1 = null;
        //list1 =a;//报错
        list1 =b;
        list1 =c;
        /**
         * 泛型的下限
         * List<? super Person>
         * 相当于
         * List<? super Person> 是List<Person> 的父类，是List<Person的父类> 的父类
         */
        //Person 及person的父类
        List<? super Person> list2 = null;
        list2 = a;
        list2 = b;
        //list2 = c;//报错
    }
}

LinkedList

1.linkedList常用方法

package com.fj.aggregate.linkedlist;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Demo01 {
    public static void main(String[] args) {
        /*
        linkedList 常用方法
        增加 addFirst(E e)  addLast(E e)
        删除 poll pollFirst() pollLast() removeFirst() removeLast()
        修改
        查找 element()  getFirst()  getLast() indexOf(Object o)  lastIndexOf(Object o)
        判断
         */
        //创建linkedList的集合
        LinkedList<String> list = new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        list.add("b");
        System.out.println(list);//可以添加重复数据
        list.addFirst("aa");//添加数据在头部
        list.addLast("bb");//添加数据在尾端
        list.offer("ff");//添加数据在尾端
        list.offerLast("pp");//添加数据在尾端
        list.addFirst("rr");//添加数据在头部
        System.out.println(list.poll());//弹出头部数据,并将元素输出
        System.out.println(list.pollFirst());//弹出头部数据,并将元素输出
        System.out.println(list.pollLast());//弹出尾部数据,并将元素输出
        System.out.println(list.removeFirst());//移除头部数据
        System.out.println(list.removeLast());//移除尾部数据
       /* list.clear();
        System.out.println(list);//可以添加重复数据
        System.out.println(list.pollFirst());
        System.out.println(list.removeFirst());//报错*/
        System.out.println("=====================================");
        //集合的遍历
        //普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("===============普通for循环结束======================");
        //增强for循环
        for (String s : list) {
            System.out.println(s);

        }
        System.out.println("===============增强for循环结束======================");
        //迭代器
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());;
        }
        System.out.println("===============迭代器循环结束======================");
        //迭代器2
         for (Iterator<String> it1 = list.iterator(); it1.hasNext();){
             System.out.println(it1.next());
         }
        System.out.println("===============迭代器2循环结束======================");
    }
}

2. iterator(),iterator,iterable的具体实现

在这里插入图片描述

3. ListIterator迭代器

【1】加入字符串代码，发现报错，并发修改异常

package com.fj.aggregate.linkedlist;

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

public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");
        //在cc添加一个字符串kk
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            if("cc".equals(it.next())){
                list.add("kk");
            }
        }
    }
}

结果：出错原因：就是迭代器和list同时对集合进行操作。

Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967)
	at com.fj.aggregate.linkedlist.Demo03.main(Demo03.java:17)

Process finished with exit code 1

解决办法：引入新的迭代器ListIterator

package com.fj.aggregate.linkedlist;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");
        //在cc添加一个字符串kk
        ListIterator<String> it = list.listIterator();
        while (it.hasNext()){
            if("cc".equals(it.next())){
                it.add("kk");
            }
        }
        System.out.println(list);
        System.out.println("==========listIterator遍历结束============");
        System.out.println(it.hasNext());
        System.out.println(it.hasPrevious());
        //逆向遍历
        while (it.hasPrevious()){
            System.out.println(it.previous());
        }
        System.out.println("==========逆向遍历结束============");
    }
}

2.Set

list：不唯一，有序
set：唯一，无序，无序不等于随机，没有和索引相关的方法，不能用普通for循环
在这里插入图片描述

1. hashSet

【1】放入Integer数据
底层原理：数组+链表=哈希表
满足：唯一，无序

package com.fj.aggregate.set.hashSet;

import java.util.HashSet;

public class Demo01 {
    public static void main(String[] args) {
        HashSet<Integer> hs = new HashSet<>();
        hs.add(19);
        hs.add(5);
        hs.add(20);
        hs.add(41);
        hs.add(0);
        hs.add(5);
        System.out.println(hs);

    }

}

结果：

[0, 19, 20, 5, 41]

【2】放入字符串
满足：唯一，无序

package com.fj.aggregate.set.hashSet;

import java.util.HashSet;

public class Demo02 {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();
        hs.add("hello");
        hs.add("apple");
        hs.add("banana");
        hs.add("html");
        hs.add("apple");
        hs.add("css");

        System.out.println(hs);
    }
}

结果：

[banana, apple, css, html, hello]

Process finished with exit code

【3】放入自己定义类型没重写hashCode,equals
自定义类
不满足：唯一，无序
注意：如果放入HashSe中的数据，一定要重写两个方法：hashCode,equals

package com.fj.aggregate.set.hashSet;

public class Student {

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

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

自定义类调用,没重写hashCode,equals

package com.fj.aggregate.set.hashSet;

import java.util.HashSet;

public class TestStudent {
    public static void main(String[] args) {
        HashSet<Student> hs = new HashSet<>();
        hs.add(new Student(18,"aa"));
        hs.add(new Student(50,"bb"));
        hs.add(new Student(18,"aa"));
        hs.add(new Student(10,"dd"));
        hs.add(new Student(36,"ee"));
        hs.add(new Student(78,"ff"));
        System.out.println(hs.size());
        System.out.println(hs);
    }
}

自定义类结果不满足无序，唯一

6
[Student{age=36, name='ee'}, Student{age=78, name='ff'}, Student{age=10, name='dd'}, Student{age=18, name='aa'}, Student{age=18, name='aa'}, Student{age=50, name='bb'}]

Process finished with exit code 0

【4】放入自己定义类型重写hashCode,equals
自定义类代码

package com.fj.aggregate.set.hashSet;

import java.util.Objects;

public class Student {

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

    public Student(int age, String name) {
        this.age = age;
        this.name = 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 age == student.age && name.equals(student.name);
    }

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

自定义类调用

package com.fj.aggregate.set.hashSet;

import java.util.HashSet;

public class TestStudent {
    public static void main(String[] args) {
        HashSet<Student> hs = new HashSet<>();
        hs.add(new Student(18,"aa"));
        hs.add(new Student(50,"bb"));
        hs.add(new Student(18,"aa"));
        hs.add(new Student(10,"dd"));
        hs.add(new Student(36,"ee"));
        hs.add(new Student(78,"ff"));
        System.out.println(hs.size());
        System.out.println(hs);
    }
}

自定义类结果

5
[Student{age=78, name='ff'}, Student{age=10, name='dd'}, Student{age=36, name='ee'}, Student{age=18, name='aa'}, Student{age=50, name='bb'}]

2. Map

1. HashMap

在这里插入图片描述

【1】.常用方法
特点：无序，唯一

package com.fj.aggregate.map.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo01 {
    public static void main(String[] args) {
        /*
         * 增加 put(K key, V value)
         * 删除 clear()
         * 修改
         * 查找 entrySet() get(Object key) keySet()
         * 判断 containsKey(Object key) containsValue(Object value) equals(Object o) isEmpty()
         *特点：无序 唯一
         *
         */

        //创建一个map集合
        Map<String,Integer> map = new HashMap();
        System.out.println(map.put("lili",10101010));//null
        System.out.println(map.put("lili",235648952));//10101010
        map.put("mingming",10101010);
        map.put("mingming",12323);
        System.out.println(map);
        /*map.clear();//清空*/
        /*map.remove("feifei");//移除*/
        System.out.println(map.size());//4
        System.out.println(map);//{nana=1234566, feifie=234568779, lili=235648952, mingming=10101010}
        System.out.println(map.containsKey("lili"));//是否包含某个key
        System.out.println(map.containsValue(12323));//是否包含某个值
        Map<String,Integer> map2 = new HashMap();
        System.out.println(map2.put("lili",10101010));//null
        map2.put("nana",1234566);
        map2.put("feifei",234568779);
        System.out.println(map2.put("lili",235648952));//10101010
        map2.put("mingming",10101010);
        map2.put("mingming",12323);
        System.out.println(map == map2);//比较地址 false
        System.out.println(map.equals(map2));//true 进行重写，比较具体数据
        System.out.println(map.isEmpty());//判断是否为空
        System.out.println(map.get("nana"));//获取某个key值得数据
        System.out.println("==================keySet()对集合中的key进行遍历查看==========================");
        //keySet()对集合中的key进行遍历查看
        Set<String> set = map.keySet();
        for (String s:set){
            System.out.println(s);
        }
        System.out.println("====================values()对集合中的value进行查看========================");
        //values()对集合中的value进行查看
        Collection<Integer> val = map.values();
        for (Integer i:val){
            System.out.println(i);
        }
        System.out.println("====================get(Object key) keySet========================");
        //get(Object key) keySet 获取值
        Set<String> set1 = map.keySet();
        for (String s:set){
            System.out.println(map.get(s));
        }
        System.out.println("================Map.Entry<String, Integer>==========================");
        //
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> e:entries){
            System.out.println(e.getKey()+"===="+e.getValue());
        }
    }
}

运行结果

null
10101010
{lili=235648952, mingming=12323}
2
{lili=235648952, mingming=12323}
true
true
null
10101010
false
false
false
null
==================keySet()对集合中的key进行遍历查看==========================
lili
mingming
====================values()对集合中的value进行查看========================
235648952
12323
====================get(Object key) keySet========================
235648952
12323
================Map.Entry<String, Integer>==========================
lili====235648952
mingming====12323

Process finished with exit code 0

2. TreeMap

【1】常用方法和HashMap一样
特点：有序，升序
代码

package com.fj.aggregate.map.map;

import java.util.TreeMap;

public class Demo02 {

    public static void main(String[] args) {
        //TreeMap 有序升序排列
        TreeMap<String, Integer> tm = new TreeMap<>();
        tm.put("lili",111);
        tm.put("alili",222);
        tm.put("blili",333);
        tm.put("clili",444);
        tm.put("alili",555);
        tm.put("dlili",666);
        System.out.println(tm.size());
        System.out.println(tm);
    }

结果

5
{alili=555, blili=333, clili=444, dlili=666, lili=111}

Process finished with exit code 0

【2】内部比较器
比较器代码

package com.fj.aggregate.map.map;

public class Student implements Comparable<Student>{
    private int age;
    private String name;
    private Double height;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Double getHeight() {
        return height;
    }

    public void setHeight(Double height) {
        this.height = height;
    }

    public Student(int age, String name, Double height) {
        this.age = age;
        this.name = name;
        this.height = height;
    }

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

    @Override
    public int compareTo(Student o) {
       // return this.getAge()-o.getAge();
        return this.getName().compareTo(o.getName());
    }
}

内部比较器调用

package com.fj.aggregate.map.map;

import java.util.TreeMap;

public class Demo03 {
    public static void main(String[] args) {
        TreeMap<Student, Integer> tm = new TreeMap<>();
        tm.put(new Student(19,"blili",170.5),1001);
        tm.put(new Student(18,"blili",150.5),1001);
        tm.put(new Student(19,"alili",180.5),1001);
        tm.put(new Student(17,"clili",140.5),1001);
        tm.put(new Student(10,"dlili",160.5),1001);
        System.out.println(tm.size());
        System.out.println(tm);
    }
}

结果

4
{Student{age=19, name='alili', height=180.5}=1001, Student{age=19, name='blili', height=170.5}=1001, Student{age=17, name='clili', height=140.5}=1001, Student{age=10, name='dlili', height=160.5}=1001}

Process finished with exit code 0

【3】外部比较器
外部比较器类

package com.fj.aggregate.map.map;

import java.util.Comparator;

public class Student01 {
    private int age;
    private String name;
    private Double height;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Double getHeight() {
        return height;
    }

    public void setHeight(Double height) {
        this.height = height;
    }

    public Student01(int age, String name, Double height) {
        this.age = age;
        this.name = name;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student01{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", height=" + height +
                '}';
    }
}
class Test01 implements Comparator<Student01> {
    @Override
    public int compare(Student01 o1, Student01 o2) {
        return o1.getAge()-o2.getAge();
    }
}

外部比较类调用

package com.fj.aggregate.map.map;


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

public class Demo04 {
    public static void main(String[] args) {
        Comparator<Student01> test01 = new Test01();
        TreeMap<Student01, Integer> tm = new TreeMap<>(test01);
        tm.put(new Student01(19,"blili",170.5),1001);
        tm.put(new Student01(18,"blili",150.5),1001);
        tm.put(new Student01(19,"alili",180.5),1001);
        tm.put(new Student01(17,"clili",140.5),1001);
        tm.put(new Student01(10,"dlili",160.5),1001);
        System.out.println(tm.size());
        System.out.println(tm);
    }
}

结果

4
{Student01{age=10, name='dlili', height=160.5}=1001, Student01{age=17, name='clili', height=140.5}=1001, Student01{age=18, name='blili', height=150.5}=1001, Student01{age=19, name='blili', height=170.5}=1001}

Process finished with exit code 0