关于java:Java-Collection与Map详解

文章和代码曾经归档至【Github 仓库：https://github.com/timerring/java-tutorial】或者公众号【AIShareLab】回复 java 也可获取。

后面咱们保留多个数据应用的是数组，那么数组有有余的中央，咱们剖析一下

1)长度开始时必须指定，而且一旦指定，不能更改

2)保留的必须为同一类型的元素

3)应用数组进行减少 / 删除元素比拟麻烦

eg: 写出 Person 数组扩容示意代码。

Person[] pers = new Person[1]; // 大小是 1
per[0] = new Person();  
// 减少新的 Person 对象?
Person[] pers2 = new Person[pers.length+1];// 新创建数组
for(){} // 拷贝 pers 数组的元素到 per2
pers2[pers2.length-1] = new Person():// 增加新的对象

1)能够动静保留任意多个对象，应用比拟不便

2)提供了一系列不便的操作对象的办法: add、remove、set、get 等

3)应用汇合增加 / 删除新元素简洁了

Java 的汇合类很多，次要分为两大类，如图!

汇合次要是两组(单列汇合, 双列汇合)
Collection 接口有两个重要的子接口 List Set , 他们的实现子类都是单列汇合（单列数据）
Map 接口的实现子类是双列汇合，寄存的 K -V（双列数据）

package com.hspedu.collection_;

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

public class Collection_ {@SuppressWarnings({"all"})
    public static void main(String[] args) {
        //Collection
        //Map
        ArrayList arrayList = new ArrayList();
        arrayList.add("jack");
        arrayList.add("tom");

        HashMap hashMap = new HashMap();
        hashMap.put("NO1", "北京");
        hashMap.put("NO2", "上海");
    }
}

public interface Collection <E> extends lterable <E>

1) collection 实现子类能够寄存多个元素，每个元素能够是 Object
2) 有些 Collection 的实现类, 能够寄存反复的元素, 有些不能够
3) 有些 Collection 的实现类，有些是有序的(List)，有些不是有序(Set)
4) Collection 接口没有间接的实现子类，是通过它的子接口 Set 和 List 来实现的

package com.hspedu.collection_;

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

public class CollectionMethod {@SuppressWarnings({"all"})
    public static void main(String[] args) {List list = new ArrayList();
//        add: 增加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10)) 实质是对象
        list.add(true);
        System.out.println("list=" + list);
//        remove: 删除指定元素
        list.remove(0);// 删除第一个元素 返回 boolen
        list.remove(true);// 指定删除某个元素 返回该 obj
        System.out.println("list=" + list);
//        contains: 查找元素是否存在
        System.out.println(list.contains("jack"));//T
//        size: 获取元素个数
        System.out.println(list.size());//2
//        isEmpty: 判断是否为空
        System.out.println(list.isEmpty());//F
//        clear: 清空
        list.clear();
        System.out.println("list=" + list);
//        addAll: 增加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);
//        containsAll: 查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//T
//        removeAll：删除多个元素
        list.add("聊斋");
        list2.add("工夫是金");
        list.removeAll(list2);
        System.out.println("list=" + list);//[聊斋]
//        阐明：以 ArrayList 实现类来演示.
    }
}

Iterator 对象称为迭代器，次要用于遍历 Collection 汇合中的元素。
所有实现了 Collection 接口的汇合类都有一个 iterator()办法，用以返回一个实现了 lterator 接口的对象, 即能够返回一个迭代器。
Iterator 的构造

迭代器的执行原理
```
lterator iterator = coll.iterator(); // 失去一个汇合的迭代器
//hasNext(): 判断是否还有下一个元素
while(iterator.hasNext()){//next()作用:1. 下移 2. 将下移当前汇合地位上的元素返回
System.out.println(iterator.next());
}
```
lterator 接口的办法

在调用 iterator.next()办法之前必须要调用 iterator.hasNext()进行检测。若不调用，且下一条记录有效，间接调用 iterator.next()会抛出 NoSuchElementException 异样。

4) Iterator 仅用于遍历汇合，Iterator 自身并不寄存对象。

package com.hspedu.collection_;

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

public class CollectionIterator {@SuppressWarnings({"all"})
    public static void main(String[] args) {Collection col = new ArrayList();

        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));


        //System.out.println("col=" + col);
        // 当初老师心愿可能遍历 col 汇合
        //1. 先失去 col 对应的 迭代器
        Iterator iterator = col.iterator();
        //2. 应用 while 循环遍历
//        while (iterator.hasNext()) {// 判断是否还有数据
//            // 返回下一个元素，类型是 Object
//            Object obj = iterator.next();
//            System.out.println("obj=" + obj);
//        }
        // 教大家一个快捷键，疾速生成 while => itit
        // 显示所有的快捷键的的快捷键 ctrl + j
        while (iterator.hasNext()) {Object obj = iterator.next();
            System.out.println("obj=" + obj);

        }
        //3. 当退出 while 循环后 , 这时 iterator 迭代器，指向最初的元素
        //   iterator.next();// 此时如果再取则会报错 NoSuchElementException
        //4. 如果心愿再次遍历，须要重置咱们的迭代器
        iterator = col.iterator(); // 重置迭代器
        System.out.println("=== 第二次遍历 ===");
        while (iterator.hasNext()) {Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
    }
}

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

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = 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;}

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

加强 for 循环，能够代替 iterator 迭代器，特点：加强 for 就是简化版的 iterator, 实质一样。只能用于遍历汇合或数组。

根本语法

for(元素类型 元素名: 汇合名或数组名){}

实例：

package com.hspedu.collection_;

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

public class CollectionFor {@SuppressWarnings({"all"})
    public static void main(String[] args) {Collection col = new ArrayList();

        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));

        //1. 应用加强 for, 在 Collection 汇合
        //2. 加强 for，底层依然是迭代器
        //3. 加强 for 能够了解成就是简化版本的 迭代器遍历
        //4. 快捷键形式 I
//        for (Object book : col) {//            System.out.println("book=" + book);
//        }
        for (Object o : col) {System.out.println("book=" + o);
        }

        // 加强 for，也能够间接在数组应用
//        int[] nums = {1, 8, 10, 90};
//        for (int i : nums) {//            System.out.println("i=" + i);
//        }
    }
}

List 接口是 Collection 接口的子接口

List 汇合类中元素有序(即增加程序和取出程序统一)、且可反复
List 汇合中的每个元素都有其对应的顺序索引，即反对索引。
List 容器中的元素都对应一个整数型的序号记录其在容器中的地位，能够依据序号存取容器中的元素。
JDK API 中 List 接口的实现类有很多：

这部分办法是 List 独有的，set 用不了。

void add(int index, Object ele): 在 index 地位插入 ele 元素
boolean addAll(int index, Collection eles): 从 index 地位开始将 eles 中的所有元素增加进来
Object get(int index): 获取指定 index 地位的元素
int indexOf(Object obj): 返回 obj 在汇合中首次呈现的地位
int lastIndexOf(Object obj): 返回 obj 在以后汇合中末次呈现的地位
Object remove(int index): 移除指定 index 地位的元素，并返回此元素
Object set(int index, Object ele): 设置指定 index 地位的元素为 ele , 相当于是替换.
List subList(int fromIndex, int toIndex): 返回从 fromIndex 到 toIndex 地位的子集合。（fromIndex <= subList < toIndex）

package com.hspedu.list_;

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

public class ListMethod {@SuppressWarnings({"all"})
    public static void main(String[] args) {List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");
//        void add(int index, Object ele): 在 index 地位插入 ele 元素
        // 在 index = 1 的地位插入一个对象（index 从 0 开始）list.add(1, "韩顺平");
        System.out.println("list=" + list);
//        boolean addAll(int index, Collection eles): 从 index 地位开始将 eles 中的所有元素增加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1, list2);
        System.out.println("list=" + list);
//        Object get(int index): 获取指定 index 地位的元素
        // 说过
//        int indexOf(Object obj): 返回 obj 在汇合中首次呈现的地位
        System.out.println(list.indexOf("tom"));//2
//        int lastIndexOf(Object obj): 返回 obj 在以后汇合中末次呈现的地位
        list.add("韩顺平");
        System.out.println("list=" + list);
        System.out.println(list.lastIndexOf("韩顺平"));
//        Object remove(int index): 移除指定 index 地位的元素，并返回此元素
        list.remove(0);
        System.out.println("list=" + list);
//        Object set(int index, Object ele): 设置指定 index 地位的元素为 ele , 相当于是替换.
        list.set(1, "玛丽");
        System.out.println("list=" + list);
//        List subList(int fromIndex, int toIndex): 返回从 fromIndex 到 toIndex 地位的子集合
        // 留神返回的子集合 fromIndex <= subList < toIndex
        List returnlist = list.subList(0, 2);
        System.out.println("returnlist=" + returnlist);
    }
}

