Java集合 自学笔记

【韩顺平讲Java】Java集合专题 视频地址

视频地址

Java集合

集合的理解和好处

数组的不足之处

/**
 * @author hejh7
 * @date 2022/11/1 0001 17:00
 * @describe
 * 数组的不足
 * 1.长度开始必须指定，而且一旦指定，不能修改
 * 2.保存的必须为同一类型的元素
 * 3.使用数组添加元素比较麻烦
 *
 */
public class ArrayExample {
    public static void main(String[] args) {
        Person[] peoples = new Person[3];
        peoples[0] = new Person("小米",13);
        peoples[1] = new Person("小明",15);
        peoples[2] = new Person("小红",22);
        for (Person people : peoples) {
            System.out.println(people);
        }

        System.out.println("-----扩容后----------");
        Person[] personAdd = new Person[5];
        for (int i = 0; i < peoples.length; i++) {
            personAdd[i] = peoples[i];
        }

        personAdd[3] = new Person("梅梅",15);
        personAdd[4] = new Person("兰兰",18);

        for (Person person : personAdd) {
            System.out.println(person);
        }
    }
}

集合的好处

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

Collection 接口图

Map接口图

1.集合主要是两组(单列集合、双列集合)
2.Collection接口有两个重要的子接口List Set 它们的实现子类都是单列集合
3.Map接口的实现子类 是双列集合，存放的 Key-Value

Collection接口实现类的特点

public interface Collection extends Iterable

(1)Collection实现子类可以存放多个元素,每个元素可以是Object
(2)有些Collection的实现类，可以存放重复的元素，有些不可以
(3)有些Collection的实现类是有序的(List),有些是无序的(Set)–这里说的有序和无序是指取出的顺序是否和放入顺序一致
(4)Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

示例:

/**
 * @author hejh7
 * @date 2022/11/1 0001 18:02
 * @describe
 */
@SuppressWarnings("all")
public class CollectionExa {
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加元素
        list.add("jack");
        list.add(10);
        list.add(true);
        list.add(new Integer(33));
        list.add(new String("tom"));
        System.out.println("list=" + list);

        //删除元素
        list.remove(0);//按照索引删除第一个元素
        list.remove("jack");//删除指定的元素
        System.out.println("list="+list);

        //查找元素
        System.out.println(list.contains(true));
        System.out.println(list.contains("jack"));

        //获取元素个数
        System.out.println(list.size());

        //集合是否为空
        System.out.println(list.isEmpty());

        //清空
        list.clear();
        System.out.println("list=" + list);

        //添加集合  多个元素
        List list2 = new ArrayList();
        list2.add("兰兰");
        list2.add(false);
        list2.add(22);
        list.addAll(list2);
        System.out.println("list=" + list);

        //查找多个元素是否存在
        System.out.println(list.containsAll(list2));

        //删除多个元素
        list.add(22.67);
        list.removeAll(list2);
        System.out.println("list=" + list);
    }
}

使用迭代器Iterator(迭代器)

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

Itrator接口的方法

示例:

package com.ItratorExercise;

import org.junit.Test;

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

/**
 * @author wty
 * @date 2022/10/4 11:45
 */
