java笔记-3-集合

集合的理解和好处

数组

1. 长度开始时必须指定，而且一旦指定，不能更改
2. 保存的必须为同一类型的元素
3. 使用数组进行增加语速的示意代码-比较麻烦

集合

1. 可以动态保存任意多个对象，使用比较方便！
2. 提供了一系列方便的操作对象的方法：add、 remove、 set、 get等
3. 使用集合添加，删除新元素的示意代码-简洁了

集合的框架体系

1. 集合主要是两组（单列集合，双列集合）
2. Collection接口有两个重要的子接口 List Set，他们的实现子类都是单列集合
3. Map 接口的实现子类 是双列集合，存放的 K-V

单列集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xegke8k6-1658839463233)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658382762829.png)]

双列集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iL9QHI3J-1658839463234)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658382903671.png)]

Collection接口和常用方法

Collection接口实现类的特点

public interface Collection extends Lterable

1. Collection实现子类可以存放多个元素，每个元素可以是Object
2. 有些Collection的实现类，可以存放重复的元素，有些不可以
3. 有些Collection的实现类，有些是有序的（List），有些不是有序的（Set）
4. Collection接口没有直接的实现子类，是通过它的子类Set和List来实现的

常用方法

1. add：添加单个元素
2. remobe:删除指定元素
3. contains:查找元素是否存在
4. size:获取元素个数
5. isEmpty:判断是否为空
6. clear:清空
7. addAll:添加多个元素
8. containsAll:查找多个元素是否存在
9. rempveAll:删除多个元素
10. 说明：以ArrayList实现类来演示

遍历元素方式 - 使用Iterator（迭代器）

1. Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。
2. 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，既可以返回一个迭代器。
3. Iterator的结构。
4. Iterator仅用于遍历集合，Iterator本省并不存放对象。

// 快捷键 快速生成 while => itit

​ 显示所有快捷键 ctrl + j

在运行iterator时，希望再次遍历，需要重置我们的迭代器。

遍历元素方式 - for循环增强

增强for循环，可以代替iterator迭代器，特点：增加for就是简化版的iterator，本质一样只能用于遍历集合或数组。

基本语法

for（元素类型 元素名：集合名或数组名）{

​ 访问元素 }

快捷方式 （大写i）I

练习 1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yEOVxvdY-1658839463236)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658475611697.png)]

package com.zzj.Collection_;

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

/**
 * @author 张正杰
 * @version 1.0
 */
public class CollectionExercise {
    public static void main(String[] args) {
        List list = new ArrayList();

        list.add(new Dog("大黄", 2));
        list.add(new Dog("小花", 1));
        list.add(new Dog("小黑", 5));

        System.out.println("使用增强for");
        for (Object dog : list) {
            System.out.println(dog);
        }

        System.out.println("使用迭代器");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object dog =  iterator.next();
            System.out.println(dog);
        }

    }
}

class Dog {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

练习 2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MWliQWII-1658839463236)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658476544343.png)]

package com.zzj.Collection_;

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

/**
 * @author 张正杰
 * @version 1.0
 */
public class ListExercise {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        for (int i = 0; i < 12; i++) {
            list.add("hello" + i);
        }
        System.out.println(list);
        //在2号位插入一个元素“张正杰”
        list.add(1,"张正杰");
        //获取第5个元素
        System.out.println("第五个元素" + list.get(4));
        //删除第6个元素
        list.remove(5);
        //修改第7个元素
        list.set(6, "z");

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}

List 的三种遍历方式【ArrayList,LinkedList,Vector】

1. 使用iterator

   Lterator iter = col.iterator();

   ​ while(iterhasNext()){

   ​ Object o = iter.next();

   }

2. 使用增强for

   for(Object o:col){

   }

3. 使用普通for

   for(int i = 0;i < list.size();i++) {

   ​ Object object = list.get(i);

   ​ System.out.println(object);

   }