增加 10 个以上的元素(比方 String “hello”)，在 2 号位插入一个元素 ” 韩顺平教育”，取得第 5 个元素，删除第 6 个元素，批改第 7 个元素，在应用迭代器遍历汇合，要求: 应用 List 的实现类 ArrayList 实现。

package com.hspedu.list_;

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

public class ListExercise {@SuppressWarnings({"all"})
    public static void main(String[] args) {
        /*
        增加 10 个以上的元素(比方 String "hello")，在 2 号位插入一个元素 "韩顺平教育"，取得第 5 个元素，删除第 6 个元素，批改第 7 个元素，在应用迭代器遍历汇合，要求: 应用 List 的实现类 ArrayList 实现。*/
        List list = new ArrayList();
        for (int i = 0; i < 12; i++) {list.add("hello" + i);
        }
        System.out.println("list=" + list);

        // 在 2 号位插入一个元素 "韩顺平教育"
        list.add(1, "韩顺平教育");
        System.out.println("list=" + list);
        // 取得第 5 个元素
        System.out.println("第五个元素 =" + list.get(4));
        // 删除第 6 个元素
        list.remove(5);
        System.out.println("list=" + list);
        // 批改第 7 个元素
        list.set(6, "三国演义");
        System.out.println("list=" + list);

        // 在应用迭代器遍历汇合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {Object obj =  iterator.next();
            System.out.println("obj=" + obj);
        }
    }
}

package com.hspedu.list_;

import java.util.*;

public class ListFor {@SuppressWarnings({"all"})
    public static void main(String[] args) {

        //List 接口的实现子类 Vector LinkedList
        //List list = new ArrayList();
        //List list = new Vector();
        List list = new LinkedList();
        list.add("jack");
        list.add("tom");
        list.add("鱼香肉丝");
        list.add("北京烤鸭子");

        // 遍历
        //1. 迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {Object obj =  iterator.next();
            System.out.println(obj);
        }
        
        System.out.println("===== 加强 for=====");
        //2. 加强 for
        for (Object o : list) {System.out.println("o=" + o);
        }

        System.out.println("===== 一般 for====");
        //3. 应用一般 for
        for (int i = 0; i < list.size(); i++) {System.out.println("对象 =" + list.get(i));
        }
    }
}

package com.hspedu.list_;

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

@SuppressWarnings({"all"})
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("水浒传", "施耐庵", 19));
        list.add(new Book("三国", "罗贯中", 80));
        //list.add(new Book("西游记", "吴承恩", 10));

        // 如何对汇合进行排序


        // 遍历

        for (Object o : list) {System.out.println(o);
        }

        // 冒泡排序
        sort(list);

        System.out.println("== 排序后 ==");

        for (Object o : list) {System.out.println(o);
        }

    }

    // 静态方法
    // 价格要求是从小到大
    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
                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);
                }
            }
        }

    }
}

1) permits all elements, including null , ArrayList 能够退出 null（空值）, 并且能够是多个。

2) ArrayList 是由数组来实现数据存储的 [源码]
3) ArrayList 根本等同于 Vector，除了 ArrayList 是线程不平安(执行效率高) 看源码。在多线程状况下，不倡议应用 ArrayList。

ArrayList 中保护了一个 Object 类型的数组 elementData.

transient Object[] elementData; //transient 示意霎时, 短暂的, 示意该属性不会被序列号

当创立 ArrayList 对象时，如果应用的是无参结构器，则初始 elementData 容量为 0，第 1 次增加，则扩容 elementData 为 10，如须要再次扩容，则扩容 elementData 为1.5 倍。
如果应用的是指定大小的结构器，则初始 elementData 容量为指定大小，如果须要扩容, 则间接扩容 elementData 为1.5 倍。

倡议: 本人去 debug 一把 ArrayList 的创立和扩容的流程。

package com.hspedu.list_;

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class ArrayListSource {public static void main(String[] args) {

        //Idea 默认状况下，Debug 显示的数据是简化后的，如果心愿看到残缺的数据须要做设置。// 应用无参结构器创立 ArrayList 对象
        //ArrayList list = new ArrayList();
        ArrayList list = new ArrayList(8);
        // 应用 for 给 list 汇合增加 1-10 数据
        for (int i = 1; i <= 10; i++) {list.add(i);
        }
        // 应用 for 给 list 汇合增加 11-15 数据
        for (int i = 11; i <= 15; i++) {list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);
    }
}

Idea 默认状况下，Debug 显示的数据是简化后的，如果心愿看到残缺的数据须要做设置。

Vector 类的定义阐明

public class vector<E>extends AbstractList<E>
implements List<E>，RandomAccess，cloneable，Serializable

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

Vector 是线程同步的，即线程平安, Vector 类的操作方法带有

synchronizedpublic synchronized E get(int index){if (index >= elementCount)
 throw new ArraylndexOutOfBoundsException(index);
return elementData(index);
}

在开发中，须要线程同步平安时，思考应用 Vector

package com.hspedu.list_;

import java.util.Vector;

@SuppressWarnings({"all"})
public class Vector_ {public static void main(String[] args) {
        // 无参结构器
        // 有参数的结构
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {vector.add(i);
        }
        vector.add(100);
        System.out.println("vector=" + vector);
        //1. new Vector() 底层
        /*
            public Vector() {this(10);
            }
         补充：如果是  Vector vector = new Vector(8);
            走的办法:
            public Vector(int initialCapacity) {this(initialCapacity, 0);
            }
         2. vector.add(i)
         2.1  // 上面这个办法就增加数据到 vector 汇合
            public synchronized boolean add(E e) {
                modCount++;
                ensureCapacityHelper(elementCount + 1);
                elementData[elementCount++] = e;
                return true;
            }
          2.2  // 确定是否须要扩容 条件：minCapacity - elementData.length>0
            private void ensureCapacityHelper(int minCapacity) {
                // overflow-conscious code
                if (minCapacity - elementData.length > 0)
                    grow(minCapacity);
            }
          2.3 // 如果 须要的数组大小 不够用，就扩容 , 扩容的算法
              //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);
            }
         */

    }
}

1) LinkedList 底层实现了双向链表和双端队列特点
2) 能够增加任意元素(元素能够反复), 包含 null
3) 线程不平安，没有实现同步

1) LinkedList 底层保护了一个双向链表.
2) LinkedList 中保护了两个属性 first 和 last 别离指向首节点和尾节点
3) 每个节点(Node 对象)，外面又保护了 prev、next、item 三个属性，其中通过
prev 指向前一个，通过 next 指向后一个节点。最终实现双向链表.
4) 所以 LinkedList 的元素的增加和删除，不是通过数组实现的，相对来说效率较高。
5) 模仿一个简略的双向链表

package com.hspedu.list_;

public class LinkedList01 {public static void main(String[] args) {
        // 模仿一个简略的双向链表

        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node hsp = new Node("老韩");

        // 连贯三个结点，造成双向链表
        //jack -> tom -> hsp
        jack.next = tom;
        tom.next = hsp;
        //hsp -> tom -> jack
        hsp.pre = tom;
        tom.pre = jack;

        Node first = jack;// 让 first 援用指向 jack, 就是双向链表的头结点
        Node last = hsp; // 让 last 援用指向 hsp, 就是双向链表的尾结点


        // 演示，从头到尾进行遍历
        System.out.println("=== 从头到尾进行遍历 ===");
        while (true) {if(first == null) {break;}
            // 输入 first 信息
            System.out.println(first);
            first = first.next;
        }

        // 演示，从尾到头的遍历
        System.out.println("==== 从尾到头的遍历 ====");
        while (true) {if(last == null) {break;}
            // 输入 last 信息
            System.out.println(last);
            last = last.pre;
        }

        // 演示链表的增加对象 / 数据，是如许的不便
        // 要求，是在 tom --------- 插入一个对象 smith

        //1. 先创立一个 Node 结点，name 就是 smith
        Node smith = new Node("smith");
        // 上面就把 smith 退出到双向链表了
        smith.next = hsp;
        smith.pre = tom;
        hsp.pre = smith;
        tom.next = smith;

        // 让 first 再次指向 jack
        first = jack;// 让 first 援用指向 jack, 就是双向链表的头结点