public class ItratorExercise {
    @Test
    @SuppressWarnings({"all"})
    public void getItrator() {
        Collection arrayList = new ArrayList();
        arrayList.add(new Book("三国演义", "罗贯中", 42.99));
        arrayList.add(new Book("西游记", "吴承恩", 38.5));
        arrayList.add(new Book("水浒传", "施耐庵", 66.66));

        System.out.println("直接输出:" + arrayList);
        System.out.println("------------------");

        // 先得到对应的迭代器
        Iterator iterator = arrayList.iterator();
        // 快捷键itit
        // ctrl + j ：所有快捷键的快捷键

        while (iterator.hasNext()) { // 判断是否还有数据
            // 返回下一个元素，类型是Object
            Object next = iterator.next();
            System.out.println(next);
        }

        // 当退出while循环后,这时迭代器指向最后一个元素
        //报错 iterator.next(); // java.util.NoSuchElementException

        // 如果希望再次遍历，需要重置迭代器
        arrayList.add("今天天气不错");
        System.out.println("重置迭代器之后………………");
        iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

class Book {
    private String name;
    private String author;
    private double price;

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

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

    public double getPrice() {
        return price;
    }

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

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

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

for循环增强遍历

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

基本语法:

for(元素类型 元素名:集合名或数组名){
 访问元素
}

示例：

package com.StrongFor;

import org.junit.Test;

import java.util.ArrayList;

/**
 * @author wty
 * @date 2022/10/4 14:18
 */
public class StrongFor {
    @Test
    public void strongFor() {

        ArrayList arrayList = new ArrayList();
        arrayList.add(new Teacher("王老师", 45, 1.68));
        arrayList.add(new Teacher("李老师", 25, 1.58));
        arrayList.add(new Teacher("刘老师", 27, 1.78));

        // 使用增强for循环，在Collection集合
        // 底层仍然是迭代器
        // 增强for循环，可以理解成简化版的迭代器
        // I快捷键
        for (Object o : arrayList) {
            System.out.println(o);
        }


        // 增强for循环也可以在数组使用
        int[] nums = {1, 8, 9, 10};
        for (int num : nums) {
            System.out.println(num);
        }

    }
}

class Teacher {
    private String name;
    private int age;
    private double height;

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

    public double getHeight() {
        return height;
    }

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

    public Teacher(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

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

课堂练习:

编写程序CollectionExercise
(1)创建3个Dog{name,age}对象,放入到ArrayList中，赋给List使用
(2)用迭代器和增强for循环两种方式来遍历
(3)重写Dog的toString方法，输出name和age

/**
 * @author hejh7
 * @date 2022/11/5 0005 12:53
 * @describe
 */
@SuppressWarnings({"all"})
public class CollectionExercise {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("大黄",3));
        list.add(new Dog("小黑",15));
        list.add(new Dog("大壮",6));
        System.out.println("-----------迭代器遍历------------------");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println("-------------增强for循环------------------");
        for (Object obj : list) {
            System.out.println(obj);
        }
    }
}

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

List接口和常用方法

List接口是Collection接口的子接口

(1)List集合类中元素有序(即添加顺序和取出顺序一致)、并且可以重复
(2)List集合中的每个元素都有其对应的顺序索引，即支持索引
(3)List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
(4)List接口的常用实现类有:ArrayList、LinkedList和Vector

List接口和常用方法
(1)add 在index位置插入元素
(2)addAll 从index位置开始将所有元素添加进来
(3)get 获取指定index位置的元素
(4)indexOf 返回在集合中首次出现的位置
(5)lastIndexOf 返回在当前集合中末次出现的位置
(6)remove 移除index位置的元素，并返回此元素
(7)set 设置指定index位置的元素(替换)
(8)subList 返回一个范围位置中的子集合

示例:

package com.ListExercise;
	
	import org.junit.Test;
	
	import java.util.ArrayList;
	import java.util.List;
	
	/**
	 * @author wty
	 * @date 2022/10/4 15:04
	 */
	public class ListMethod {
	    @Test
	    public void ListMethodExercise() {
	        List list = new ArrayList();
	        list.add("张三丰");
	        list.add("贾宝玉");
	
	        // 插入一个元素
	        list.add(1, "林黛玉");
	        System.out.println(list);
	
	        // 插入一个集合
	        List list2 = new ArrayList();
	        list2.add("Jack");
	        list2.add("Tom");
	        list.addAll(1, list2);
	        System.out.println(list);
	
	        // 获取集合中索引的值
	        System.out.println("get(2):" + list.get(2)); // Tom
	
	        // 返回首个出现的位置
	        System.out.println(list.indexOf("林黛玉")); // 3
	
	        // 返回末次出现的位置
	        list.add("林黛玉");
	        System.out.println(list.lastIndexOf("林黛玉")); // 5
	
	        // 移除元素并且输出该元素
	        list.remove(5);
	        System.out.println(list);
	
	        // 替换
	        list.set(1, "王宝强");
	        System.out.println(list);
	
	        // 返回范围值内的子集合[0,3)所以只有0，1，2三个元素
	        List listReturn = list.subList(0, 3);
	        System.out.println(listReturn);
	    }
	}

练习:

package com.ListExercise;
	
	import org.junit.Test;
	
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	
	/**
	 * @author wty
	 * @date 2022/10/4 15:17
	 */
	public class ListExercise02 {
	    @Test
	    public void ListExer02() {
	        List list = new ArrayList();
	        list.add("1 你好");
	        list.add("2 hello world");
	        list.add("3 10");
	        list.add("4 今天天气不错");
	        list.add("5 开心");
	        list.add("6 难过");
	        list.add("7 悲伤");
	        list.add("8 喜悦");
	        list.add("9 幸福");
	        list.add("10 自豪");
	        System.out.println(list);
	
	        list.add(1, "韩顺平教育");
	        System.out.println("在2号位置插入:" + list);
	
	        System.out.println("获取第5个元素:" + list.get(4));
	        list.remove(5);
	        System.out.println("删除第6个元素后:" + list);
	        list.set(6, "很悲伤");
	        System.out.println("修改第7个元素后:" + list);
	
	
	        Iterator iterator = list.iterator();
	        while (iterator.hasNext()) {
	            Object next = iterator.next();
	            System.out.println(next);
	        }
	    }
	}

List的三种遍历方式

(1)方式一:使用迭代器
(2)方式二:增强for循环
(3)方式三:使用普通for循环

package com.ListExercise;

import org.junit.Test;

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

/**
 * @author wty
 * @date 2022/10/4 18:08
 */
public class Bianli {
    @Test
    public void getBianli() {
        List list = new ArrayList();
        list.add("Jack");
        list.add("Tom");
        list.add("鱼香肉丝");
        list.add("北京烤鸭");

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

        // 增强for循环遍历
        System.out.println("------增强for循环遍历:-------");
        for (Object o : list) {
            System.out.println(o);
        }

        // 普通for循环遍历(类似数组)
        System.out.println("-----普通for循环遍历:-------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }

    @Test
    public void getBianli02() {
        List vector = new Vector();
        vector.add("Jack");
        vector.add("Tom");
        vector.add("鱼香肉丝");
        vector.add("北京烤鸭");

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

        // 增强for循环遍历
        System.out.println("------增强for循环遍历:-------");
        for (Object o : vector) {
            System.out.println(o);
        }

        // 普通for循环遍历(类似数组)
        System.out.println("-----普通for循环遍历:-------");
        for (int i = 0; i < vector.size(); i++) {
            System.out.println(vector.get(i));
        }

    }
}

课堂练习2

package com.he.list_;

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

/**
 * @author hejh7
 * @date 2022/11/6 0006 10:47
 * @describe
 */
@SuppressWarnings({"all"})
public class ListExercise03 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Book("红楼梦","曹雪芹",100));
        list.add(new Book("西游记","吴承恩",45));
        list.add(new Book("水浒传","施耐庵",12));
        list.add(new Book("三国志","罗贯中",26));

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
        
        System.out.println("================排序后=======================");
        Sort(list);
        Iterator iterator1 = list.iterator();
        while (iterator1.hasNext()) {
            Object obj = iterator1.next();
            System.out.println(obj);
        }
    }

    public static void Sort(List list){
        int listSize = list.size();
        for (int i = 0; i < listSize - 1; i++) {
            for (int j = 0; j < listSize-1-i; j++) {
                Book book1 = (Book)list.get(j);
                Book book2 = (Book)list.get(j+1);
                if (book1.getPrice() > book2.getPrice()){
                    list.set(j,book2);
                    list.set(j+1,book1);
                }
            }
        }
    }
}

ArrayList底层结构和源码分析

(1).ArrayList可以放所有的元素甚至是空元素，可以放入多个空值。
(2).ArrayList是由数组来实现数据存储的。
(3).ArrayList基本等同于Vector，除了ArrayList是线程不安全(执行效率高)，在多线程下，不建议用ArrayList。
(4).ArrayList中维护了一个Object类型的数组elementData
transient Object[] elementData
transient：短暂的，瞬间的，表示该属性不会被序列化
(5).当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量是0，第1次添加，则扩容elementData为10,如需再次扩容，则扩容elementData为1.5倍
(6).如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

源码分析：

1.无参构造ArrayList集合

1.有参构造ArrayList集合

Vector底层机构和源码剖析

Vector的基本介绍

(1)Vector类的定义说明:

public class Vector extends AbstractList 
       implements List, RandomAccess, Cloneable,Serializable

(2)Vector底层也是一个对象数组，protected Object[] elementData
(3)Vector 是线程同步的，即线程安全，Vector类的操作方法带有synchronized
(4)在开发中，需要线程同步安全时，优先考虑用Vector

package com.he.list_;

import java.util.Vector;

/**
 * @author hejh7
 * @date 2022/11/6 0006 18:11
 * @describe
 */
@SuppressWarnings({"all"})
public class Vector_ {
    public static void main(String[] args) {
        Vector vector = new Vector();
        for (int i = 1; i <= 10; i++) {
            vector.add(i);
        }

        vector.add(100);
        //源码解读
        /**
         * 1.无参构造 初始化为10
         * public Vector(int initialCapacity) {
         *         this(initialCapacity, 0);
         *     }
         * 2.添加元素
         *  public synchronized boolean add(E e) {
         *         modCount++;
         *         ensureCapacityHelper(elementCount + 1);
         *         elementData[elementCount++] = e;
         *         return true;
         *     }
         *  3.添加的元素大于集合的容量进行扩容 扩大到原来的两倍
         *  int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  capacityIncrement : oldCapacity);
         *  private void grow(int minCapacity) {
         *         // overflow-conscious code
         *         int oldCapacity = elementData.length;
         *         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
         *                                          capacityIncrement : oldCapacity);
         *         if (newCapacity - minCapacity < 0)
         *             newCapacity = minCapacity;
         *         if (newCapacity - MAX_ARRAY_SIZE > 0)
         *             newCapacity = hugeCapacity(minCapacity);
         *         elementData = Arrays.copyOf(elementData, newCapacity);
         *     }
         */
    }
}

Vector和List比较

LinkedList底层结构

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

LinkedList的底层操作机制

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

模拟一个双向链表简单示例:

package com.he.list_;

/**
 * @author hejh7
 * @date 2022/11/7 0007 12:32
 * @describe
 */
@SuppressWarnings({"all"})
public class LinkedList_ {
    public static void main(String[] args) {
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node hjh = new Node("hjh");

        jack.next = tom;
        tom.next = hjh;
        hjh.pre = tom;
        tom.pre = jack;

        //定义头结点
        Node first = jack;
        //定义尾结点
        Node last = hjh;

        System.out.println("===从头到尾遍历====");
        while (true){
            if (first == null){
                break;
            }
            System.out.println(first);
            first = first.next;
        }
        System.out.println("===从尾到头遍历====");
        while (true){
            if (last == null){
                break;
            }
            System.out.println(last);
            last = last.pre;
        }
        //插入元素
        System.out.println("===插入元素从尾到头遍历====");
        Node rose = new Node("rose");
        jack.next = rose;
        tom.pre = rose;
        rose.pre = jack;
        rose.next = tom;
        //遍历插入元素后
        first = jack;
        while (true){
            if (first == null){
                break;
            }
            System.out.println(first);
            first = first.next;
        }
    }
}

class Node{
    public Object name;
    public Node pre;
    public Node next;


    public Node(Object name) {
        this.name = name;
    }

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

关于LinkedList源码分析

package com.he.list_;

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

/**
 * @author hejh7
 * @date 2022/11/7 0007 12:45
 * @describe
 */
@SuppressWarnings({"all"})
public class LinkedListCRUD {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        //添加
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        list.add(600);
        /**
         * 源码分析
         * 1.初始化空链表
         *  public LinkedList() {}
         * 2.添加方法
         * public boolean add(E e) {
         *         linkLast(e);
         *         return true;
         *     }
         * 3.执行添加元素方法
         * void linkLast(E e) {
         *         final Node<E> l = last;
         *         final Node<E> newNode = new Node<>(l, e, null);
         *         last = newNode;
         *         if (l == null)
         *             first = newNode;
         *         else
         *             l.next = newNode;
         *         size++;
         *         modCount++;
         *     }
         *
         */
        System.out.println("list=" + list);


        // //删除第一个节点
        // list.remove();
        // System.out.println("删除第一个节点list=" + list);
        // //删除指定的元素
        // list.remove(new Integer(200));
        // System.out.println("删除指定的元素list=" + list);
        // //按照索引删除元素
        // list.remove(0);
        // System.out.println("按照索引删除元素list=" + list);
        // //删除第一个元素
        // list.removeFirst();
        // System.out.println("删除第一个元素list=" + list);
        // //删除最后一个元素
        // list.removeLast();
        // System.out.println("删除最后一个元素list=" + list);
        //
        // //修改元素 返回修改的元素
        // System.out.println(list.set(0,666));
        // //查找元素
        // System.out.println( list.get(0));

        System.out.println("====迭代器遍历===");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
        System.out.println("====增强for遍历===");
        for (Object obj : list) {
            System.out.println(obj);
        }
        System.out.println("====普通for遍历===");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

LinkedList和ArrayList的区别

Set接口和常用方法

(1)无序(添加和取出的顺序不一致)，没有索引
(2)不允许元素重复，所以最多包含一个null
(3)JDK API中Set接口的实现类有:

Set接口的遍历方式

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口。
1.可以使用迭代器
2.增强for循环
3.不能使用索引的方式来获取

常用方法示例；

package com.he.set_;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * @author hejh7
 * @date 2022/11/8 0008 11:45
 * @describe
 */
@SuppressWarnings({"all"})
public class SetMethod {
    public static void main(String[] args) {
        // 以Set接口的实现类，HashSet为例
        // Set接口的实现类的对象(Set接口对象)不能存放重复元素
        // 可以添加一个null
        // Set接口对象存放数据、对象是无序的(添加顺序和取出顺序不一致)
        // 取出的顺序是固定的
        Set set = new HashSet();
        set.add("小米");
        set.add("大黑");
        set.add("张三");
        set.add("jankin");
        set.add(null);
        set.add(null);
        for (int i = 0; i < 10; i++) {
            System.out.println(set);
        }
        //遍历
        System.out.println("===迭代器遍历===");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        System.out.println("===增强for循环遍历===");
        for (Object obj : set) {
            System.out.println(obj);
        }
        System.out.println("==================================");
        System.out.println("size=" + set.size());
        System.out.println("是否为空:" + set.isEmpty());
        System.out.println("包含元素张三："+set.contains("张三"));
        System.out.println(set.remove(null));
        System.out.println(set.remove("jankin"));
        System.out.println(set);
    }
}

HashSet的全面说明

(1)HashSet实现了Set接口
(2)HashSet实际上是HashMap
(3)可以存放null值，但是只能有一个null
(4)HashSet不保证元素是有序的，取决于hash后，再确定索引的结果(不保证元素存放和取出顺序一致)
(5)不能有重复元素/对象。在前面Set接口使用已经讲过了

package com.he.set_;

/**
 * @author hejh7
 * @date 2022/11/8 0008 11:54
 * @describe
 */
public class HashSetStructure {
    public static void main(String[] args) {
        // 模拟一个HashSet的底层(其实就是HashMap)
        // 创建一个Node数组,有些人称为table
        Node[] table = new Node[16];
        System.out.println("table=" + table);
        Node jhon = new Node("jhon", null);
        table[2] = jhon;
        System.out.println("table=" + table);

        Node jack = new Node("jack", null);
        jhon.next = jack;

        Node rose = new Node("rose", null);
        jack.next = rose;

        System.out.println("table:" + table);

        Node lucy = new Node("lucy", null);
        table[3] = lucy;
    }
}

class Node {
    Object item;
    Node next;

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

    @Override
    public String toString() {
        return "Node{" +
                "item=" + item + '}';
    }
}

HashSet的底层机制

分析:HashSet底层是HashMap，HashMap底层是(数组+链表+红黑树)
浓缩成6句话

1.HashSet底层是HashMap

2.添加一个元素时，先得到hash值，会转成索引值

3.找到存储数据表table，看这个索引位置是否已经存放的有元素

4.如果没有，直接加入

5.如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后

6.在JAVA 8 中，如果一条链表的元素个数，到达TREEIFY_THRESHOLD(默认是8)，并且table的大小>= MIN_TREEIFY_CAPACITY(默认64)就进行树化(红黑树)

7.不管是数组还是数组中的链表元素个数，只要总数大于临界值 就进行扩容。

源码分析：

package com.he.set_;

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

/**
 * @author hejh7
 * @date 2022/11/9 0009 17:09
 * @describe
 */
@SuppressWarnings({"all"})
public class HashSetResourceCode {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        // hashSet.add("java");
        // hashSet.add("php");
        // hashSet.add("java");

        //演示扩容 添加的元素大于数组临界值12个时候 扩容  数组16 临界值12 --> 数组扩大原来的两倍32 临界值24(数组		大小乘以加载因子0.75) --> 数组64 临界值48。。。。。
        // for (int i = 1; i <= 100; i++) {
        //     hashSet.add(i);
        // }

        //演示链表
        for (int i = 1; i <= 12; i++) {
            hashSet.add(new A(i));
        }

        /**
         * 源码分析：
         *1.初始化HashSet 就是初始化了一个HashMap
         * public HashSet() {
         *         map = new HashMap<>();
         *     }
         * 2添加元素
         * 2.1 调用add()方法   private static final Object PRESENT = new Object();
         * public boolean add(E e) {
         *         return map.put(e, PRESENT)==null;
         *     }
         * 2.2 调用put() 方法 value 就是 new Object()
         *  public V put(K key, V value) {
         *         return putVal(hash(key), key, value, false, true);
         *     }
         * 2.3 调用2,2 中的hash()方法
         * static final int hash(Object key) {
         *         int h;
         *         //返回需要添加元素的hashCode值 h >>> 16标识无符号右移16位
         		  //计算key值的hashCode值   h = key.hashCode()
         		  //key值的hashCode值无符号右移16位 h >>> 16
         		  //1.右移16位是为了让高16位也参与运算，可以更好的均匀散列，减少碰撞，进一步降低hash冲突的几率
				 //2.异或运算是为了更好保留两组32位二进制数中各自的特征
         *         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
         *     }
         * 2.3 调用putVal() 方法
         * final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
         *                    boolean evict) {
         *          //定义辅助变量
         *         Node<K,V>[] tab; Node<K,V> p; int n, i;
         *         //判断数组tab 为null 或者 tab的长度为0 对table进行扩容
         *         //调用resize()方法扩容 这时tab的容量为16 阈值或者叫临界值为 16*0.75(加载因子) = 12
         *         if ((tab = table) == null || (n = tab.length) == 0)
         *             n = (tab = resize()).length;
         *         // (n - 1) & hash 算出 新加入元素的索引位置 并将当前元素再数组中的对象赋值给p
         *         // 表中索引的位置没有元素
         		  //位与运算符为&，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时                      为 1，那么计算结果才为 1，否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。
         *         if ((p = tab[i = (n - 1) & hash]) == null)
         *         //添加元素
         *             tab[i] = newNode(hash, key, value, null);
         *         else {
         *             //定义辅助变量
         *             Node<K,V> e; K k;
         *             //如果当前的hash值和原来元素的hash值相等 且 值也相等 添加失败
         *             if (p.hash == hash &&
         *                 ((k = p.key) == key || (key != null && key.equals(k))))
         *                 e = p;
         *             //添加的元素 是否为 树节点
         *             else if (p instanceof TreeNode)
         *                 //添加树节点
         *                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         *             else {
         *               // 死循环
         *                 for (int binCount = 0; ; ++binCount) {
         *                     //表中的元素和现在添加的元素hashCode一致
         *                     //表中元素的下一个元素为空  新加的元素追加到当前元素的后面
         *                     // 当前节点的下一个元素赋值给e
         *                     if ((e = p.next) == null) {
         *                         p.next = newNode(hash, key, value, null);
         *                         //元素节点的链表达到8个  进行数化  将链表转化为红黑树
         *                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
         *                             treeifyBin(tab, hash);
         *                         break;
         *                     }
         *                     //如果新加的元素和链表中的元素相等 退出
         *                     if (e.hash == hash &&
         *                         ((k = e.key) == key || (key != null && key.equals(k))))
         *                         break;
         *                     // 将e赋值给p  链表后移
         *                     p = e;
         *                 }
         *             }
         *             //元素不为null
         *             if (e != null) { // existing mapping for key
         *                 V oldValue = e.value;
         *                 if (!onlyIfAbsent || oldValue == null)
         *                     e.value = value;
         *                 afterNodeAccess(e);
         *                 //返回原来元素的value 也是是空的Object
         *                 return oldValue;
         *             }
         *         }
         *         //修改次数
         *         ++modCount;
         *         //如果表中的元素个数大于临界值 进行扩容
         *         if (++size > threshold)
         *             resize();
         *         //
         *         afterNodeInsertion(evict);
         *         return null;
         *     }
         *
         */
    }
}

class A {
    int n;

    public A(int n) {
        this.n = n;
    }

    @Override
    public int hashCode() {
        return 100;
    }
}

课堂练习：

package com.he.set_;

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

/**
 * @author hejh7
 * @date 2022/11/10 0010 9:59
 * @describe
 */
@SuppressWarnings({"all"})
public class HashSetExercise {
    public static void main(String[] args) {
        Set hashSet = new HashSet();
        hashSet.add(new Employee("tom",12));
        hashSet.add(new Employee("jack",23));
        hashSet.add(new Employee("tom",12));
        hashSet.add(new Employee("rose",45));
        System.out.println("hashSet=" + hashSet);
    }
}

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 "Employee{" +
                "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);
    }
}

课后练习

package com.he.set_;

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

/**
 * @author hejh7
 * @date 2022/11/10 0010 10:04
 * @describe
 */
@SuppressWarnings({"all"})
public class HashSetExercise1 {
    public static void main(String[] args) {
        Set hashSet = new HashSet();
        hashSet.add(new Employee1("tom",2300f,new MyDate("2020","7","8")));
        hashSet.add(new Employee1("jack",4800f,new MyDate("2021","9","9")));
        hashSet.add(new Employee1("tom",2300f,new MyDate("2020","7","8")));
        hashSet.add(new Employee1("tom",4500f,new MyDate("2020","7","8")));
        System.out.println(hashSet);
    }
}

class Employee1{
    private String name;
    private float salary;
    private MyDate birthday;