说明：使用LinkedList完成 使用方式和ArrayList 一样

练习 3

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JCDIFhBd-1658839463237)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658557178658.png)]

package com.zzj.Collection_;

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

/**
 * @author 张正杰
 * @version 1.0
 */
public class ListExercise02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //List list = new LinkedList();
        //List list = new Vector();


        list.add(new Book("红楼梦", 100, "曹雪芹"));
        list.add(new Book("西游记", 10, "吴承恩"));
        list.add(new Book("水浒传", 9, "施耐庵"));
        list.add(new Book("三国演义", 80, "罗贯中"));
        //list.add(new Book("西游记", 10, "吴承恩"));

        for (Object obj : list) {
            System.out.println(obj);
        }
        //冒泡排序
        sort(list);

        //排序后
        System.out.println("排序后");
        for (Object obj : list) {
            System.out.println(obj);
        }

    }
    //静态方法
    public static void sort(List list) {

        for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < list.size() - 1 -i; j++) {
                //去处对象Book
                Book book1 = (Book)list.get(j);
                Book book2 = (Book)list.get(j + 1);
                //排序
                if (book1.getRMB() > book2.getRMB()) {
                     list.set(j, book2);
                     list.set(j + 1, book1);
                }
            }
        }
    }
}
class Book {
    private String name;
    private int RMB;
    private String author;

    public Book(String name, int RMB, String author) {
        this.name = name;
        this.RMB = RMB;
        this.author = author;
    }

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

    public String getName() {
        return name;
    }

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

    public int getRMB() {
        return RMB;
    }

    public void setRMB(int RMB) {
        this.RMB = RMB;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

ArrayList注意事项

1. permits all elements, including null , ArrayList 可以加入null，并且多个
2. ArrayList 是由数组来实现数据存储的
3. ArrayList基本你等同于Vector ,处了 ArrayList是线程不安全（执行效率高）看原码，在多线程情况下，不建议使用ArrayList。

ArrayList底层操作机制源码分析（重点，难点）

1. ArrayList中维护了一个object类型的数组elementData。【debug 看源码】transient Object[] elementData;

   //transient 表示瞬间，短暂的，表示该属性不会被序列号

2. 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需再次扩容，则扩容elementData为1.5倍。

3. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要直接扩容elementData为1.5倍。

Vector底层结构和原码剖析

1. Vector类的定义说明

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KiOXpddE-1658839463238)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658564581120.png)]

2. Vector底层也是一个对象数组，protected Object[] elementData;

3. Vector是线程同步的，即线程安全，Vector类的操作方法带有 synchronized

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vIDeCso2-1658839463238)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658564690322.png)]

4. 在开发中 ，需要线程同步安全时，考虑使用Vector。

Vector 比较 ArrayList

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bdVFvYWP-1658839463239)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658566293673.png)]

LinkedList底层结构

全面说明

1. LinkedList实现了双向两边和双端队列特点
2. 可以添加任意元素（元素可以重复），包括null
3. 线程不安全，没有实现同步

底层操作机制

1. LinkedList底层维护了一个双向链表
2. LinkedList中维护了两个属性first和last分别指向 首节点和尾结点
3. 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表。
4. 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。
5. 模拟一个简单的双向链表。