        System.out.println("=== 从头到尾进行遍历 ===");
        while (true) {if(first == null) {break;}
            // 输入 first 信息
            System.out.println(first);
            first = first.next;
        }

        last = hsp; // 让 last 从新指向最初一个结点
        // 演示，从尾到头的遍历
        System.out.println("==== 从尾到头的遍历 ====");
        while (true) {if(last == null) {break;}
            // 输入 last 信息
            System.out.println(last);
            last = last.pre;
        }


    }
}

// 定义一个 Node 类，Node 对象 示意双向链表的一个结点
class Node {
    public Object item; // 真正存放数据
    public Node next; // 指向后一个结点
    public Node pre; // 指向前一个结点
    public Node(Object name) {this.item = name;}
    public String toString() {return "Node name=" + item;}
}

package com.hspedu.list_;

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

@SuppressWarnings({"all"})
public class LinkedListCRUD {public static void main(String[] args) {LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList=" + linkedList);

        // 演示一个删除结点的
        linkedList.remove(); // 这里默认删除的是第一个结点
        //linkedList.remove(2);

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

        // 批改某个结点对象
        linkedList.set(1, 999);
        System.out.println("linkedList=" + linkedList);

        // 失去某个结点对象
        //get(1) 是失去双向链表的第二个对象
        Object o = linkedList.get(1);
        System.out.println(o);//999

        // 因为 LinkedList 是 实现了 List 接口, 遍历形式
        System.out.println("===LinkeList 遍历迭代器 ====");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {Object next =  iterator.next();
            System.out.println("next=" + next);

        }

        System.out.println("===LinkeList 遍历加强 for====");
        for (Object o1 : linkedList) {System.out.println("o1=" + o1);
        }
        System.out.println("===LinkeList 遍历一般 for====");
        for (int i = 0; i < linkedList.size(); i++) {System.out.println(linkedList.get(i));
        }


        // 源码浏览.
        /* 1. LinkedList linkedList = new LinkedList();
              public LinkedList() {}
           2. 这时 linkeList 的属性 first = null  last = null
           3. 执行 增加
               public boolean add(E e) {linkLast(e);
                    return true;
                }
            4. 将新的结点，退出到双向链表的最初
             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++;
            }

         */

        /*
          读源码 linkedList.remove(); // 这里默认删除的是第一个结点
          1. 执行 removeFirst
            public E remove() {return removeFirst();
            }
         2. 执行
            public E removeFirst() {
                final Node<E> f = first;
                if (f == null)
                    throw new NoSuchElementException();
                return unlinkFirst(f);
            }
          3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
            private E unlinkFirst(Node<E> f) {
                // assert f == first && f != null;
                final E element = f.item;
                final Node<E> next = f.next;
                f.item = null;
                f.next = null; // help GC
                first = next;
                if (next == null)
                    last = null;
                else
                    next.prev = null;
                size--;
                modCount++;
                return element;
            }
         */
    }
}

如何抉择 ArrayList 和 LinkedList:

1) 如果咱们改查的操作多，抉择 ArrayList
2) 如果咱们增删的操作多，抉择 LinkedList
3) 一般来说，在程序中，80%-90% 都是查问，因而大部分状况下会抉择 ArrayList
4) 在一个我的项目中，依据业务灵便抉择，也可能这样，一个模块应用的是 ArrayList, 另外一个模块是 LinkedList, 也就是说, 要依据业务来进行抉择。

无序（增加和取出的程序不统一)，没有索引
不容许反复元素, 所以最多蕴含一个 null
JDK API 中 Set 接口的实现类有:

和 List 接口一样, Set 接口也是 Collection 的子接口，因而，罕用办法和 Collection 接口一样.

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

能够应用迭代器
加强 for
不能应用索引的形式来获取

package com.hspedu.set_;

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

@SuppressWarnings({"all"})
public class SetMethod {public static void main(String[] args) {
        //1. 以 Set 接口的实现类 HashSet 来解说 Set 接口的办法
        //2. set 接口的实现类的对象(Set 接口对象), 不能寄存反复的元素, 能够增加一个 null
        //3. set 接口对象存放数据是无序(即增加的程序和取出的程序不统一)
        //4. 留神：取出的程序的程序尽管不是增加的程序，然而他的固定.
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");// 反复
        set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);// 再次增加 null
        for(int i = 0; i <10;i ++) {System.out.println("set=" + set);
        }

        // 遍历
        // 形式 1：应用迭代器
        System.out.println("===== 应用迭代器 ====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {Object obj =  iterator.next();
            System.out.println("obj=" + obj);

        }

        set.remove(null);

        // 形式 2: 加强 for
        System.out.println("===== 加强 for====");

        for (Object o : set) {System.out.println("o=" + o);
        }

        //set 接口对象，不能通过索引来获取


    }
}

HashSet 实现了 Set 接口

HashSet 实际上是 HashMap, 看下源码

public Hashset() {map = new HashMap<>();
}

能够寄存 null 值，然而只能有一个 null
HashSet 不保障元素是有序的, 取决于 hash 后，再确定索引的后果。(即，不保障寄存元素的程序和取出程序统一)
不能有反复元素 / 对象，在后面 Set 接口应用曾经讲过。

package com.hspedu.set_;

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

@SuppressWarnings({"all"})
public class HashSet_ {public static void main(String[] args) {
        //1. 结构器走的源码
        /*
            public HashSet() {map = new HashMap<>();
            }
         2. HashSet 能够寄存 null , 然而只能有一个 null, 即元素不能反复
         */
        Set hashSet = new HashSet();
        hashSet.add(null);
        hashSet.add(null);
        System.out.println("hashSet=" + hashSet);

    }
}

package com.hspedu.set_;



import java.util.HashSet;

@SuppressWarnings({"all"})
public class HashSet01 {public static void main(String[] args) {HashSet set = new HashSet();

        // 阐明
        //1. 在执行 add 办法后，会返回一个 boolean 值
        //2. 如果增加胜利，返回 true, 否则返回 false
        //3. 能够通过 remove 指定删除哪个对象
        System.out.println(set.add("john"));//T
        System.out.println(set.add("lucy"));//T
        System.out.println(set.add("john"));//F
        System.out.println(set.add("jack"));//T
        System.out.println(set.add("Rose"));//T


        set.remove("john");
        System.out.println("set=" + set);// 3 个

        //
        set  = new HashSet();
        System.out.println("set=" + set);//0
        //4 Hashset 不能增加雷同的元素 / 数据?
        set.add("lucy");// 增加胜利
        set.add("lucy");// 退出不了
        set.add(new Dog("tom"));//OK 不同的对象
        set.add(new Dog("tom"));//Ok
        System.out.println("set=" + set);

        // 在加深一下. 十分经典的面试题.
        // 看源码，做剖析，先给小伙伴留一个坑，当前讲完源码，你就了然
        // 去看他的源码，即 add 到底产生了什么? => 底层机制.
        set.add(new String("hsp"));//ok
        set.add(new String("hsp"));// 退出不了.
        System.out.println("set=" + set);


    }
}
class Dog { // 定义了 Dog 类
    private String name;

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

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

package com.hspedu.set_;

@SuppressWarnings({"all"})
public class HashSetStructure {public static void main(String[] args) {// 模仿一个 HashSet 的底层 (HashMap 的底层构造)

        //1. 创立一个数组，数组的类型是 Node[]
        //2. 有些人，间接把 Node[] 数组称为 表
        Node[] table = new Node[16];

        //3. 创立结点
        Node john = new Node("john", null);

        table[2] = john;
        Node jack = new Node("jack", null);
        john.next = jack;// 将 jack 结点挂载到 john
        Node rose = new Node("Rose", null);
        jack.next = rose;// 将 rose 结点挂载到 jack

        Node lucy = new Node("lucy", null);
        table[3] = lucy; // 把 lucy 放到 table 表的索引为 3 的地位.
        System.out.println("table=" + table);


    }
}
class Node { // 结点, 存储数据, 能够指向下一个结点，从而造成链表
    Object item; // 存放数据
    Node next; // 指向下一个结点

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

剖析底层实现：

HashSet 底层是 HashMap
增加一个元素时，先失去 hash 值 - 会转成 -> 索引值
找到存储数据表 table，看这个索引地位是否曾经寄存的有元素
如果没有，间接退出
如果有，调用 equals 比拟，如果雷同，就放弃增加, 如果不雷同，则增加到最初
在 Java8 中, 如果一条链表的元素个数达到 TREEIFY_THRESHOLD(默认是 8)，并且 table 的大小 >=MIN TREEIFY CAPACITY(默认 64), 就会进行树化(红黑树)，否则依然会采纳数组扩容机制。

package com.hspedu.set_;

import java.util.HashSet;

@SuppressWarnings({"all"})
public class HashSetSource {public static void main(String[] args) {HashSet hashSet = new HashSet();
        hashSet.add("java");// 到此地位，第 1 次 add 剖析结束.
        hashSet.add("php");// 到此地位，第 2 次 add 剖析结束
        hashSet.add("java");
        System.out.println("set=" + hashSet);