    public Employee1(String name, float salary, MyDate birthday) {
        this.name = name;
        this.salary = salary;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public float getSalary() {
        return salary;
    }

    public void setSalary(float salary) {
        this.salary = salary;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

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

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

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

class MyDate{
    private String year;
    private String month;
    private String day;

    public MyDate(String year, String month, String day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public String getYear() {
        return year;
    }

    public void setYear(String year) {
        this.year = year;
    }

    public String getMonth() {
        return month;
    }

    public void setMonth(String month) {
        this.month = month;
    }

    public String getDay() {
        return day;
    }

    public void setDay(String day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year='" + year + '\'' +
                ", month='" + month + '\'' +
                ", day='" + day + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        MyDate myDate = (MyDate) o;
        return Objects.equals(year, myDate.year) && Objects.equals(month, myDate.month) && Objects.equals(day, myDate.day);
    }

    @Override
    public int hashCode() {
        return Objects.hash(year, month, day);
    }
}

LinkedHashSet

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

说明:

在LinkedHashSet中维护一个hash表和双向链表(LinkedHashSet 有head和tail)

每一个结点有before和after属性，这样可以形成双向链表

在添加一个元素时，先求hash值，再求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表(如果已经存在，不添加[原则和hashset一样])

tail.next = newElement
newElement.pre = tail
tail = newElement;

这样的话，我们遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致

package com.he.set_;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

/**
 * @author hejh7
 * @date 2022/11/12 0012 11:12
 * @describe
 */
@SuppressWarnings({"all"})
public class LinkHashSetSource {
    public static void main(String[] args) {
        HashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("tom");
        linkedHashSet.add("123");
        linkedHashSet.add("123");
        linkedHashSet.add("456");
        linkedHashSet.add(new Customer("张三",23));
        linkedHashSet.add("HJH");
        linkedHashSet.add(null);
        linkedHashSet.add(null);
        Iterator iterator = linkedHashSet.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj==" + obj);
        }

        //源码解读
        //1.LinkedHashSet 加入顺序和取出元素/数据的顺序一致
        //2.LinkedHashSet 底层维护的是一个LinkedHashMap（是HashMap的子类）
        //3.LinkedHashSet 底层结构（数组table + 双向链表）
        //4.LinkedHashSet 第一次添加元素时 直接将数组table 扩容到16 存放的节点类型是 LinkedHashMap$Entry
        //5.数组是 HashMap$Node[] 存放的元素/数组时 LinkedHashMap$Entry
    }
}

class Customer{
    private String name;
    private int 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;
    }

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

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

练习

equals和hashCode重写

package com.he.set_;

import java.util.LinkedHashSet;
import java.util.Objects;

/**
 * @author hejh7
 * @date 2022/11/12 0012 11:35
 * @describe
 */
@SuppressWarnings({"all"})
public class LinkedHashSetExercise {
    public static void main(String[] args) {
        //对象如何没有重新 hashCode() 和 equals() 方法 会添加相同的对象 两者缺一不可
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new Car("奥拓",1000));
        linkedHashSet.add(new Car("奥迪",300000));
        linkedHashSet.add(new Car("法拉利",200000));
        linkedHashSet.add(new Car("奥拓",1000));
        linkedHashSet.add(new Car("保时捷",7000000));
        linkedHashSet.add(new Car("奥拓",1000));
        System.out.println(linkedHashSet);

    }
}

class Car{
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

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

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
    }

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

TreeSet

TreeSet含Comparator构造器

package com.he.set_;

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

/**
 * @author hejh7
 * @date 2022/11/19 0019 11:48
 * @describe
 */
@SuppressWarnings({"all"})
public class TreeSet_ {
    public static void main(String[] args) {
        //当使用无参构造器创建TreeSet的时候是无序的
        TreeSet treeSet = new TreeSet();
        treeSet.add("tom");
        treeSet.add("jack");
        treeSet.add("smith");
        treeSet.add("jankinHe");
        treeSet.add("aine");
        System.out.println("treeSet=" + treeSet);

        System.out.println("---按照字符串首字母的顺序进行排序---");
        //可以传入一个比较器（匿名内部类） 并指定规则
        //如何字符串里面既有大写又有小写  先排序大写 再排序小写
        TreeSet treeSet1 = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String) o1).compareTo((String) o2);
            }
        });
        treeSet1.add("tom");
        treeSet1.add("milan");
        treeSet1.add("smith");
        treeSet1.add("JankinHe");
        treeSet1.add("aine");
        treeSet1.add("Sdd");
        System.out.println("treeSet1=" + treeSet1);


        System.out.println("---按照字符串长度进行排序 长度相同加不进入---");
        //可以传入一个比较器（匿名内部类） 并指定规则
        TreeSet treeSet2 = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        treeSet2.add("tom");
        treeSet2.add("milan");
        treeSet2.add("smith");
        treeSet2.add("JankinHe");
        treeSet2.add("aine");
        treeSet2.add("Sdd");
        System.out.println("treeSet2=" + treeSet2);
        /**
         * 源码：
         * 1.构造器把传入的比较器对象 赋值给 TreeSet的底层的 TreeMap的属性 this.comparator
         * public TreeMap(Comparator<? super K> comparator) {
         *         this.comparator = comparator;
         *     }
         * 2.调用add
         * public boolean add(E e) {
         *         return m.put(e, PRESENT)==null;
         *     }
         * 3.调用 put
         * public V put(K key, V value) {
         *         Entry<K,V> t = root;
         *         //第一次添加执行
         *         if (t == null) {
         *             compare(key, key); // type (and possibly null) check
         *
         *             root = new Entry<>(key, value, null);
         *             size = 1;
         *             modCount++;
         *             return null;
         *         }
         *         int cmp;
         *         Entry<K,V> parent;
         *         // split comparator and comparable paths
         *         Comparator<? super K> cpr = comparator;
         *         //第二次添加执行 
         *         if (cpr != null) {
         *             do {
         *                 parent = t;
         *                 cmp = cpr.compare(key, t.key);
         *                 if (cmp < 0)
         *                     t = t.left;
         *                 else if (cmp > 0)
         *                     t = t.right;
         *                 else
         *                     return t.setValue(value);
         *             } while (t != null);
         *         }
         *         else {
         *             if (key == null)
         *                 throw new NullPointerException();
         *             @SuppressWarnings("unchecked")
         *                 Comparable<? super K> k = (Comparable<? super K>) key;
         *             do {
         *                 parent = t;
         *                 cmp = k.compareTo(t.key);
         *                 if (cmp < 0)
         *                     t = t.left;
         *                 else if (cmp > 0)
         *                     t = t.right;
         *                 else
         *                     return t.setValue(value);
         *             } while (t != null);
         *         }
         *         Entry<K,V> e = new Entry<>(key, value, parent);
         *         if (cmp < 0)
         *             parent.left = e;
         *         else
         *             parent.right = e;
         *         fixAfterInsertion(e);
         *         size++;
         *         modCount++;
         *         return null;
         *     }
         */

    }
}