D:\Java\jdk1.8.0_224\bin\java.exe "-javaagent:E:\IDEA\IntelliJ IDEA 2022.1\lib\idea_rt.jar=55524:E:\IDEA\IntelliJ IDEA 2022.1\bin" -Dfile.encoding=UTF-8 -classpath D:\Java\jdk1.8.0_224\jre\lib\charsets.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\access-bridge-64.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\dnsns.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\jaccess.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\jfxrt.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\localedata.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\sunec.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\sunjce_provider.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\sunmscapi.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\sunpkcs11.jar;D:\Java\jdk1.8.0_224\jre\lib\ext\zipfs.jar;D:\Java\jdk1.8.0_224\jre\lib\javaws.jar;D:\Java\jdk1.8.0_224\jre\lib\jce.jar;D:\Java\jdk1.8.0_224\jre\lib\jfr.jar;D:\Java\jdk1.8.0_224\jre\lib\jfxswt.jar;D:\Java\jdk1.8.0_224\jre\lib\jsse.jar;D:\Java\jdk1.8.0_224\jre\lib\management-agent.jar;D:\Java\jdk1.8.0_224\jre\lib\rt.jar;D:\Java\word\chapter13\out\production\chapter13 com.zzj.list_.LinkedList01
====从头到尾进行遍历====
Node name=jack
Node name=tom
Node name=zzj
====从尾到头进行遍历====
Node name=zzj
Node name=tom
Node name=jack
====添加后从头到尾进行遍历====
Node name=jack
Node name=tom
Node name=smith
Node name=zzj

Process finished with exit code 0

底层结构

增加

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LeoURTMS-1658839463240)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658644696946.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k8gzhJ1C-1658839463240)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658644739002.png)]

删除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2JGS01AI-1658839463241)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658645152616.png)]

ArrayList 比较 LinkedList

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EgOTqsXA-1658839463241)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658645706374.png)]

如何选择ArrayList 和 LinkedList：

1. 如果我们改查的操作多，就选择ArrayList
2. 如果我们增删操作多，选择LinkedList
3. 一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList
4. 在一个项目中，根据业务灵活选择，也可能这样，一个模式使用的是ArrayList，另一个模块是LinkedList。

Set接口和常用方法

Set接口介绍

1. 无序(添加和去除的顺序不一致)， 没有索引

2. 不允许重复出现元素，所以最多包含一个null

3. JDK API中Set接口的实现类有：

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9NOhStZ-1658839463242)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658646231771.png)]

Set接口常用方法

和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样。

Set接口的遍历方式

同Collection的遍历方式一样，因此Set接口是Collection接口的子接口。

1. 可以使用迭代器
2. 增强for
3. 不能使用索引的方式来获取。

HashSet的全面说明

1. hashSet实现了Set接口

2. HashSet实现上是HashMap

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uIJYfOCe-1658839463243)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658648572281.png)]

3. 可以存放null值，但是只能有一个null

4. HashSet不保证元素是有序的，取决于hash后，在确定索引的结果。

5. 不能有重复元素/对象，在前面Set接口使用已经讲过

HashSet底层机制说明

分析HashSet底层是HashMap，HashMap底层是（数组+ 链表 +红黑树）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ewWiCimT-1658839463243)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658649899962.png)]

1. HashSet 底层是 HashMap
2. 添加一个元素时，先得到hash值 - 会转成 -> 索引值
3. 找到储存数据表table，看到这个索引位置是否已经存放的有元素
4. 如果没有，直接加入
5. 如果有，调用equals比较，如果相同，就放弃添加，如果不同，则添加到最后
6. 在Java8中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树）

练习

1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iJX0fzV2-1658839463244)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658665761738.png)]

package com.zzj.set_;

import java.util.HashSet;
import java.util.Objects;

/**
 * @author 张正杰
 * @version 1.0
 */
public class HashSetExercise {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add(new Employee("大黄", 2));
        hashSet.add(new Employee("小花", 1));
        hashSet.add(new Employee("大黄", 2));

        System.out.println(hashSet);


    }

//    @Override
//    public boolean equals(Object obj) {
//        return super.equals(obj);
//    }
}

class Employee {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

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

2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V9IJKnh6-1658839463244)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658728547142.png)]

LinkedHashSet 全面说明

1. LinkedHashSet 是 HashSet 的子类
2. LinkedHashSet 底层是一个 LinkedHashMap，底层维护了一个数组 + 双向链表
3. LinkedHashSet根据元素的hashCode 值来决定元素的存储位置，同时使用链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
4. LinkedHashSet不允许添重复元素