        /*
        对 HashSet 的源码解读
        1. 执行 HashSet()
            public HashSet() {map = new HashMap<>();
            }
        2. 执行 add()
           public boolean add(E e) {//e = "java"
                return map.put(e, PRESENT)==null;// (static) PRESENT = new Object();}
         3. 执行 put() , 该办法会执行 hash(key) 失去 key 对应的 hash 值 算法：h = key.hashCode()) ^ (h >>> 16) 可见这个 hash 的值并不是 hashcode，而是做了肯定的解决 >>> 16.
             public V put(K key, V value) {//key = "java" value = PRESENT 共享
                return putVal(hash(key), key, value, false, true);
            }
         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 就是 HashMap 的一个数组，类型是 Node[]（后面咱们也模仿过）//if 语句示意如果以后 table 是 null, 或者 大小 =0
                // 就是第一次扩容，到 16 个空间.
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;

                //(1)依据 key，失去 hash 去计算该 key 应该寄存到 table 表的哪个索引地位并把这个地位的对象，赋给 p
                //(2)判断 p 是否为 null
                //(2.1) 如果 p 为 null, 示意还没有寄存元素, 就创立一个 Node (key="java",value=PRESENT)
                //(2.2) 就放在该地位 tab[i] = newNode(hash, key, value, null)
                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null); // 这个 null 相似与模仿节点的 null，其前面还没有挂载节点
                else {// 一个开发技巧提醒：在须要局部变量 (辅助变量) 时候，在创立
                    Node<K,V> e; K k; //
                    // 如果以后索引地位对应的链表的第一个元素和筹备增加的 key 的 hash 值一样
                    // 并且满足 上面两个条件之一:
                    //  (1) 筹备退出的 key 和 p 指向的 Node 结点的 key 是同一个对象
                    //  (2)  p 指向的 Node 结点的 key 的 equals() 和筹备退出的 key 比拟后雷同
                    // 就不能退出
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    // 再判断 p 是不是一颗红黑树,
                    // 如果是一颗红黑树，就调用 putTreeVal , 来进行增加
                    else if (p instanceof TreeNode)
                        e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                    else {// 如果 table 对应索引地位，曾经是一个链表, 就应用 for 循环比拟
                          //(1) 顺次和该链表的每一个元素比拟后，都不雷同, 则退出到该链表的最初
                          //    留神在把元素增加到链表后，立刻判断 该链表是否曾经达到 8 个结点
                          //    , 就调用 treeifyBin() 对以后这个链表进行树化(转成红黑树)
                          //    留神，在转成红黑树时，要进行判断, 判断条件
                          //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
                          //            resize();
                          //    如果下面条件成立，先 table 扩容.
                          //    只有下面条件不成立时，才进行转成红黑树
                          //(2) 顺次和该链表的每一个元素比拟过程中，如果有雷同状况, 就间接 break

                        for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);
                                if (binCount >= TREEIFY_THRESHOLD(8) - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V oldValue = e.value;
                        if (!onlyIfAbsent || oldValue == null)
                            e.value = value;
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;
                //size 就是咱们每退出一个结点 Node(k,v,h,next), size++
                if (++size > threshold)
                    resize();// 扩容
                afterNodeInsertion(evict);
                return null;
            }
         */

    }
}

HashSet 底层是 HashMap, 第一次增加时,table 数组扩容到 16，临界值 (threshold) 是 16* 加载因子 (loadFactor)是 0.75 = 12
如果 table 数组应用到了临界值 12, 就会扩容到 16 2=32, 新的临界值就是 320.75 =24. 顺次类推

package com.hspedu.set_;

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

@SuppressWarnings({"all"})
public class HashSetIncrement {public static void main(String[] args) {
        /*
        HashSet 底层是 HashMap, 第一次增加时，table 数组扩容到 16，临界值 (threshold) 是 16* 加载因子 (loadFactor) 是 0.75 = 12
        如果 table 数组应用到了临界值 12, 就会扩容到 16 * 2 = 32,
        新的临界值就是 32*0.75 = 24, 顺次类推

         */
        HashSet hashSet = new HashSet();
//        for(int i = 1; i <= 100; i++) {//            hashSet.add(i);//1,2,3,4,5...100
//        }
        /*
        在 Java8 中, 如果一条链表的元素个数达到 TREEIFY_THRESHOLD(默认是 8)，并且 table 的大小 >= MIN_TREEIFY_CAPACITY(默认 64), 就会进行树化(红黑树),
        否则依然采纳数组扩容机制

         */

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


        /*
            当咱们向 hashset 减少一个元素，-> Node -> 退出 table , 就算是减少了一个 size++

         */

        for(int i = 1; i <= 7; i++) {// 在 table 的某一条链表上增加了 7 个 A 对象
            hashSet.add(new A(i));//
        }

        for(int i = 1; i <= 7; i++) {// 在 table 的另外一条链表上增加了 7 个 B 对象
            hashSet.add(new B(i));//
        }



    }
}

class B {
    private int n;

    public B(int n) {this.n = n;}
    @Override
    public int hashCode() {return 200;}
}

class A {
    private int n;

    public A(int n) {this.n = n;}
    @Override
    public int hashCode() {return 100;}
}

定义一个 Employee 类, 该类蕴含:private 成员属性 name.age

要求:

1. 创立 3 个 Employee 对象放入 HashSet 中

2. 当 name 和 age 的值雷同时，认为是雷同员工, 不能增加到 HashSet 汇合中

package com.hspedu.set_;

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

@SuppressWarnings({"all"})
public class HashSetExercise {public static void main(String[] args) {


        /**
         定义一个 Employee 类，该类蕴含：private 成员属性 name,age 要求:
         创立 3 个 Employee 对象放入 HashSet 中
         当 name 和 age 的值雷同时，认为是雷同员工, 不能增加到 HashSet 汇合中

         */
        HashSet hashSet = new HashSet();
        hashSet.add(new Employee("milan", 18));//ok
        hashSet.add(new Employee("smith", 28));//ok
        hashSet.add(new Employee("milan", 18));// 退出不胜利.

        // 答复, 退出了几个? 3 个
        System.out.println("hashSet=" + hashSet);
    }
}

// 创立 Employee
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;}

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

    public void setAge(int age) {this.age = age;}
    // 如果 name 和 age 值雷同，则返回雷同的 hash 值

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

1) LinkedHashSet 是 HashSet 的子类
2) LinkedHashSet 底层是一个 LinkedHashMap，底层保护了一个数组 + 双向链表
3) LinkedHashSet 依据元素的 hashCode 值来决定元素的存储地位, 同时使
用链表保护元素的秩序(图), 这使得元素看起来是以插入程序保留的。
4) LinkedHashSet 不容许添反复元素

package com.hspedu.set_;

import java.util.LinkedHashSet;
import java.util.Set;

@SuppressWarnings({"all"})
public class LinkedHashSetSource {public static void main(String[] args) {
        // 剖析一下 LinkedHashSet 的底层机制
        Set set = new LinkedHashSet();
        set.add(new String("AA"));
        set.add(456);
        set.add(456);
        set.add(new Customer("刘", 1001));
        set.add(123);
        set.add("HSP");