Map集合

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类作为Map的key

(7)key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value

package com.he.map_;

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

/**
 * @author hejh7
 * @date 2022/11/15 0015 13:16
 * @describe
 */
@SuppressWarnings({"all"})
public class MapTest {
    public static void main(String[] args) {
        // (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类作为Map的key
        // (7)key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
        Map hashMap = new HashMap();
        hashMap.put("hjh","18");
        hashMap.put("hjh",24);//key 相同 替换对用的value
        hashMap.put("小明",24);
        hashMap.put("tom",24);
        hashMap.put(null,null);
        hashMap.put(null,null);
        hashMap.put("no",null);
        System.out.println(hashMap.get("hjh"));
        System.out.println("hashMap=" + hashMap);
    }
}

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

package com.he.map_;

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

/**
 * @author hejh7
 * @date 2022/11/15 0015 13:24
 * @describe
 */
@SuppressWarnings({"all"})
public class MapSource_ {
    public static void main(String[] args) {
        Map hashMap = new HashMap();
        hashMap.put("no1","张无忌");
        hashMap.put("no2","金毛狮王");
        hashMap.put("dog",new Dog());
        //源码解读
        /**
         * 1 k-v 最后是 HashMap$Node node = newNode(hash,key,value,null)
         * 2.k-v 为了方便程序员遍历，还会 创建 EntrySet集合 该集合存放的元素的类型 Entry ，
         *      而一个Entey对象就有k,v EntrySet<Entry<k,v>> 即 transient Set<Map.Entry<k,v>> entrySet;
         *  3.entrySet中 定义的类型是Map.Entry 但是实际上存放的还是 HashMap$Node
         *  这是因为 static class Node<K,V> implements Map.Entry<k,V>;
         *  4.当把HashMap$node 对象存放到entrySet 就方便我们遍历 因为 Map.Entry 提供了重要的方法 K getKey(); V getvalue();
         *  
         */

        Set set = hashMap.entrySet();
        System.out.println(set.getClass());//class java.util.HashMap$EntrySet
        for (Object obj : set) {
            //System.out.println(obj.getClass());//class java.util.HashMap$Node
            //为了从HashMap$Node 取出k-v
            //先做一个向下转型
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }

    }
}