底层机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jvu34sNg-1658839463245)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658730710712.png)]

1. 在LinkedHashSet 中 维护了一个 hash表和双向链表 （LinkedHashSet 有 head 和 tail）
2. 每一个节点有 before 和 after 属性 ，这样可以形成双向链表
3. 在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加[原则和hashset一样]）
4. 这样的话，我们遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致

Map接口 和 常用方法

Map接口实现类的特点

注意：这里讲的是JDK8的Map接口

1. Map与Collection并列存在，用于保存具有映射关系的数据：Key-Value

2. Map中的Key 和 value 可以是任何引用类型的数据，会封装到HashMap$Node对象中

3. Map 中的 Key 不能重复 ，原因和HashSet 一样，前面分析过源码

4. Map中的value可以重复

5. Map 的 key 可以为 null ， value 也可以为null，注意 Key 为 Null ，只能有一个，value为null ，可以为多个。

6. 常用 String 类 作为May 的Key

7. Key 和 Value 之间存在单向一对一关系，即通过指定的Key 总能找到对应的value。

8. Map存放的数据的key-value示意图，一对 k-v 是放在一个Node中的，又因为Node实现了 Entry接口， 有些书上也说 一对 k-v 就是一个Entry。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-er74KNvF-1658839463245)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658738073064.png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tHZh25s3-1658839463246)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658735513002.png)]

Map体系图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wePjpfH4-1658839463246)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658738177200.png)]

Map常用方法

1. put:添加
2. remove:根据键删除映射关系
3. get:根据键获取值
4. size:获取元素个数
5. isEmpty:判断个数是否为0
6. clear:清除
7. containsKey:查找键是否存在

Map接口遍历方法

1. containsKey：查找键是否存在
2. KeySet：获取所有的键
3. entrySet：获取所有关系
4. values:获取所有的值

package com.zzj.map_;

import java.util.*;

/**
 * @author 张正杰
 * @version 1.0
 */
public class MapFor {
    public static void main(String[] args) {

        HashMap map = new HashMap();
        map.put("邓超","孙俪");
        map.put("王宝强","马蓉");
        map.put("宋喆","马蓉");
        map.put("刘凌波",null);
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");

        //第一组：先取出所有的Key，通过Key取出相应的Value
        Set keySet = map.keySet();
        //（1）增强for
        System.out.println("---第一种");
        for (Object key : keySet) {
            System.out.println(key + "-" + map.get(key));
        }
        //（2）迭代器
        System.out.println("---第二种");
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            System.out.println(key + "-" + map.get(key));
        }

        //第二组：把所有的values取出
        Collection values = map.values();
        //这里可以使用所有的Collections使用的遍历方法
        //（1）增强for
        System.out.println("----取出所有的value----");
        for (Object value : values) {
            System.out.println(value);
        }
        //（2）迭代器
        Iterator iterator2 = values.iterator();
        while (iterator2.hasNext()) {
            Object value = iterator2.next();
            System.out.println(value);
        }

        //第三组：通过EntrySet 来获取 k-v
        Set entrySet = map.entrySet();//EntrySet<Map.Entry<K,V>>
        //（1）增强for
        for (Object entry : entrySet) {
            //将 entry 转成 map.entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
        //（2）迭代器
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {
            //System.out.println(next.get());//HashMap$Node -实现-> Map.Entry(getKey,getValue)
            //向下转型 Map.Entry
           // Map.Entry next = (java.util.Map.Entry) iterator3.next();
            Object entry = iterator3.next();
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
    }
}

小练习

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PfwrlQJy-1658839463247)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658746644115.png)]

package com.zzj.map_;

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

/**
 * @author 张正杰
 * @version 1.0
 */