        System.out.println("set=" + set);
        //1. LinkedHashSet 退出程序和取出元素 / 数据的程序统一
        //2. LinkedHashSet 底层保护的是一个 LinkedHashMap(是 HashMap 的子类)
        //3. LinkedHashSet 底层构造 (数组 table+ 双向链表)
        //4. 增加第一次时，间接将 数组 table 扩容到 16 , 寄存的结点类型是 LinkedHashMap$Entry
        //5. 数组是 HashMap$Node[] 寄存的元素 / 数据是 LinkedHashMap$Entry 类型
        /*
                // 继承关系是在内部类实现.
                static class Entry<K,V> extends HashMap.Node<K,V> {
                    Entry<K,V> before, after;
                    Entry(int hash, K key, V value, Node<K,V> next) {super(hash, key, value, next);
                    }
                }

         */

    }
}
class Customer {
    private String name;
    private int no;

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

阐明

在 LinkedHastSet 中保护了一个 hash 表和双向链表(LinkedHashSet 有 head 和 tail)
每一个节点有 before 和 after 属性, 这样能够造成双向链表
在增加一个元素时，先求 hash 值，在求索引, 确定该元素在 table 的地位, 而后将增加的元素退出到双向链表(如果曾经存在，不增加[准则和 hashset 一样])
```
tail.next = newElement // 示意代码
newElement.pre = tail
tail = newEelment;
```
这样的话，咱们遍历 LinkedHashSet 也能确保插入程序和遍历程序统一

Car 类(属性:name,price)，如果 name 和 price 一样，则认为是雷同元素，就不能增加。

package com.hspedu.set_;

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

@SuppressWarnings({"all"})
public class LinkedHashSetExercise {public static void main(String[] args) {LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new Car("奥拓", 1000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));//OK
        linkedHashSet.add(new Car("法拉利", 10000000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));// 退出不了
        linkedHashSet.add(new Car("保时捷", 70000000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));// 退出不了

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

    }
}

/**
 * Car 类(属性:name,price)，如果 name 和 price 一样，* 则认为是雷同元素，就不能增加。5min
 */

class Car {
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.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 String toString() {
        return "\nCar{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    // 重写 equals 办法 和 hashCode
    // 当 name 和 price 雷同时，就返回雷同的 hashCode 值, equals 返回 t

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

留神: 这里讲的是 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 为 nul，只能有一个，value 为 null , 能够多个:.
6) 罕用 String 类作为 Map 的 key
7) key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value

package com.hspedu.map_;

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

@SuppressWarnings({"all"})
public class Map_ {public static void main(String[] args) {
        //Map 接口实现类的特点, 应用实现类 HashMap
        //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 map = new HashMap();
        map.put("no1", "韩顺平");//k-v
        map.put("no2", "张无忌");//k-v
        map.put("no1", "张三丰");// 当有雷同的 k , 就等价于替换.
        map.put("no3", "张三丰");//k-v
        map.put(null, null); //k-v
        map.put(null, "abc"); // 等价替换
        map.put("no4", null); //k-v
        map.put("no5", null); //k-v
        map.put(1, "赵敏");//k-v
        map.put(new Object(), "金毛狮王");//k-v
        // 通过 get 办法，传入 key , 会返回对应的 value
        System.out.println(map.get("no2"));// 张无忌

        System.out.println("map=" + map);
    }
}

Map 存放数据的 key-value 示意图, 一对 k - v 是放在一个 HashMap$Node 中的，有因为 Node 实现了 Entry 接口，有些书上也说一对 k-v 就是一个 Entry(如图)。然而实质上 Entry 还是指向 HashMap$Node 中的元素，并不是复制版存储。

package com.hspedu.map_;

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


@SuppressWarnings({"all"})
public class MapSource_ {public static void main(String[] args) {Map map = new HashMap();
        map.put("no1", "韩顺平");//k-v
        map.put("no2", "张无忌");//k-v
        map.put(new Car(), new Person());//k-v

        // 老韩解读
        //1. k-v 最初是 HashMap$Node node = newNode(hash, key, value, null)
        //2. k-v 为了不便程序员的遍历，还会 创立 EntrySet 汇合，该汇合寄存的元素的类型 Entry, 而一个 Entry
        //   对象就有 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 = map.entrySet();
        System.out.println(set.getClass());// HashMap$EntrySet
        for (Object obj : set) {//System.out.println(obj.getClass()); //HashMap$Node
            // 为了从 HashMap$Node 取出 k -v
            //1. 先做一个向下转型
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

        Set set1 = map.keySet();
        System.out.println(set1.getClass());
        Collection values = map.values();
        System.out.println(values.getClass());


    }
}

class Car {

}

class Person{}

package com.hspedu.map_;

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

@SuppressWarnings({"all"})
public class MapMethod {public static void main(String[] args) {
        // 演示 map 接口罕用办法

        Map map = new HashMap();
        map.put("fh", new Book("", 100));//OK
        map.put("fh", "bnd");// 替换 -> 一会剖析源码
        map.put("fgd", "mr");//OK
        map.put("sgfh", "mr");//OK
        map.put("vcbhhd", null);//OK
        map.put(null, "dfhdfg");//OK
        map.put("lh", "gct");//OK
        map.put("hsp", "hspd");

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

//        remove: 依据键删除映射关系
        map.remove(null);
        System.out.println("map=" + map);
//        get：依据键获取值
        Object val = map.get("lh");
        System.out.println("val=" + val);
//        size: 获取元素个数
        System.out.println("k-v=" + map.size());
//        isEmpty: 判断个数是否为 0
        System.out.println(map.isEmpty());//F
//        clear: 革除 k -v
        //map.clear();
        System.out.println("map=" + map);
//        containsKey: 查找键是否存在
        System.out.println("后果 =" + map.containsKey("hsp"));//T


    }
}

class Book {
    private String name;
    private int num;

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

Map 遍历的示意图(比 List，和 Set 简单点然而基本原理一样)

containsKey: 查找键是否存在
keySet: 获取所有的键
entrySet: 获取所有关系 k -v
values: 获取所有的值

package com.hspedu.map_;

import java.util.*;

@SuppressWarnings({"all"})
public class MapFor {public static void main(String[] args) {Map 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----");
        for (Object value : values) {System.out.println(value);
        }
        //(2) 迭代器
        System.out.println("--- 取出所有的 value 迭代器 ----");
        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
        System.out.println("---- 应用 EntrySet 的 for 加强(第 3 种)----");
        for (Object entry : entrySet) {
            // 将 entry 转成 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
        //(2) 迭代器
        System.out.println("---- 应用 EntrySet 的 迭代器(第 4 种)----");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {Object entry =  iterator3.next();
            //System.out.println(next.getClass());//HashMap$Node - 实现 -> Map.Entry (getKey,getValue)
            // 向下转型 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
    }
}

应用 HashMap 增加 3 个员工对象，要求

键: 员工 id

值: 员工对象

并遍历显示工资 >18000 的员工(遍历形式起码两种)

员工类: 姓名、工资、员工 id

package com.hspedu.map_;

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

@SuppressWarnings({"all"})
public class MapExercise {public static void main(String[] args) {
        // 实现代码
        Map hashMap = new HashMap();
        // 增加对象
        hashMap.put(1, new Emp("jack", 300000, 1));
        hashMap.put(2, new Emp("tom", 21000, 2));
        hashMap.put(3, new Emp("milan", 12000, 3));


        // 遍历 2 种形式
        // 并遍历显示工资 >18000 的员工(遍历形式起码两种)
        //1. 应用 keySet  -> 加强 for
        Set keySet = hashMap.keySet();
        System.out.println("==== 第一种遍历形式 ====");
        for (Object key : keySet) {
            // 先获取 value
            Emp emp = (Emp) hashMap.get(key);
            if(emp.getSal() >18000) {System.out.println(emp);
            }
        }

        //2. 应用 EntrySet -> 迭代器
        Set entrySet = hashMap.entrySet();
        System.out.println("====== 迭代器 ======");
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            // 真正的运行类型是 Node，能够 getClass 看一下
            Map.Entry entry =  (Map.Entry)iterator.next();
            // 通过 entry 获得 key 和 value
            Emp emp = (Emp) entry.getValue();
            if(emp.getSal() > 18000) {System.out.println(emp);
            }
        }
    }
}

/**
 * 应用 HashMap 增加 3 个员工对象，要求
 * 键：员工 id
 * 值：员工对象
 * 并遍历显示工资 >18000 的员工(遍历形式起码两种)
 * 员工类：姓名、工资、员工 id
 */
class Emp {
    private String name;
    private double sal;
    private int id;

    public Emp(String name, double sal, int 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 int getId() {return id;}

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

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

1) Map 接口的罕用实现类:HashMap、Hashtable 和 Properties。
2) HashMap 是 Map 接口应用频率最高的实现类。
3) HashMap 是以 key-val 对的形式来存储数据(HashMap$Node 类型)[案例 Entry]
4) key 不能反复，然而值能够反复, 容许应用 null 键和 null 值。
5) 如果增加雷同的 key，则会笼罩原来的 key-val , 等同于批改.(key 不会替换，val 会替换)
6) 与 HashSet 一样，不保障映射的程序，因为底层是以 hash 表的形式来存储的. (jdk8 的 hashMap 底层数组 + 链表 + 红黑树)
7) HashMap 没有实现同步，因而是线程不平安的, 办法没有做同步互斥的操作, 没有 synchronized