class Dog{

}

Map的常用方法

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

package com.he.map_;

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

/**
 * @author hejh7
 * @date 2022/11/15 0015 13:44
 * @describe
 */
@SuppressWarnings({"all"})
public class MapMethod {
    public static void main(String[] args) {
        // (1)put:添加
        // (2)remove:根据键删除映射关系
        // (3)get：根据键获取值
        // (4)size：获取元素个数
        // (5)isEmpty:判断个数是否为0
        // (6)clear:清除
        // (7)containsKey：查找键是否存在
        Map hashMap = new HashMap();
        hashMap.put("邓超","孙俪");
        hashMap.put("王宝强","马蓉");
        hashMap.put("宋喆","马蓉");
        hashMap.put("鹿晗","关晓彤");
        hashMap.put("刘亦菲",null);
        System.out.println("map=" + hashMap);
        Object remove = hashMap.remove("宋喆");
        System.out.println(remove);
        System.out.println("map=" + hashMap);
        System.out.println(hashMap.size());
        System.out.println(hashMap.isEmpty());
        System.out.println(hashMap.containsKey("hjh"));
        System.out.println(hashMap.containsKey("刘亦菲"));
        hashMap.clear();
        System.out.println("map=" + hashMap);
    }
}

Map接口遍历方法

Map遍历的示意图(比List，和Set复杂一点，但是基本原理一样)
(1)containsKey：查找键是否存在

(2)keySet：获取所有的键

(3)values：获取所有的值

(4)entrySet：获取所有关系

package com.he.map_;

import java.util.*;

/**
 * @author hejh7
 * @date 2022/11/15 0015 17:43
 * @describe
 */
@SuppressWarnings({"all"})
public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("天龙八部","乔峰");
        map.put("倚天同龙记","张无忌");
        map.put("亮剑","李云龙");
        map.put("打狗棍","戴天理");
        map.put("刘亦菲",null);
        map.put(null,null);

        // **(1)containsKey：查找键是否存在**
        //
        // **(2)keySet：获取所有的键**
        //
        // **(3)values：获取所有的值**
        //
        // **(4)entrySet：获取所有关系**
        System.out.println("---------keySet  先获取键  在获取值--------------");
        System.out.println("-----增强for循环----");
        Set set = map.keySet();
        for (Object key : set) {
            System.out.println(key + "-" + map.get(key));
        }
        System.out.println("-----迭代器----");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key + "-" + map.get(key));
        }

        System.out.println("----------values：获取所有的值---------");
        System.out.println("-----增强for循环----");
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }
        System.out.println("-----迭代器----");
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object next = iterator1.next();
            System.out.println(next);
        }

        System.out.println("----------entrySet：获取所有关系---------");
        Set entrySet = map.entrySet();
        System.out.println("-----增强for循环----");
        for (Object obj : entrySet) {
            //System.out.println(obj.getClass());
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+"-" + entry.getValue());
        }
        System.out.println("-----迭代器----");
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()) {
            Object next = iterator2.next();
            Map.Entry entry = (Map.Entry) next;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

    }
}

课后练习

package com.he.map_;
import java.util.*;

/**
 * @author hejh7
 * @date 2022/11/15 0015 18:00
 * @describe
 */
@SuppressWarnings({"all"})
public class MapExercise {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(1,new Employee("tom",1,13000));
        map.put(2,new Employee("jack",2,28000));
        map.put(3,new Employee("rose",3,36000));
        map.put(4,new Employee("john",4,26000));
        map.put(5,new Employee("lucy",5,17000));