public class MapExercise {
    public static void main(String[] args) {
        Map hashMap = new HashMap();
        //添加对象
        hashMap.put(1, new Employee("大黄", 10000, "110"));
        hashMap.put(2, new Employee("小黑", 19000, "120"));
        hashMap.put(3, new Employee("旺旺", 39000, "130"));

        //进行遍历
        //1.使用KeySet -> 增强for
        Set keySet = hashMap.keySet();
        System.out.println("第一种便利方式");
        for (Object key : keySet) {
           //先获取value
            Employee emp = (Employee) hashMap.get(key);
            if (emp.getSal() > 18000) {
                System.out.println(emp);
            }
        }
        //2.使用EntrySet -> 迭代器
        Set entrySet = hashMap.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator.next();
            //通过entry 获取 key 和 value
            Employee employee = (Employee) entry.getValue();
            if (employee.getSal() > 18000) {
                System.out.println(employee);
            }

        }
    }
}

class Employee {
    private String name;
    private double sal;
    private String id;

    public Employee(String name, double sal, String id) {
        this.name = name;
        this.sal = sal;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", id='" + id + '\'' +
                '}';
    }
}

HashMap小结

1. Map接口的常用实现类：HashMap、Hashtable和Properties。
2. HashMap是Map接口使用频率最高的实现类。
3. HashMap是以 key-val 对的方式来存储数据
4. key 不能重复，但是是值可以重复，允许使用null键和null值。
5. 如果添加相同的key，则会覆盖原来的key-val，等同于修改，（key不会替换，val会替换）
6. 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的。
7. HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronized

HashMap底层机制及源码剖析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-atM7xbLz-1658839463248)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658748408185.png)]

1. （k,v)是一个Node实现了Map.Entry<K,V>,查看了HashMap的源码可以看到。
2. jdk7.0的HashMap 底层实现[数组 + 链表]，jdk8.0底层[数组 + 链表 + 红黑树]

扩容机制[和HashSet相同]

1. HashMap底层维护了Node类型的数组table，默认为null
2. 当创建对象时，将加载因子(loadfactor)初始化为0.75.
3. 当添加key-val时，通过key的哈希值得到在table的素 。然后判断该索引处是否有元素， 如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key是否和准备加入的 key相等，如果相等，则直接替换val；如果不相等需要判断是树结构还是链表结构，做出 相应处理。如果添加时发现容量不够，则需要扩容。
4. 第1次添加，则需要扩 容table容量为16，临界值(threshold)为12.
5. 以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍,即24,依次类推
6. 在Java8中，如果一条链表的元素个数超过 TREEIFY_THRESHOLD（默认是8），并且 table的大小 ＞= MIN_TREEIFY_CAPACITY（默认64),就会进行树化(红黑树）

HashTable基本介绍

1. 存放的元素是键值对：即 K-V
2. hashtable的键和值都不能为null
3. hashTable使用方法基本上和HashMap一样
4. HashTable是线程安全的，HashMap是线程不安全的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IZSNstCt-1658839463248)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658812077706.png)]

HashMap 与 Hashtable对比

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZcaBGBxC-1658839463249)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658813241017.png)]

properties 基本介绍

1. Properties类继承自HashTable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。
2. 他的使用特点和HashTable类似
3. Properties还可以用于 从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改。
4. 说明：工作后 xxx.properties文件通常作为配置文件，这个知识点在IO流

package com.zzj.map_;

import java.util.Properties;

/**
 * @author 张正杰
 * @version 1.0
 */
public class Properties_ {
    public static void main(String[] args) {

        Properties properties = new Properties();
        //添加
        //properties.put(null, 100); //抛出空指针异常
        //properties.put("zzj", null); //抛出空指针异常
        properties.put("zzj", 100); // K-V
        properties.put("lucy", 100);
        properties.put("lic", 100);
        properties.put("lic", 80); //如果有相同的key，value被替换

        System.out.println("properties" + properties);

        //通过k 获取对应值
        System.out.println(properties.get("lic")); //88

        //删除
        properties.remove("lic");
        System.out.println("properties" + properties);

       //修改
        properties.put("zzj", "帅");
        System.out.println("properties" + properties);

        //查找
        System.out.println(properties.get("zzj"));
        System.out.println(properties.getProperty("zzj")); // getPropertyruguo value类型 不为String类型，则返回null

    }
}