1) HashMap 底层保护了 Node 类型的数组 table，默认为 null
2) 当创建对象时，将加载因子 (Ioadfactor) 初始化为 0.75.
3) 当增加 key-val 时，通过 key 的哈希值得到在 table 的索引。而后判断该索引处是否有元素, 如果没有元素间接增加。如果该索引处有元素，持续判断该元素的 key 和筹备退出的 key 相是否等, 如果相等，则间接替换 val; 如果不相等须要判断是树结构还是链表构造，做出相应解决。如果增加时发现容量不够，则须要扩容。
4) 第 1 次增加，则须要扩容 table 容量为 16，临界值 (threshold) 为 12 (16*0.75)
5) 当前再扩容，则须要扩容 table 容量为原来的 2 倍(32)，临界值为原来的 2 倍, 即 24, 顺次类推.
6) 在 Java8 中, 如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认是 8)，并且 table 的大小 >= MIN TREEIFY CAPACITY(默认 64), 就会进行树化(红黑树)

package com.hspedu.map_;

import java.util.HashMap;

@SuppressWarnings({"all"})
public class HashMapSource1 {public static void main(String[] args) {HashMap map = new HashMap();
        map.put("java", 10);//ok
        map.put("php", 10);//ok
        map.put("java", 20);// 替换 value

        System.out.println("map=" + map);//

        /* 解读 HashMap 的源码 + 图解
        1. 执行结构器 new HashMap()
           初始化加载因子 loadfactor = 0.75
           HashMap$Node[] table = null
        2. 执行 put 调用 hash 办法，计算 key 的 hash 值 (h = key.hashCode()) ^ (h >>> 16)
            public V put(K key, V value) {//K = "java" value = 10
                return putVal(hash(key), key, value, false, true);
            }
         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;// 辅助变量
                // 如果底层的 table 数组为 null, 或者 length =0 , 就扩容到 16
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;
                // 取出 hash 值对应的 table 的索引地位的 Node, 如果为 null, 就间接把退出的 k -v
                //, 创立成一个 Node , 退出该地位即可
                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    Node<K,V> e; K k;// 辅助变量
                // 如果 table 的索引地位的 key 的 hash 雷同和新的 key 的 hash 值雷同，// 并 满足(table 现有的结点的 key 和筹备增加的 key 是同一个对象  || equals 返回真)
                 // 就认为不能退出新的 k -v
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    else if (p instanceof TreeNode)// 如果以后的 table 的已有的 Node 是红黑树，就依照红黑树的形式解决
                        e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                    else {
                        // 如果找到的结点，前面是链表，就循环比拟
                        for (int binCount = 0; ; ++binCount) {// 死循环
                            if ((e = p.next) == null) {// 如果整个链表，没有和他雷同, 就加到该链表的最初
                                p.next = newNode(hash, key, value, null);
                                // 退出后，判断以后链表的个数，是否曾经到 8 个，到 8 个，后
                                // 就调用 treeifyBin 办法进行红黑树的转换
                                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash && // 如果在循环比拟过程中，发现有雷同, 就 break, 就只是替换 value
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V oldValue = e.value;
                        if (!onlyIfAbsent || oldValue == null)
                            e.value = value; // 替换，key 对应 value
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;// 每减少一个 Node , 就 size++
                if (++size > threshold[12-24-48])// 如 size > 临界值，就扩容
                    resize();
                afterNodeInsertion(evict);
                return null;
            }

              5. 对于树化(转成红黑树)
              // 如果 table 为 null , 或者大小还没有到 64，临时不树化，而是进行扩容.
              // 否则才会真正的树化 -> 剪枝
              final void treeifyBin(Node<K,V>[] tab, int hash) {
                int n, index; Node<K,V> e;
                if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                    resize();}
         */


    }
}

模仿 HashMap 触发扩容、树化状况, 并 Debug 验证.

package com.hspedu.map_;

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

@SuppressWarnings({"all"})
public class HashMapSource2 {public static void main(String[] args) {HashMap hashMap = new HashMap();
        for(int i = 1; i <= 12; i++) {hashMap.put(i, "hello");
        }

        hashMap.put("aaa", "bbb");

        System.out.println("hashMap=" + hashMap);//12 个 k-v

        // 安排一个工作，本人设计代码去验证，table 的扩容
        //0 -> 16(12) -> 32(24) -> 64(64*0.75=48)-> 128 (96) ->
        // 本人设计程序，验证 -》加强本人浏览源码能力. 看他人代码.
    }
}

class A  {
    private int num;

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

    // 所有的 A 对象的 hashCode 都是 100
//    @Override
//    public int hashCode() {
//        return 100;
//    }

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

1) 寄存的元素是键值对: 即 K -V

2) hashtable 的键和值都不能为 null，否则会抛出 NullPointerException
3) hashTable 应用办法基本上和 HashMap 一样
4) hashTable 是线程平安的(synchronized), hashMap 是线程不平安的

package com.hspedu.map_;

import java.util.Hashtable;

@SuppressWarnings({"all"})
public class HashTableExercise {public static void main(String[] args) {Hashtable table = new Hashtable();//ok
        table.put("john", 100); //ok
        //table.put(null, 100); // 异样 NullPointerException
        //table.put("john", null);// 异样 NullPointerException
        table.put("lucy", 100);//ok
        table.put("lic", 100);//ok
        table.put("lic", 88);// 替换
        table.put("hello1", 1);
        table.put("hello2", 1);
        table.put("hello3", 1);
        table.put("hello4", 1);
        table.put("hello5", 1);
        table.put("hello6", 1);
        System.out.println(table);

        // 简略阐明一下 Hashtable 的底层
        //1. 底层有数组 Hashtable$Entry[] 初始化大小为 11
        //2. 临界值 threshold 8 = 11 * 0.75
        //3. 扩容: 
        //4. 执行 办法 addEntry(hash, key, value, index); 增加 K -V 封装到 Entry
        //5. 当 if (count >= threshold) 满足时，就进行扩容
        //5. 依照 int newCapacity = (oldCapacity << 1) + 1; 的大小扩容. 两倍加一
    }
}

Properties 类继承自 Hashtable 类并且实现了 Map 接口，也是应用一种键值对的模式来保留数据。
他的应用特点和 Hashtable 相似。
Properties 还能够用于从 xxx.properties 文件中，加载数据到 Properties 类对象, 并进行读取和批改。
阐明: 工作后 xxx.properties 文件通常作为配置文件，这个知识点在 IO 流举例, 有趣味可先看文章。cnblogs.com/xudong-bupt/p/3758136.html

package com.hspedu.map_;

import java.util.Properties;

@SuppressWarnings({"all"})
public class Properties_ {public static void main(String[] args) {

        //1. Properties 继承  Hashtable
        //2. 能够通过 k-v 存放数据，当然 key 和 value 不能为 null
        // 减少
        Properties properties = new Properties();
        //properties.put(null, "abc");// 抛出 空指针异样
        //properties.put("abc", null); // 抛出 空指针异样
        properties.put("john", 100);//k-v
        properties.put("lucy", 100);
        properties.put("lic", 100);
        properties.put("lic", 88);// 如果有雷同的 key，value 被替换

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

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

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

        // 批改
        properties.put("john", "约翰");
        System.out.println("properties=" + properties);
    }
}

在开发中，抉择什么汇合实现类，次要取决于业务操作特点，而后依据汇合实现类个性进行抉择, 剖析如下:

先判断存储的类型 (一组对象[单列] 或一组键值对[双列])
一组对象 [单列]:Collection 接口
容许反复:List
- 增删多:LinkedList[底层保护了一个双向链表]
- 改查多: ArrayList[底层保护 Object 类型的可变数组]
不容许反复:Set
- 无序:HashSet[底层是 HashMap，保护了一个哈希表即(数组 + 链表 + 红黑树)
- 排序:TreeSet
- 插入和取出程序统一:LinkedHashSet . 保护数组 + 双向链表
一组键值对[双列]:Map
- 键无序;HashMap [底层是; 哈希表 jdk7: 数组 + 链表,jdk8: 数组 + 链表 + 红黑
- 键排序: TreeMap
- 键插入和取出程序统一:LinkedHashMap
- 读取文件 Properties

package com.hspedu.set_;

import java.util.Comparator;
import java.util.TreeSet;
@SuppressWarnings({"all"})
public class TreeSet_ {public static void main(String[] args) {

        //1. 当咱们应用无参结构器，创立 TreeSet 时，依然是无序的
        //2. 心愿增加的元素，依照字符串大小来排序
        //3. 应用 TreeSet 提供的一个结构器，能够传入一个比拟器 (匿名外部类) 并指定排序规定
        //4. 简略看看源码
        /*
        1. 结构器把传入的比拟器对象，赋给了 TreeSet 的底层的 TreeMap 的属性 this.comparator

         public TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;}
         2. 在 调用 treeSet.add("tom"), 在底层会执行到

             if (cpr != null) {//cpr 就是咱们的匿名外部类(对象)
                do {
                    parent = t;
                    // 动静绑定到咱们的匿名外部类(对象)compare
                    cmp = cpr.compare(key, t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else // 如果相等，即返回 0, 这个 Key 就没有退出
                        return t.setValue(value);
                } while (t != null);
            }
         */

//        TreeSet treeSet = new TreeSet();
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 上面 调用 String 的 compareTo 办法进行字符串大小比拟
                //return ((String) o2).compareTo((String) o1);
                // 如果要求退出的元素，依照长度大小排序
                return ((String) o1).length() - ((String) o2).length();}
        });
        // 增加数据.
        treeSet.add("jack");
        treeSet.add("tom");// 3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");// 长度为 3，加不进去
        System.out.println("treeSet=" + treeSet);
    }
}