        //显示工资大于18000的
        Set set = map.keySet();
        System.out.println("------第一种遍历------");
        for (Object key : set) {
            Employee employee = (Employee) map.get(key);
            if (employee.getSalary() > 18000){
                System.out.println(key+"-"+employee);
            }
        }
        System.out.println("------第二种遍历------");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            Employee employee = (Employee) map.get(key);
            if (employee.getSalary()>18000){
                System.out.println(key+"-"+employee);
            }
        }
        System.out.println("------第三种遍历------");
        Set entrySet = map.entrySet();
        for (Object obj : entrySet) {
            Map.Entry entry = (Map.Entry) obj;
            Object key = entry.getKey();
            Employee employee  = (Employee) entry.getValue();
            if (employee.getSalary() > 18000){
                System.out.println(key+"-"+employee);
            }
        }
        System.out.println("------第四种遍历------");
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()) {
            Object next = iterator1.next();
            Map.Entry entry = (Map.Entry) next;
            Object key = entry.getKey();
            Employee employee  = (Employee) entry.getValue();
            if (employee.getSalary() > 18000){
                System.out.println(key+"-"+employee);
            }
        }

    }
}

class Employee {
    private String name;
    private int id;
    private double salary;

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

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

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

HashMap小结

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

HashMap底层机制以及源码剖析

1. HashMap底层维护了Node类型的数组table，默认为null
2. 当创建对象时，将加载因子(loadFactor)初始化为0.75
3. 当添加key-value时，通过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)，就会进行树化(红黑树)

package com.he.map_;

import java.util.HashMap;

/**
 * @author hejh7
 * @date 2022/11/16 0016 12:27
 * @describe
 */
@SuppressWarnings({"all"})
public class MapSource1 {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("java",10);
        hashMap.put("java",20);
        hashMap.put("php",10);

        System.out.println("hashMap=" + hashMap);
        /**
         * 源码分析：
         * 1.初始化HashMap 加载因子loadFactor=0.75 底层数组表为null
         * public HashMap() {
         *     this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
         *     }
         * 2.执行put方法
         * public V put(K key, V value) {
         *         return putVal(hash(key), key, value, false, true);
         *     }
         * 3.执行执行hash(key) 返回当前节点key的hash值  (h = key.hashCode()) ^ (h >>> 16);
         * static final int hash(Object key) {
         *         int h;
         *         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
         *     }
         * 4.执行putVal方法
         *  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
         *                    boolean evict) {
         *         //辅助变量
         *         Node<K,V>[] tab; Node<K,V> p; int n, i;
         *         //如果table为null 或者 tab.length 为0 进行扩容
         *         if ((tab = table) == null || (n = tab.length) == 0)
         *         //第一次扩容核心代码
         *          //表的大小设置为16
         *          //newCap = DEFAULT_INITIAL_CAPACITY;
         *         //表的临界值为12（16*0.75）
         *         //newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
         *             n = (tab = resize()).length;
         *         if ((p = tab[i = (n - 1) & hash]) == null)
         *         //如何添加节点的key的hash值对应的table中的索引位置节点为null 直接添加到对应的位置
         *             tab[i] = newNode(hash, key, value, null);
         *         else {
         *             //辅助变量
         *             Node<K,V> e; K k;
         *             //如果新添加的k-v的在table表中索引对应的位置有值并且hash相等 key相等 则跳到下一步 替换的位置
         *             if (p.hash == hash &&
         *                 ((k = p.key) == key || (key != null && key.equals(k))))
         *                 e = p;
         *             //如果添加的k-v 是红黑树 则按照红黑树的方法进行添加
         *             else if (p instanceof TreeNode)
         *                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         *             else {
         *             //新添加的节点key的hash计算出表中的索引位置有值且不相等 执行下面
         *             //也就是在链表中添加节点
         *
         *                 for (int binCount = 0; ; ++binCount) {//死循环
         *                     if ((e = p.next) == null) {
         *                        //原来节点的下一个为null 直接添加
         *                         p.next = newNode(hash, key, value, null);
         *                         //添加完成后 判断链表的节点数是否到达8个 到达后调用树化方法将链表转换为红黑树
         *                         if (binCount >= TREEIFY_THRESHOLD - 1) // TREEIFY_THRESHOLD=8
         *                            //树化方法还会判断当前表的大小师傅到达64  没有则不会树化 而是对表进行扩容
         *                            //核心代码如下
         *                                //final void treeifyBin(Node<K,V>[] tab, int hash) {
         *                                //     int n, index; Node<K,V> e;
         *                                //          MIN_TREEIFY_CAPACITY = 64
         *                                //     if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
         *                                //           resize();
         *                             treeifyBin(tab, hash);
         *                         break;
         *                     }
         *                     //如何添加的元素节点和链表中的节点相等 则链表后移 继续进行比较
         *                     if (e.hash == hash &&
         *                         ((k = e.key) == key || (key != null && key.equals(k))))
         *                         break;
         *                     p = e;
         *                 }
         *             }
         *             if (e != null) {
         *                 V oldValue = e.value;
         *                 //如果原来元素节点的key对应value不为空 则替换原来的value为当前的value
         *                 if (!onlyIfAbsent || oldValue == null)
         *                     e.value = value;
         *                 afterNodeAccess(e);
         *                 return oldValue;
         *             }
         *         }
         *         //每次添加成功++
         *         ++modCount;
         *         //添加完成后判断元素的个数是否大于临界值 大于进行扩容
         *         if (++size > threshold)
         *             resize();
         *         afterNodeInsertion(evict);
         *         return null;
         *     }
         *
         */

    }
}

触发树化测试（链表元素到达8个 且表的大小扩容到64）

package com.he.map_;

import java.util.HashMap;
import java.util.Objects;

/**
 * @author hejh7
 * @date 2022/11/16 0016 13:02
 * @describe
 */
@SuppressWarnings({"all"})
public class MapSource2 {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        for (int i = 1; i <= 12; i++) {
            hashMap.put(new A(i),"hello");
        }
    }
}

class A {
    private int num;

    public A(int num) {
        this.num = num;
    }

    @Override
    public int hashCode() {
        return 100;
    }
}

Map接口实现类-Hashtable

1. 存放的元素是键值对:即K-V
2. hashtable的键和值都不能为null，否则会抛出NullPointerException
3. hashTable使用方法基本上和HashMap一样
4. hashTable是线程安全的(synchronized)，hashMap是线程不安全的
5. 实现Map接口

注意:

1. 底层有数组 Hashtable$Entry[] 初始化大小为11
2. 临界值 threshold = 11 * 0.75 ≈ 8
3. 扩容:按照自己的扩容机制来进行
4. 执行方法 addEntry(hash, key, value, index); 添加键值对，封装到Entry

package com.he.map_;

import java.util.Hashtable;

/**
 * @author hejh7
 * @date 2022/11/18 0018 9:38
 * @describe
 */
@SuppressWarnings({"all"})
public class Hashtable_ {
    public static void main(String[] args) {
        Hashtable hashtable = new Hashtable();
        //hashtable.put(null,null); //java.lang.NullPointerException
        //hashtable.put(123,null); //java.lang.NullPointerException
        //hashtable.put(null,456); //java.lang.NullPointerException
        hashtable.put("tom",23);
        hashtable.put("rose",18);
        hashtable.put("john",66);
        hashtable.put("john",27);
        System.out.println("hashtable=" + hashtable);
        // 1. 存放的元素是键值对:即K-V
        // 2. **hashtable的键和值都不能为null**，否则会抛出NullPointerException
        // 3. hashTable使用方法基本上和HashMap一样
        // 4. **hashTable是线程安全的**(synchronized)，**hashMap是线程不安全的**
        // 5. 实现Map接口
        // 6 扩容机制 Hashtable$Entry[] 初始化大小为11  threshold = 11 * 0.75 ≈ 8
        //扩容是原来数组的2倍加1
    }
}

Hashtable和HashMap对比

名称	版本	线程安全	效率	允许null键null值
HashMap	1.2	不安全	高	可以
Hashtable	1.0	安全	较低	不可以

Properties

基本介绍

1. Properties类继承自Hashtable类并且实现了Map接口，也是一种键值对的形式来保存数据。
2. 它的使用特点和Hashtable类似。
3. Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改。
4. 文章链接：https://www.cnblogs.com/xudong-bupt/p/3758136.html