总结：开发中如何选择集合实现类（记住）

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现特性进行选择，分析如下：

1. 先判断存储类型（一组对象[单列]或一组键值对[双列])

2. 一组对象[单列]:Collection接口

   允许重复：List

   ​ 增删多：LinkedList[底层维护了一个双向链表]

   ​ 改查多：ArrayList[底层维护 Object类型的可变数组]

   不允许重复：Set

   ​ 无序：HashSet[底层是HashMap，维护了一个哈希表 即（数组+链表+红黑树）]

   ​ 顺序：TreeSet

   ​ 插入和去除顺序一致：LinkedHashSet，维护数组+双向链表

3. 一组键值对：Map

   ​ 键无序：HashMap[底层是：哈希表 jdk7：数组 + 链表， jdk8：数组链表+红黑树]

   ​ 键排序：TreeMap

   ​ 键插入和去除顺序一致：LinkedHashMap

   ​ 读取文件 Properties

TreeSet

package com.zzj.map_;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author 张正杰
 * @version 1.0
 */
public class TreeSet_ {
    public static void main(String[] args) {

        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //下面调用String的 compareTo方法进行字符串大小比较
                // retrun((String) o2).compareTo((String) o1);
                return ((String) o2).length() - ((String) o1).length();
            }
        });

        //添加数据
        treeSet.add("jack");
        treeSet.add("tom"); // 3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc"); //加不进去 因为与上面的长度相同 3


        System.out.println(treeSet);

    }
}

TreeMap

package com.zzj.map_;

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

/**
 * @author 张正杰
 * @version 1.0
 */
public class TreeMap_ {
    public static void main(String[] args) {

        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照传入的K(String) 的大小进行排序
                //return ((String) o1).compareTo((String) o2);
                //按照K（String）的长度大小排序
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        //使用默认的构造器，创建TreeMap，是无序的
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "科瑞斯特");
        treeMap.put("smith", "私密事");

        System.out.println("TreeMap" + treeMap);
    }
}

Collections工具类

Collections工具类介绍

1. Collections是一个操作Set、List和Map等集合的工具类
2. Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作

排序操作：（均为static方法）

1. reverse(List):翻转List中元素的顺序
2. shuffle(List):对List集合元素进行随机排序
3. sort(List):根据元素的自然排序对指定List集合元素按升序排序
4. sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
5. swap(List,int,int):将指定list集合中的 i 处元素和 j 处元素进行交换

查找 替换

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

练习

1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5TLQawVo-1658839463250)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658830480973.png)]

package com.zzj.map_;

import java.util.ArrayList;

/**
 * @author 张正杰
 * @version 1.0
 */
public class HomeWork01 {
    public static void main(String[] args) {

        ArrayList list = new ArrayList();
        list.add(new News("新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧"));
        list.add(new News("男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生"));

       //System.out.println(list);
        //倒叙遍历
        int size = list.size();
        for (int i = size - 1; i >= 0 ; i--) {
            News o = (News) list.get(i);
            //System.out.println(o.getTitle());
            System.out.println(processTitle(o.getTitle()));
        }
    }
    //专门写一个方法，处理现实新闻标题
    public static String processTitle(String title) {
        if (title == null) {
            return "";
        }
        if (title.length() > 15) {
            return title.substring(0, 15) + "...";
        } else {
            return title;
        }
    }
}

class News {
    private String title;
    private String contant;

    public News(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContant() {
        return contant;
    }

    public void setContant(String contant) {
        this.contant = contant;
    }

    @Override
    public String toString() {
        return "title='" + title + '\n';
    }
}

2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-797yQ042-1658839463251)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658832364745.png)]