package com.hspedu.map_;

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

@SuppressWarnings({"all"})
public class TreeMap_ {public static void main(String[] args) {// 应用默认的结构器，创立 TreeMap, 是无序的(也没有排序)
        /*
            要求：依照传入的 k(String) 的大小进行排序
         */
//        TreeMap treeMap = new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {// 依照传入的 k(String) 的大小进行排序
                // 依照 K(String) 的长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o2).length() - ((String) o1).length();}
        });
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克瑞斯提诺");
        treeMap.put("smith", "斯密斯");
        treeMap.put("hsp", "韩顺平");// 退出不了

        System.out.println("treemap=" + treeMap);

        /*
            解读源码：1. 结构器. 把传入的实现了 Comparator 接口的匿名外部类(对象)，传给给 TreeMap 的 comparator
             public TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;}
            2. 调用 put 办法
            2.1 第一次增加, 把 k -v 封装到 Entry 对象，放入 root
            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;
            }
            2.2 当前增加
            Comparator<? super K> cpr = comparator;
            if (cpr != null) {
                do { // 遍历所有的 key , 给以后 key 找到适当地位
                    parent = t;
                    cmp = cpr.compare(key, t.key);// 动静绑定到咱们的匿名外部类的 compare
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else  // 如果遍历过程中，发现筹备增加 Key 和以后已有的 Key 相等，就不增加
                        return t.setValue(value);
                } while (t != null);
            }
         */

    }
}

1) Collections 是一个操作 Set、List 和 Map 等汇合的工具类。
2) Collections 中提供了一系列动态的办法对汇合元素进行排序、查问和批改等操作。

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,Comparator): 依据 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 对象的所有旧值。

package com.hspedu.collections_;

import java.util.*;

@SuppressWarnings({"all"})
public class Collections_ {public static void main(String[] args) {

        // 创立 ArrayList 汇合，用于测试.
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");
        list.add("tom");


//        reverse(List)：反转 List 中元素的程序
        Collections.reverse(list);
        System.out.println("list=" + list);
//        shuffle(List)：对 List 汇合元素进行随机排序
//        for (int i = 0; i < 5; i++) {//            Collections.shuffle(list);
//            System.out.println("list=" + list);
//        }

//        sort(List)：依据元素的天然程序对指定 List 汇合元素按升序排序
        Collections.sort(list);
        System.out.println("天然排序后");
        System.out.println("list=" + list);
//        sort(List，Comparator)：依据指定的 Comparator 产生的程序对 List 汇合元素进行排序
        // 咱们心愿依照 字符串的长度大小排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 能够退出校验代码.
                return ((String) o2).length() - ((String) o1).length();}
        });
        System.out.println("字符串长度大小排序 =" + list);
//        swap(List，int，int)：将指定 list 汇合中的 i 处元素和 j 处元素进行替换

        // 比方
        Collections.swap(list, 0, 1);
        System.out.println("替换后的状况");
        System.out.println("list=" + list);

        //Object max(Collection)：依据元素的天然程序，返回给定汇合中的最大元素
        System.out.println("天然程序最大元素 =" + Collections.max(list));
        //Object max(Collection，Comparator)：依据 Comparator 指定的程序，返回给定汇合中的最大元素
        // 比方，咱们要返回长度最大的元素
        Object maxObject = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {return ((String)o1).length() - ((String)o2).length();}
        });
        System.out.println("长度最大的元素 =" + maxObject);


        //Object min(Collection)
        //Object min(Collection，Comparator)
        // 下面的两个办法，参考 max 即可

        //int frequency(Collection，Object)：返回指定汇合中指定元素的呈现次数
        System.out.println("tom 呈现的次数 =" + Collections.frequency(list, "tom"));

        //void copy(List dest,List src)：将 src 中的内容复制到 dest 中

        ArrayList dest = new ArrayList();
        // 为了实现一个残缺拷贝，咱们须要先给 dest 赋值，大小和 list.size()一样
        for(int i = 0; i < list.size(); i++) {dest.add("");
        }
        // 拷贝
        Collections.copy(dest, list);
        System.out.println("dest=" + dest);

        //boolean replaceAll(List list，Object oldVal，Object newVal)：应用新值替换 List 对象的所有旧值
        // 如果 list 中，有 tom 就替换成 汤姆
        Collections.replaceAll(list, "tom", "汤姆");
        System.out.println("list 替换后 =" + list);
    }
}

1. 编程题按要求实现:
(1) 封装一个新闻类，蕴含题目和内容属性，提供 get、set 办法，重写 toString 办法，打印对象时只打印题目;

(2) 只提供一个带参数的结构器，实例化对象时，只初始化题目; 并且实例化两个对象: 新闻一: 新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担心
新闻二: 女子忽然想起 2 个月前钓的鱼还在网兜里，捞起一看连忙放生

(3) 将新闻对象增加到 ArrayList 汇合中，并且进行倒序遍历;

(4) 在遍历汇合过程中，对新闻标题进行解决，超过 15 字的只保留前 15 个，而后在后边加“….”

(5)在控制台打印遍历出通过解决的新闻标题;

package com.hspedu.homework;

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class Homework01 {public static void main(String[] args) {ArrayList arrayList = new ArrayList();
        arrayList.add(new News("新冠确诊病例超千万，数百万印度教信徒赴恒河 \" 圣浴 \"引民众担心"));
        arrayList.add(new News("女子忽然想起 2 个月前钓的鱼还在网兜里，捞起一看连忙放生"));

        int size = arrayList.size();
        for (int i = size - 1; i >= 0; i--) {//System.out.println(arrayList.get(i));
            News news = (News)arrayList.get(i);
            System.out.println(processTitle(news.getTitle()));
        }

    }
    // 专门写一个办法，解决事实新闻标题 process 解决
    public static String processTitle(String title) {if(title == null) {return "";}

        if(title.length() > 15) {return title.substring(0, 15) + "..."; //[0,15)
        } else {return title;}

    }
}

/**
 * 按要求实现：* (1) 封装一个新闻类，蕴含题目和内容属性，提供 get、set 办法，重写 toString 办法，打印对象时只打印题目；* (2) 只提供一个带参数的结构器，实例化对象时，只初始化题目；并且实例化两个对象：* 新闻一：新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担心
 * 新闻二：女子忽然想起 2 个月前钓的鱼还在网兜里，捞起一看连忙放生
 * (3) 将新闻对象增加到 ArrayList 汇合中，并且进行倒序遍历；* (4) 在遍历汇合过程中，对新闻标题进行解决，超过 15 字的只保留前 15 个，而后在后边加“…”* (5) 在控制台打印遍历出通过解决的新闻标题；*/
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. 编程题

应用 ArrayList 实现对对象 Car {name, price}的各种操作

1.add: 增加单个元素

2.remove: 删除指定元素

3.contains: 查找元素是否存在

4.size: 获取元素个数

5.isEmpty: 判断是否为空 6.clear: 清空

7.addAll: 增加多个元素

8.containsAl: 查找多个元素是否都存在

9.removeAll: 删除多个元素

应用加强 for 和迭代器来遍历所有的 car，须要重写 Car 的 toString 办法

package com.hspedu.homework;

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