基本用法：

package com.he.map_;

import java.util.Properties;

/**
 * @author hejh7
 * @date 2022/11/18 0018 9:29
 * @describe
 */
@SuppressWarnings({"all"})
public class Properties_ {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //添加元素 键和值都不能为空 否则空指针异常
        //properties.put(null,null);  //java.lang.NullPointerException
        //properties.put(null,"123");   //java.lang.NullPointerException
        //properties.put(123,null); //java.lang.NullPointerException
        properties.put("john",100);
        properties.put("tom",23);
        properties.put("rose",88);
        properties.put("john",200);//替换

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

        //删除
        properties.remove("tom");
        System.out.println("删除后properties=" + properties);

        //获取
        System.out.println(properties.get("rose"));

        //修改
        properties.setProperty("rose","66");
        System.out.println("修改后properties=" + properties);
    }
}

说明:工作后xxx.properties文件通常作为配置文件，这个知识点在IO流举例，有兴趣可先看文章。

配置文件不会显示乱码，统一调整为UTF-8

res.properties

name=root
key=value
pass=liu

package com.he.map_;

import java.io.*;
import java.util.Properties;
import java.util.Set;

/**
 * @author hejh7
 * @date 2022/11/18 0018 9:50
 * @describe
 */
@SuppressWarnings({"all"})
public class PropertiesTest {
    public static void main(String[] args) {
        Properties properties = new Properties();
        String path = "src/res.properties";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            //获取
            bufferedReader = new BufferedReader(new FileReader(path));
            properties.load(bufferedReader);
            Set<Object> keys = properties.keySet();
            for (Object key : keys) {
                System.out.println(key + "---" + properties.getProperty((String) key));
            }
            //写入
            bufferedWriter = new BufferedWriter(new FileWriter(path));
            properties.setProperty("tom","23");
            properties.setProperty("john","约翰");
            properties.store(bufferedWriter,"这是新写入的！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

TreeMap

package com.he.map_;

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

/**
 * @author hejh7
 * @date 2022/11/19 0019 12:13
 * @describe
 */
@SuppressWarnings({"all"})
public class TreeMap_ {
    public static void main(String[] args) {
        //无参构造 无序
        TreeMap treeMap = new TreeMap();
        treeMap.put("tom","汤姆");
        treeMap.put("jack","杰克");
        treeMap.put("lucy","露丝");
        treeMap.put("milan","米兰");
        treeMap.put("jankin","大神");
        System.out.println("TreeMap=" + treeMap);

        System.out.println("===按照key的首字母顺序排序===");
        TreeMap treeMap1 = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).compareTo(((String)o2));
            }
        });
        treeMap1.put("tom","汤姆");
        treeMap1.put("jack","杰克");
        treeMap1.put("lucy","露丝");
        treeMap1.put("milan","米兰");
        treeMap1.put("jankin","大神");
        System.out.println("treeMap1=" + treeMap1);

        System.out.println("===按照key的长度排序===");
        TreeMap treeMap2 = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length()-(((String)o2)).length();
            }
        });
        treeMap2.put("tom","汤姆");
        treeMap2.put("jack","杰克");
        treeMap2.put("lucy","露丝");//key相同 会替换原来形同长度key对应的value
        treeMap2.put("milan","米兰");
        treeMap2.put("jankin","大神");
        System.out.println("treeMap2=" + treeMap2);
    }
}

集合选型

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

(1)先判断存储类型(一组对象(单列)或者键值对(双列))
(2)一组对象: Collection接口
允许重复:List
增删多:LinkedList(底层是双向链表)
查改多:ArrayList(底层维护Object类型的可变数组)
不允许重复:Set
无序:HashSet底层是HashMap，维护一个Hash表(数组+链表+红黑树)
排序:TreeSet
插入和取出顺序一样: LinkedHashSet(继承自LinkedHashMap)，维护数组+双向链表
(3)键值对:Map
键无序:HashMap(底层是:哈希表:数组+链表+红黑树)
键有序:TreeMap
键插入和取出顺序一致:LinkedHashMap(继承自HashMap)
读取文件: Properties

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处元素进行交换

package com.he.collections_;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * @author hejh7
 * @date 2022/11/19 0019 12:24
 * @describe
 */
@SuppressWarnings({"all"})
public class Collections_ {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("tom");
        arrayList.add("hjh");
        arrayList.add("rose");
        arrayList.add("smith");
        arrayList.add("jankinHe");
        System.out.println("arrayList=" + arrayList);
        // 1. reverse(List):反转List中元素的顺序
        Collections.reverse(arrayList);
        System.out.println("反转List中元素的顺序"+ arrayList);
        // 2. shuffle(List):对List集合元素进行随机排序
        // for (int i = 0; i < 5; i++) {
        //     Collections.shuffle(arrayList);
        //     System.out.println("对List集合元素进行随机排序"+ arrayList);
        // }
        // 3. sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
        Collections.sort(arrayList);
        System.out.println("根据元素的自然顺序对指定List集合元素按升序排序"+ arrayList);
        // 4. sort(List,Comparator):根据指定的Comparator产生的顺序对List集合进行排序
        Collections.sort(arrayList, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
              if (o1 instanceof String && o2 instanceof String){
                  String str1 = (String) o1;
                  String str2 = (String) o2;

                  int len1 = str1.length();
                  int len2 = str2.length();
                  //自定义比较规则 长度排序（由短到长） 长度相同按照首字符顺序排序
                  int res = (len1 == len2 ? str1.compareTo(str2): len1-len2);
                  return res;
              }else {
                  return 0;
              }
            }
        });
        System.out.println("根据指定的Comparator产生的顺序对List集合进行排序"+ arrayList);
        // 5. swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换

        Collections.swap(arrayList,1,2);
        System.out.println("将指定list集合中的i处元素和j处元素进行交换"+ arrayList);

    }
}

查找和替换

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

package com.he.collections_;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;

/**
 * @author hejh7
 * @date 2022/11/19 0019 12:37
 * @describe
 */
@SuppressWarnings({"all"})
public class CollectionsTest {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("tom");
        arrayList.add("hjh");
        arrayList.add("rose");
        arrayList.add("jankinHe");
        arrayList.add("smith");
        System.out.println("arrayList=" + arrayList);
        // 1. Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素

        System.out.println("根据元素的自然顺序，返回给定集合中的最大元素=" +  Collections.max(arrayList));
        // 2. Object max(Collection, Comparator):根据Compartor指定的顺序，返回给定集合中的最大元素
        Object max = Collections.max(arrayList, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof String && o2 instanceof String) {

                    String str_o1 = (String) o1;
                    String str_o2 = (String) o2;

                    int a = str_o1.length();
                    int b = str_o2.length();

                    int result = a == b ? str_o1.compareTo(str_o2) : a - b;
                    return result;
                } else {
                    return 0;
                }
            }
        });
        System.out.println("根据Compartor指定的顺序，返回给定集合中的最大元素=" + max);
        // 3. Object (Collection)
        System.out.println("根据元素的自然顺序，返回给定集合中的最小元素=" +  Collections.min(arrayList));
        // 4. Object min(Collection, Object)
        Object min = Collections.min(arrayList, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof String && o2 instanceof String) {

                    String str_o1 = (String) o1;
                    String str_o2 = (String) o2;

                    int a = str_o1.length();
                    int b = str_o2.length();

                    int result = a == b ? str_o1.compareTo(str_o2) : a - b;
                    return result;
                } else {
                    return 0;
                }
            }
        });
        System.out.println("根据Compartor指定的顺序，返回给定集合中的最小元素=" + min);
        // 5. int frequency(Collection， Object):返回指定集合中指定元素的出现次数
        int tom = Collections.frequency(arrayList, "tom");
        System.out.println("返回指定集合中指定元素的出现次数" + tom);
        // 6. void copy(List dest, List src):将src中的内容复制到dest中
        // 拷贝要注意 ，拷贝后的集合dest的元素个数要 >= 被拷贝集合arrayList
        //一般情况在初始化dest指定大小和arrayList相同
        //ArrayList dest = new ArrayList(); // java.lang.IndexOutOfBoundsException
        ArrayList dest = new ArrayList();
        for (int i = 0; i < arrayList.size(); i++) {
            dest.add(i);
        }
        Collections.copy(dest,arrayList);
        System.out.println("dest=" + dest);
        // 7. boolean replaceAll(List list, Object oldVal, Object newVal):使用新值替换List对象的所有旧值
        Collections.replaceAll(dest,"tom","zs");
        System.out.println("dest=" + dest);

    }
}