package com.zzj.map_;

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

/**
 * @author 张正杰
 * @version 1.0
 */
public class HomeWork02 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        Cat car1 = new Cat("宝马", 4000000);
        Cat car2 = new Cat("宾利", 50000000);
        //添加
        list.add(car1);
        list.add(car2);
        System.out.println(list);
        //删除
        list.remove(car1);
        System.out.println(list);
        //查找
        System.out.println(list.contains(car1));
        System.out.println(list.contains(car2));
        //个数
        System.out.println(list.size());
        //判断是否为空
        System.out.println(list.isEmpty());
        //清空
        //list.clear();
        //System.out.println(list);
        //添加多个
        list.addAll(list);//两个宾利
        System.out.println(list);
        //查找多个元素
        list.containsAll(list);
        //删除多个
        //list.removeAll(list);//相当于清空

        //增强否遍历 list
        System.out.println("增强否遍历 list");
        for (Object obj : list) {
            Cat cat = (Cat) obj;
            System.out.println(cat);
        }

        //迭代器遍历 list
        System.out.println("迭代器遍历 list");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

    }
}

class Cat {
    private String name;
    private int price;

    public Cat(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

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

3

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gB7d3bTk-1658839463251)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658836349176.png)]

package com.zzj.map_;

import java.util.*;

/**
 * @author 张正杰
 * @version 1.0
 */
public class HomeWork03 {
    public static void main(String[] args) {
        HashMap m = new HashMap();
        m.put("jack", 650); //int ->Integer
        m.put("tom", 1200);
        m.put("smith", 2900);
        System.out.println(m);
        //将jack的工资更改为2600
        m.put("jack", 2600);
        System.out.println(m);
        Set set = m.keySet();
        for (Object o : set) {
            //更新
            m.put(o, (Integer)m.get(o) + 100);
        }
        System.out.println(m);

        //遍历 EntrySet
        System.out.println("========遍历 EntrySet===========");
        Set set1 = m.entrySet();
        //迭代器
        Iterator iterator = set1.iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator.next();
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

        //遍历工资
        System.out.println("========遍历工资=========");
        Collection values = m.values();
        for (Object o : values) {
            System.out.println(o);
        }
    }
}

4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uePRg2Wq-1658839463252)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658837510033.png)]

5

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZtDIuj36-1658839463252)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658837563057.png)]

解决： 实现 Comparable接口

6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WEMv1tr6-1658839463253)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658838018482.png)]

7

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iPfya49e-1658839463254)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1658838399494.png)]

rgs) {
HashMap m = new HashMap();
m.put(“jack”, 650); //int ->Integer
m.put(“tom”, 1200);
m.put(“smith”, 2900);
System.out.println(m);
//将jack的工资更改为2600
m.put(“jack”, 2600);
System.out.println(m);
Set set = m.keySet();
for (Object o : set) {
//更新
m.put(o, (Integer)m.get(o) + 100);
}
System.out.println(m);

    //遍历 EntrySet
    System.out.println("========遍历 EntrySet===========");
    Set set1 = m.entrySet();
    //迭代器
    Iterator iterator = set1.iterator();
    while (iterator.hasNext()) {
        Map.Entry entry = (Map.Entry) iterator.next();
        System.out.println(entry.getKey() + "-" + entry.getValue());
    }

    //遍历工资
    System.out.println("========遍历工资=========");
    Collection values = m.values();
    for (Object o : values) {
        System.out.println(o);
    }
}

}

## 4

[外链图片转存中...(img-uePRg2Wq-1658839463252)]

## 5

[外链图片转存中...(img-ZtDIuj36-1658839463252)]

解决： 实现 Comparable接口

## 6

[外链图片转存中...(img-WEMv1tr6-1658839463253)]

## 7

[外链图片转存中...(img-iPfya49e-1658839463254)]