@SuppressWarnings({"all"})
public class Homework02 {public static void main(String[] args) {ArrayList arrayList = new ArrayList();
        Car car = new Car("宝马", 400000);
        Car car2 = new Car("宾利",5000000);
        //1.add: 增加单个元素
        arrayList.add(car);
        arrayList.add(car2);
        System.out.println(arrayList);
        //* 2.remove: 删除指定元素
        arrayList.remove(car);
        System.out.println(arrayList);
        //* 3.contains: 查找元素是否存在
        System.out.println(arrayList.contains(car));//F
        //* 4.size: 获取元素个数
        System.out.println(arrayList.size());//1
        //* 5.isEmpty: 判断是否为空
        System.out.println(arrayList.isEmpty());//F
        //* 6.clear: 清空
        //System.out.println(arrayList.clear(););
        //* 7.addAll: 增加多个元素
        System.out.println(arrayList);
        arrayList.addAll(arrayList);// 2 个宾利
        System.out.println(arrayList);
        //* 8.containsAll: 查找多个元素是否都存在
        arrayList.containsAll(arrayList);//T
        //* 9.removeAll：删除多个元素
        //arrayList.removeAll(arrayList); // 相当于清空
        //* 应用加强 for 和 迭代器来遍历所有的 car , 须要重写 Car 的 toString 办法

        for (Object o : arrayList) {System.out.println(o);//
        }
        System.out.println("=== 迭代器 ===");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {Object next =  iterator.next();
            System.out.println(next);

        }

    }
}
/**
 * 应用 ArrayList 实现对 对象 Car {name, price} 的各种操作
 * 1.add: 增加单个元素
 * 2.remove: 删除指定元素
 * 3.contains: 查找元素是否存在
 * 4.size: 获取元素个数
 * 5.isEmpty: 判断是否为空
 * 6.clear: 清空
 * 7.addAll: 增加多个元素
 * 8.containsAll: 查找多个元素是否都存在
 * 9.removeAll：删除多个元素
 * 应用加强 for 和 迭代器来遍历所有的 car , 须要重写 Car 的 toString 办法
 */
class Car {
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.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 String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

3. 编程题，按要求实现下列工作

1) 应用 HashMap 类实例化一个 Map 类型的对象 m，键 (String) 和值 (int) 别离用于存储员工的姓名和工资，存入数据如下:jack—650 元; tom—1200 元; smith——2900 元;
2) 将 jack 的工资更改为 2600 元
3) 为所有员工工资加薪 100 元;
4) 遍历汇合中所有的员工
5) 遍压售合听有的工咨

package com.hspedu.homework;

import java.util.*;

@SuppressWarnings({"all"})
public class Homework03 {public static void main(String[] args) {Map m = new HashMap();
        m.put("jack", 650);//int->Integer
        m.put("tom", 1200);//int->Integer
        m.put("smith", 2900);//int->Integer
        System.out.println(m);

        m.put("jack", 2600);// 替换，更新
        System.out.println(m);

        // 为所有员工工资加薪 100 元；//keySet
        Set keySet = m.keySet();
        for (Object key : keySet) {
            // 更新
            m.put(key, (Integer)m.get(key) + 100);
        }
        System.out.println(m);

        System.out.println("============= 遍历 =============");
        // 遍历 EntrySet
        Set entrySet = m.entrySet();
        // 迭代器
        Iterator iterator = entrySet.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 value : values) {System.out.println("工资 =" + value);
        }

    }
}
/**
 * 按要求实现下列工作
 * 1）应用 HashMap 类实例化一个 Map 类型的对象 m，键（String）和值（int）别离用于存储员工的姓名和工资，* 存入数据如下：jack—650 元；tom—1200 元；smith——2900 元；* 2）将 jack 的工资更改为 2600 元
 * 3）为所有员工工资加薪 100 元；* 4）遍历汇合中所有的员工
 * 5）遍历汇合中所有的工资
 */

4. 简答题

试剖析 HashSet 和 TreeSet 别离如何实现去重的

(1) HashSet 的去重机制:hashCode() + equals() , 底层先通过存入对象, 进行运算失去一个 hash 值，通过 hash 值得到对应的索引，如果发现 table 索引所在的地位, 没有数据，就间接寄存如果有数据，就进行 equals 比拟[遍历比拟]，如果比拟后，不雷同，就退出，否则就不退出。

(2)TreeSet 的去重机制: 如果你传入了一个 Comparator 匿名对象，就应用实现的 compare 去重，如果办法返回 0，就认为是雷同的元素 / 数据，就不增加，如果你没有传入一个 Comparator 匿名对象, 则以你增加的对象实现的 Compareable 接口的 compareTo 去重。

5. 代码分析题

上面代码运行会不会抛出异样，并从源码层面阐明起因。[考查读源码+接口编程 + 动静绑定]

TreeSet treeSet = new TreeSet();
treeSet.add(new Person());

package com.hspedu.homework;
import java.util.TreeSet;

@SuppressWarnings({"all"})
public class Homework05 {public static void main(String[] args) {TreeSet treeSet = new TreeSet();
        // 剖析源码
        //add 办法，因为 TreeSet() 结构器没有传入 Comparator 接口的匿名外部类
        // 所以在底层 Comparable<? super K> k = (Comparable<? super K>) key;
        // 即 把 Perosn 转成 Comparable 类型
        treeSet.add(new Person());//ClassCastException.
        treeSet.add(new Person());//ClassCastException.
        System.out.println(treeSet);

    }
}
class Person implements Comparable{

    @Override
    public int compareTo(Object o) {return 0; // 重写，永远都是 0，此时就只能加一个对象}
}

6. 上面的代码输入什么? 这道题很有意思, 稍不留神就掉进陷阱.

已知: Person 类依照 id 和 name 重写了 hashCode 和 equals 办法（id 和 name 雷同的话就认定为同一个对象）, 问上面代码输入什么?

package com.hspedu.homework;

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

@SuppressWarnings({"all"})
public class Homework06 {public static void main(String[] args) {HashSet set = new HashSet();//ok
        Person p1 = new Person(1001,"AA");//ok
        Person p2 = new Person(1002,"BB");//ok
        set.add(p1);//ok
        set.add(p2);//ok
        p1.name = "CC"; // 批改了原 p1 的 name 为 CC
        set.remove(p1); // 可能删除失败，这里删除 p1 依照以后的 1001 和 CC 计算 hash，那么这对应的地位与原 p1 不同
        System.out.println(set);// 2
        set.add(new Person(1001,"CC")); // 能够增加胜利，增加到原本要删除的 p1（理论删除失败）的地位
        System.out.println(set);// 3
        set.add(new Person(1001,"AA")); // 能够增加，因为原 p1 曾经批改了
        System.out.println(set);// 4
    }
}

class Person {
    public String name;
    public int id;

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

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

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

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

7. 试写出 Vector 和 ArrayList 的比拟?

汇合的了解和益处

数组

汇合

汇合的框架体系

Collection 接口和罕用办法

Collection 接口实现类的特点

Collection 接口遍历元素形式 1 - 应用 Iterator

Collection 接口遍历对象形式 2 -for 循环加强

List 接口和罕用办法

List 接口根本介绍

List 接口的罕用办法

List 接口课堂练习

List 的三种遍历形式[ArrayList, LinkedList,Vector]

实现类的课堂练习 2

ArrayList 底层构造和源码剖析

ArrayList 的注意事项

ArrayList 的底层操作机制源码剖析

Vector 底层构造和源码分析

Vector 的根本介绍

Vector 和 ArrayList 的比拟

LinkedList 底层构造

LinkedList 的全面阐明

LinkedList 的底层操作机制

LinkedList 的增删改查案例

ArrayList 和 LinkedList 比拟

ArrayList 和 LinkedList 的比拟

Set 接口和罕用办法

Set 接口根本介绍

Set 接口的罕用办法

Set 接口的遍历形式

Set 接口的罕用办法举例

Set 接口实现类 -HashSet

HashSet 的全面阐明

HashSet 案例阐明

HashSet 底层机制阐明

实例测试

HashSet 课堂练习 1

Set 接口实现类 -LinkedHashSet

LinkedHashSet 的全面阐明

LinkedHashSet 课后练习题

Map 接口和罕用办法

Map 接口实现类的特点[实用]

Map 接口罕用办法

Map 接口遍历办法

Map 接口课堂练习

Map 接口实现类 -HashMap

HashMap 小结

HashMap 底层机制及源码分析

Map 接口实现类 -Hashtable

HashTable 的根本介绍

Hashtable 和 HashMap 比照

Map 接口实现类 -Properties

根本介绍

根本应用

总结 - 开发中如何抉择汇合实现类!

TreeSet

TreeMap

Collections 工具类

Collections 工具类介绍

排序操作（均为 static 办法)

查找、替换

本章作业