课后作业

课后作业1

package com.he.homework;

import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Collections;

/**
 * @author hejh7
 * @date 2022/11/19 0019 13:07
 * @describe
 */
@SuppressWarnings({"all"})
public class HomeWork1 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new News("新冠确诊病例超千万，数百万印度教徒赴恒河'圣浴'引民众担忧。"));
        arrayList.add(new News("男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生。"));
        System.out.println("----倒序遍历----");
        int size = arrayList.size();
        for (int i = size-1; i >= 0; i--) {
            News news = (News) arrayList.get(i);
            System.out.println(processTitle(news.getTitle()));
        }
        // Collections.reverse(arrayList);
        // System.out.println("arrayList=" + arrayList);
        // for (Object obj : arrayList) {
        //     News news = (News) obj;
        //     if (news.getContent().length()>=15){
        //         news.setContent(news.getContent().substring(0,15) + "...");
        //     }
        //     System.out.println(news.getContent());
        // }

    }
    public static String processTitle(String title){
        if (title == null){
            return null;
        }
        if (title.length() > 15){
            return title.substring(0,15) + "...";
        }else {
            return title;
        }
    }
}

class News{
    private String title;
    private String content;

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

    public String getTitle() {
        return title;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

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

课后作业2

package com.he.homework;

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

/**
 * @author hejh7
 * @date 2022/11/19 0019 17:47
 * @describe
 */
@SuppressWarnings({"all"})
public class HomeWork2 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        //添加元素
        Car car1 = new Car("桑塔纳", 78000);
        Car car2 = new Car("奔驰",450000);
        Car car3 = new Car("宝来",120000);
        Car car4 = new Car("保时捷卡宴",1160000);
        Car car5 = new Car("面包车",66000);
        arrayList.add(car1);
        arrayList.add(car2);
        arrayList.add(car3);
        arrayList.add(car4);
        arrayList.add(car5);
        System.out.println("---arrayList增强for循环遍历---");
        for (Object obj : arrayList) {
            System.out.println(obj);
        }
        System.out.println("---arrayList迭代器遍历---");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println("arrayList集合元素个数为："+ arrayList.size());
        System.out.println("arrayList集合是否为空："+ arrayList.isEmpty());
        //查找元素是否存在
        System.out.println("arrayList元素car1是否存在："+arrayList.contains(car1));
        System.out.println("arrayList删除元素car1："+arrayList.remove(car1));
        arrayList.clear();
        System.out.println("arrayList清空集合元素后" + arrayList);

        ArrayList arrayList1 = new ArrayList();
        Car c1 = new Car("宝马",450000);
        Car c2 = new Car("宾利",5000000);
        arrayList1.add(c1);
        arrayList1.add(c2);
        arrayList.addAll(arrayList1);
        System.out.println("arrayList添加多个元素后" + arrayList);
        System.out.println("arrayList查找多个元素是否存在" + arrayList.containsAll(arrayList1));
        arrayList.removeAll(arrayList1);
        System.out.println("arrayList删除多个元素后" + arrayList);

        System.out.println("arrayList集合元素个数为："+ arrayList.size());
        System.out.println("arrayList集合是否为空："+ arrayList.isEmpty());



    }
}

class Car{
    private String name;
    private Integer price;

    public String getName() {
        return name;
    }

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

    public Integer getPrice() {
        return price;
    }

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

    public Car(String name, Integer price) {
        this.name = name;
        this.price = price;
    }

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

课后作业3

package com.he.homework;

import java.util.*;

/**
 * @author hejh7
 * @date 2022/11/19 0019 18:13
 * @describe
 */
@SuppressWarnings({"all"})
public class HomeWork3 {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("jack",650);
        hashMap.put("tom",1200);
        hashMap.put("smith",2900);
        System.out.println("hashMap=" + hashMap);
        //将jack的工资更改为2600
        System.out.println("---将jack的工资更改为2600---");
        hashMap.put("jack",2600);
        System.out.println("hashMap=" + hashMap);

        //遍历所有的员工
        System.out.println("---遍历所有的员工 方法1---");
        Set set = hashMap.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Map.Entry entry =  (Map.Entry)iterator.next();
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }

        System.out.println("---遍历所有的员工 方法2---");
        Set set2 = hashMap.keySet();
        for (Object key : set2) {
            System.out.println(key+"---"+hashMap.get(key));
        }

        System.out.println("---遍历所有的工资---");
        //遍历所有的工资
        Collection values = hashMap.values();
        for (Object value : values) {
            System.out.println("员工工资：" + value);
        }

        System.out.println("---为所有的员工加薪100---");
        //为所有的员工加薪100
        Set set1 = hashMap.keySet();
        for (Object obj : set1) {
            hashMap.put(obj,((Integer)hashMap.get(obj))+100);
            System.out.println("员工工资：" + hashMap.get(obj));
        }

    }
}

课后作业4

试分析HashSet和TreeSet分别是如何实现去重的

1. HashSet的去重机制:hashCode() + equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals比较[遍历比较]，如果比较后不相同就加入，否则就不加入。
2. TreeSet的去重机制:如果你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0,就认为是相同的元素/数据，就不添加; 如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Comparator接口的compareTo去重。

课后作业5

package com.he.homework;

import java.util.TreeSet;
import java.util.concurrent.TransferQueue;

/**
 * @author hejh7
 * @date 2022/11/19 0019 18:44
 * @describe
 */
@SuppressWarnings({"all"})
public class HomeWork05 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Person()); java.lang.ClassCastException 报错
        System.out.println(treeSet);
        // 错误原因:treeSet在add时候会执行
        /**
         *     final int compare(Object var1, Object var2) {
         *         return this.comparator == null ? ((Comparable)var1).compareTo(var2) : this.comparator.compare(var1, var2);
         *     }
         *
         *     会把加入的元素var1 转换成(Comparable) 对象，所以Person必须实现Comparable接口才行
         */
    }
}

class Person implements Comparable{// 实现之后再添加就不会报错了
    /**
     *TreeSet的去重机制:如果你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0,
     * 就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，
     * 则以你添加的对象实现的Comparator接口的compareTo去重。
     *     final int compare(Object var1, Object var2) {
     *         return this.comparator == null ? ((Comparable)var1).compareTo(var2) : this.comparator.compare(var1, var2);
     *     }
     */
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}

课后作业6

package com.he.homework;

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

/**
 * @author hejh7
 * @date 2022/11/19 0019 18:48
 * @describe
 */
@SuppressWarnings({"all"})
public class HomeWork06 {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        Person1 p1 = new Person1(1001, "AA");
        Person1 p2 = new Person1(1002, "BB");
        hashSet.add(p1);
        hashSet.add(p2);
        System.out.println("hashSet=" + hashSet);
        p1.setName("CC");
        //删除的时候也会根据id和name找元素的位置 因为1001的name已经改变 所以找到的位置没有p1 删除失败
        hashSet.remove(p1);
        System.out.println("hashSet=" + hashSet);
        hashSet.add(new Person1(1001,"CC"));
        System.out.println("hashSet=" + hashSet);
        hashSet.add(new Person1(1001,"AA"));
        System.out.println("hashSet=" + hashSet);
    }
}
class Person1{
    private int id;
    private String name;

    public Person1(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

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

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

思维导图地址：

思维导图

思维导图：