类集的归纳

CodeDunkster

已于 2022-04-24 21:01:39 修改

阅读量511

点赞数 1

分类专栏：类集知识总结文章标签： java

于 2021-03-15 21:39:40 首次发布

本文链接：https://blog.csdn.net/weixin_54574094/article/details/114369182

版权

类集知识总结专栏收录该内容

1 篇文章 0 订阅

订阅专栏

类集归纳

前言
类集的基本组成
总结

前言

因为数组的长度在给定时是固定的，在存储新的数据时需要动态扩容，并且数组在内存中的存储地址是连续的导致在增删元素时还需要对下标进行移动以防在遍历输出时出现空指针异常，因此为了提高效率，JAVA官方引入了类集这些个数据结构。

类集的基本组成

在这里插入图片描述

注释：Iterator与ListIterator作用范围区别在于前者只能迭代Collection而后者范围更小只能迭代Collection下的子接口List。

一、Iterator

1.Iterator

作用：类集是java对各种数据结构的实现，有些数据结构无下标，需要利用迭代器Iterator去进行遍历输出。
以下是它的运行过程：在这里插入图片描述
迭代器像指针一样，刚开始指向的位置是0下标的上面，当调用hasNext方法时会对下一个元素进行有无的判断，返回Boolean类型，而调用next方法时是将指针向下移动一位并且返回此时指针所指向的值，直到下一个位置无元素时停止遍历。

方法	详情
boolean hasNext()	如果该位置含有元素则返回true否则返回false
E next()	将hasNext处的元素返回并且将迭代下一个元素
default void remove()	删除此时指针所指向的元素，需要获取完数据才能删除，不然会出现异常

代码如下（示例）：

package com.java.demo2;

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

public class Demo10 {
    public static void main(String args[]){
        ArrayList<Integer> data = new ArrayList<>();
        data.add(1);
        data.add(2);
        data.add(3);
        Iterator<Integer> it = data.iterator();
       /* while(it.hasNext()){
            System.out.println(it.next());//输出结果为：1、2、3
        }*/
        Integer temp = it.next();//将迭代器向下移动一位同时返回该值
        System.out.println(temp);//对temp进行输出
        System.out.print("--------");
        System.out.println();
        it.remove();//删除指针所指向的元素（此时为0下标）
        while(it.hasNext()){
            System.out.print(it.next()+" ");//输出结果为：2、3
        }
    }
}

2.ListIterator

ListIterator的运行过程和Iterator的运行过程相同，以下是它所包含的方法。

方法	详情
void add(E e)	将指定的元素插入列表（可选操作）
boolean hasNext()	如果此列表迭代器在向前遍历列表时具有更多元素，则返回 true
E next()	返回列表中的下一个元素并前进光标位置
boolean hasPrevious()	如果此列表迭代器在反向遍历列表时具有更多元素，则返回 true
int nextIndex()	返回后续调用 next()将返回的元素的索引
E previous()	返回列表中的上一个元素并向后移动光标位置
void remove()	从列表中删除 next()或 previous() （可选操作）返回的最后一个元素
int previousIndex()	返回后续调用 previous()将返回的元素的索引
void set(E e)	用指定的元素替换 next()或 previous()返回的最后一个元素（可选操作）

注释：相较于Iterator来说ListIterator除了hasNext、remove（ListIterator的remove无返回值）、next方法外还多出了许多别的方法。其中previous方法和next方法类似，只不过移动光标的方向是相反的。

代码如下（示例）：

package com.java.demo2;

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

public class Demo10 {
    public static void main(String args[]){
        ArrayList<Integer> data = new ArrayList<>();
        data.add(1);
        data.add(2);
        data.add(3);
        ListIterator<Integer> it = data.listIterator();
        it.add(666);//向光标处添加元素，此时的光标在0下标的上方，当通过ListIterator调用add方法时，所有下标都会自动加一。此时666所在下标就为0
       /* while(it.hasNext()){
            System.out.println(it.next());//输出结果为：1、2、3
        }*/
        it.previous();//需要将光标上移才能够输出光标此时的元素
        while(it.hasNext()) {
            System.out.print(it.next()+" ");//输出结果为666、1、2、3
        }
        //此时光标已经下移到了下标为4处
        System.out.println();
        System.out.println("----------");
        //从下标为4处向下标为0处反向遍历
        while(it.hasPrevious()){
            System.out.print(it.previous()+" ");//输出结果为：3、2、1、666
        }
        //此时光标在0下标的上，需要将光标下移一个才有数据，才能进行删除
        it.next();
        it.remove();//删除后光标位置不变，下标全部-1
        System.out.println();
        System.out.print(data);
        System.out.println(it.nextIndex());//输出下标为0
    }
}

二、Collection

Collection单值存储(每次存储只能存一个对象)集合的顶级父接口。因为Collection接口不常用，我们常用的是List和Set这两个子接口里面的类，因此我们主要讲解ArrayList、LinkedList、Vector。
在这里插入图片描述

1、List

List集合可以存储重复的元素。

1、ArrayList

构造器	描述
ArrayList()	构造一个初始容量为10的空列表。
ArrayList(int initialCapacity)	构造具有指定初始容量的空列表。
ArrayList(Collection<? extends E> c)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

注：每次数组长度需要扩容时，会扩大到原来数组长度的1.5倍。在通过无参构造器构造时，ArrayList的数组长度为0，在调用add方法时，长度才会扩大到10。

ArrayList主要方法以及代码演示如下：

package com.java.demo2;

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

//if语句若是没有加{}则只管它下面的那一行代码
public class Demo1 {
    public static void main(String args[]){
        //创建两个ArrayList集合data、data1
        ArrayList<Integer> data = new ArrayList<>();
        ArrayList<Integer> data1 = new ArrayList<>();
        //1、void ensureCapacity(int minCapacity) 如有必要，增加此 ArrayList实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
        data1.ensureCapacity(10);
        //2、boolean add(E e) 将指定的元素追加到此列表的末尾，并且只返回true
        data1.add(1);
        data1.add(2);
        data.add(100);
        data.add(200);
        data.add(300);
        data.add(400);
        //3、void add(int index, E element) 将指定元素插入此列表中的指定位置，其它元素依次往后移
        data.add(0,123);
        //4、data.size指的是有效数据的长度而不是data数组的总长度
        System.out.println(data.size());//输出结果：5
        System.out.println(data);//输出结果：[123, 100, 200, 300, 400]
        //5、boolean addAll(int index, Collection<? extends E> c) 从指定位置开始，将指定集合中的所有元素插入此列表。
        data.addAll(0,data1);
        System.out.println(data);//输出结果：[1, 2, 123, 100, 200, 300, 400]
        //6、boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。
        System.out.println(data.contains(200));//输出结果：true
        //7、E get(int index) 返回此列表中指定位置的元素。
        System.out.println(data.get(1));//输出结果：2
       /* 8.data.clear();用于清除所有元素
        System.out.println(data.size());输出结果：0*/
        //9、Object clone() 返回此 ArrayList实例的浅表副本。
        System.out.println(data.clone());//输出结果：[1, 2, 123, 100, 200, 300, 400]
        //10、E remove(int index) 删除此列表中指定位置的元素，并且返回该元素
        Integer a = data.remove(2);
        System.out.println(a);//输出结果：123
        //11、boolean remove(Object o) 从该列表中删除指定元素的第一个匹配项（如果存在）。
        data.remove((Object)400);
        System.out.println(data.clone());
       /* data.clear();清空所有元素
        12、boolean isEmpty() 如果此列表不包含任何元素，则返回true
        System.out.println(data.isEmpty());输出结果：true*/
        //13、boolean removeAll(Collection<?> c) 从此列表中删除指定集合中包含的所有元素。
        data.removeAll(data1);
        System.out.println(data);//输出结果：[100, 200, 300]
        //14、E set(int index, E element) 用指定的元素替换此列表中指定位置的元素
        data.set(0,666);
        System.out.println(data);//输出结果：[666, 200, 300]
        //15、List<E> subList(int fromIndex, int toIndex) 返回指定的[fromIndex,toIndex)内容
        System.out.println(data.subList(0,1));//输出结果：[666]
        //16、ListIterator<E> listIterator(int index) 从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
        ListIterator<Integer> it = data.listIterator(1);
        //迭代器遍历
        while(it.hasNext()){
            System.out.print(it.next()+" ");
            //输出结果：200 300
        }
        System.out.println();
        System.out.println("----------");
        //17、Object[] toArray() 以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
        Object[]temp = data.toArray();
        for (int i = 0; i <temp.length; i++) {
            System.out.print(temp[i]+" ");
            //输出结果：666 200 300 
        }
        System.out.println();
        //18、int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。  
        System.out.println(data.lastIndexOf((Object)100));
        //输出结果：-1（因为不包含元素100）
    }
}

小结：ArrayList是以数组为底层数据结构（增删慢、查找快），以动态数组模式进行扩容。在数据初始化的集合长度是0，在调用add方法时自动扩容成10。线程不安全

2、LinkedList

构造器	描述
LinkedList()	构造一个空列表。
LinkedList(Collection<? extends E> c)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

LinkedList是不同于Arraylist是，它的底层数据结构是采用双向链表结构（增删快、查找慢），我们应该根据不同业务的需求去选择数据结构的使用。以下方法只演示相较于ArrayList多出来的。
主要方法以及代码演示如下：

package com.java.demo2;
import java.util.Iterator;
import java.util.LinkedList;
//Linklist的主要方法
public class Demo3 {
    public static void main(String args[]){
        //Linklist是双向链表结构 增删快，查找慢
        LinkedList<Integer> data = new LinkedList<>();
        data.add(2);
        data.add(200);
        data.add(2000);
        //hasNext只能够判断有无
        //next才能让它往下走并且取出
        Iterator<Integer> it = data.iterator();
        /*while (it.hasNext()){
            System.out.print(it.next()+" ");
        }*/
        //迭代器调用remove前需要调用next因为迭代器相当于指针需要指向东西
        //才可删除，不然会报错
        it.next();
        it.remove();
        System.out.print(data.size());
        //模仿弹栈与压栈
        System.out.println();
        System.out.println("-----");
        //压栈
        data.push(1);
        //弹栈
        System.out.println( data.pop());
        //首部添加
        data.addFirst(666);
        System.out.println( data.pop());
        //首部删除
        System.out.println(data.removeFirst());
        //尾部添加
        data.addLast(8888);
        //尾部删除
        System.out.println(data.removeLast());
        //首部获得
        System.out.println(data.getFirst());
        //尾部获得
        System.out.println(data.getLast());
        //首部添加和尾部添加常用于队列结构，让排头或排尾站一个人
    }
}

小结：LinkedList集合可以采用单端队列（头存尾取）或者双端队列（头存尾存、头取尾取）的形式进行数据的存储，或者是以栈的形式（先进先出）进行存取（压栈、弹栈）。

3、Vector

Vector相当于ArrayList的前身，也是也数组为底层数据结构（增删慢、查找快）如果不需要线程安全实现，建议使用ArrayList代替Vector 。

构造器	描述
Vector()	构造一个空向量，使其内部数据数组的大小为 10 ，其标准容量增量为零。
Vector(int initialCapacity)	构造一个具有指定初始容量且容量增量等于零的空向量
Vector(int initialCapacity, int capacityIncrement)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表
Vector(Collection<? extends E> c)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的向量。

注：Vector是一个可以指定每次扩容时容量增量的数据结构，每次数组长度需要扩容时，首先判断增量是否为0，若是为0，则在原有的数组长度上扩大一倍，若是不为0则按照指定增量进行扩容。

package com.java.demo2;

import java.util.Iterator;
import java.util.Vector;
//Vector的主要方法
public class Demo2 {
    public static void main(String args[]){
        //无参构造器的初始数组容量为10
        Vector<Integer> data = new Vector<>();
        //1、int capacity() 返回此向量的当前容量。
        System.out.println(data.capacity());//输出结果：10
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(2);
        //2、E firstElement() 返回此向量的第一个元素（索引 0处的项）。
        System.out.println(data.firstElement());//输出结果：2
        //3、int indexOf(Object o) 返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回-1。
        System.out.println(data.indexOf(2));//输出结果：0
        //4、int indexOf(Object o, int index) 返回此向量中第一次出现的指定元素的索引，从 index向后搜索，如果找不到该元素，则返回-1。
        System.out.println(data.indexOf(2,1));//输出结果：3
        //创建data的迭代器并迭代输出，迭代器相当于指针
        Iterator<Integer> it = data.iterator();
        //hasNext()只能判断该位置是否有元素，返回boolean类型
        //next()是将指针指的位置元素输出，并且将指针下移
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        System.out.println("------");
        //5、输出数组结构中最后一个元素
        System.out.println(data.lastElement());
        //采用foreach进行遍历输出
        for (Integer a:data) {
            System.out.print(a+" ");
        }
    }
}

小结：Vector的方法与ArrayList方法类似，如果不需要线程安全实现，建议使用ArrayList代替Vector 。

2、Set

Set集合不能存储重复的元素，并且无get方法获取数据，只能采用迭代器进行遍历输出或者是将其转换为数组在进行遍历输出或者foreach进行输出。

1、hashSet

构造器	描述
HashSet()	构造一个新的空集; HashMap实例具有默认初始容量（16）和加载因子（0.75）
HashSet(int initialCapacity)	构造一个新的空集; 支持HashMap实例具有指定的初始容量和默认加载因子（0.75）
HashSet(int initialCapacity, float loadFactor)	构造一个新的空集; 支持HashMap实例具有指定的初始容量和指定的加载因子
HashSet(Collection<? extends E> c)	构造一个包含指定集合中元素的新集合

注：hashSet对象的元素无序，底层数据结构是哈希表（哈希表式即HashMap实例化实现）的、是无序的，因此若是存储的对象可变则需要注意，因为不同对象的位置是不同的。为了弥补它的缺陷，他有一个子类LinkedHashSet，这可以保证他的有序性。

package com.java.demo2;

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

/*
Set集合下的子类HashSet:采用的是散装存放（哈希表式的存放）
它是没有get方法去获取数据的只能够通过迭代器或者运用toArray将其转换为数组在进行遍历取出且它是不能够存储重复元素的，因为它的存储形式是散装存储，所以是按照哈希表顺序存储而不是顺序存储
* */
public class Demo6 {
    public static void main(String args[]){
        HashSet<String> data = new HashSet<>();
        boolean flag1 = data.add("麻子");
        data.add("喜欢");
        data.add("二狗");
        boolean flag2 = data.add("麻子");
        //证明set集合是不能存储重复元素的
        System.out.println(flag1);//输出结果：true
        System.out.println(flag2);//输出结果：false
       /*运用迭代器进行输出遍历
       Iterator<String> iterator = data.iterator();
       while(iterator.hasNext()){
            System.out.println(iterator.next());
        }*/
        for (String s:data) {
            System.out.println(s);
        }//输出结果顺序：二狗、麻子、喜欢
    }
}

小结：hashSet是继承Collection接口，方法类似。这里代码主要演示hashSet不可存储相同数据以及存储无序的效果。

1、TreeSet

构造器	描述
TreeSet()	构造一个新的空树集，根据其元素的自然顺序进行排序。
TreeSet(Collection<? extends E> c)	构造一个新的树集，其中包含指定集合中的元素，并根据其元素的自然顺序进行排序。
TreeSet(Comparator<? super E> comparator)	构造一个新的空树集，根据指定的比较器进行排序。
TreeSet(SortedSet s)	构造一个包含相同元素并使用与指定有序集相同排序的新树集。
注：TreeSet的底层数据结构是二叉树（以TreeMap进行实实例化），可以实现对元素的排序。当然这仅限于系统内部的类，若是自己定义的类则需要继承Comparabale接口并且进行重写才能够进行排序

package com.java.demo2;

import java.util.Iterator;
import java.util.TreeSet;

/*
TressSet不同于HashSet ：它的存储是有序的（二叉树形式进行存储），有序指的是根据集合里面的内容TressSet给出的排列顺序（系统内部的类，如：Integer、Character等）
相同点：存储都是通过Map进行，且都不能存储相同的元素
* */
public class Demo7 {
    public static void main(String args[]){
        TreeSet<String> data = new TreeSet<>();
        data.add("D");
        data.add("A");
        data.add("C");
        data.add("B");
        //1、有输出结果可知道TreeSet会自动排序（仅限于系统内部的类）
        for (String s:data) {
            System.out.print(s+" ");//输出结果：A B C D
        }
        System.out.println();
        //2、Iterator<E> descendingIterator() 以降序返回此集合中元素的迭代器。
        Iterator<String> it = data.descendingIterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");//输出结果：D C B A
        }
        System.out.println();
        //3、NavigableSet<E> descendingSet() 返回此set中包含的元素的逆序视图。
        System.out.println(data.descendingSet());//输出结果:[D,C,B,A]
        //4、E first() 返回此集合中当前的第一个（排序后的第一个）元素。
        System.out.println(data.first());//输出结果：A
        //5、E last() 返回此集合中当前的最后一个（最高）元素。
        System.out.println(data.last());//输出结果：D
        //6、E floor(E e) 返回此set中小于或等于给定元素的最大元素，如果没有这样的元素，则 null 。
        System.out.println(data.floor("F"));//输出结果：D
        //7、E higher(E e) 返回此集合中的最小元素严格大于给定元素，如果没有这样的元素，则 null 。
        System.out.println(data.higher("A"));//输出结果：B
        //8、E lower(E e) 返回此集合中的最大元素严格小于给定元素，如果没有这样的元素，则 null 。
        System.out.println(data.lower("D"));//输出结果：C
        System.out.println("--------------");
        //9、SortedSet<E> subSet(E fromElement, E toElement) 返回此set的部分视图，其元素范围从 fromElement （包括）到 toElement （不包括）。  
        System.out.println(data.subSet("A","D"));
        //10、E pollFirst() 检索并删除第一个（最低）元素，如果此组为空，则返回 null 。
        System.out.println(data.pollFirst());//输出结果：A
        System.out.println(data.clone());//输出结果：[B,C,D]
        //11、E pollLast() 检索并删除最后一个（最高）元素，如果此集合为空，则返回 null 。
        System.out.println(data.pollLast());//输出结果：D
        System.out.println(data.clone());//输出结果：[B,C]
        //12、E ceiling(E e) 返回此set中大于或等于给定元素的 null元素，如果没有这样的元素，则 null 。
        System.out.println(data.ceiling("C"));
    }
}

补充：若向TreeSet中添加自己定义的类（非系统内部类）则需要该类继承Comparable接口并且根据自己的排列方法进行重写。
代码演示如下：

package com.java.demo2;

import java.util.Objects;
import java.util.TreeSet;

//在TreeSet中添加自己定义的类时会报错（因为TreeSet的底层数据结构是二叉树是有序排列而自己定义的类系统内部无排列规则需要引入Comparable接口并重写）
//解决：需要自己定义排序方法，引入Compareable接口并且根据你想要的排列依据进行重写
//若是比较结果为相等那么后面添加的则添加失败（Set接口不能存储相同元素）
public class Demo8 {
    public static void main(String args[]){
        TreeSet<Person> data = new TreeSet<Person>();
        Person p1 = new Person("张三",18);
        Person p2 = new Person("李四",19);
        Person p3 = new Person("王五",20);
        //当添加的是自己定义的对象时需要引入Comparable接口并重写
        data.add(p1);
        data.add(p2);
        data.add(p3);
        for (Person p:data) {
            System.out.println(p.toString());
            //输出结果：(根据年龄进行排序)
            //Person{name='张三', age=18}
            //Person{name='李四', age=19}
            //Person{name='王五', age=20}
        }
    }
    //继承接口并指定类型 重写CompareTo方法
    static class Person implements Comparable<Person>{
        private String name;
        private int age;

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

        //需要自己重写Comparable
        @Override
        public int compareTo(Person o) {
            //拿this与o进行比较
            //若this<o返回负数 等于0 >正数
            if(this.age > o.age){
                return 1;
            }else if(this.age == o.age){
                return 0;
            }
            return -1;
        }

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

        @Override
        public int hashCode() {
            return Objects.hash(name, 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 Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public Person() {
        }
    }
}

小结：TreeSet是继承Collection接口，方法类似。这里代码主要演示TreeSet独有的方法以及向TreeSet中添加非系统内部类时的解决方法（继承并且重写Comparable接口）。

三、Map

Map与List、Set接口不同，它是由一系列键–值对组成的集合，提供了key到Value的映射，一个key对应一个value或者是一个Value对应多个Key（即不允许Key相同，Value可以相同），且Map接口不常用，这里主要讲解HashMap、TreeSet、HashTable

1、HashMap

构造器	描述
HashMap()	使用默认初始容量（16）和默认加载因子（0.75）构造一个空 HashMap
HashMap(int initialCapacity)	使用指定的初始容量和默认加载因子（0.75）构造一个空 HashMap
HashMap(int initialCapacity, float loadFactor)	使用指定的初始容量和加载因子构造一个空 HashMap
HashMap(Map<? extends K,? extends V> m)	构造一个新的 HashMap ，其映射与指定的 Map相同

注：HashMap是基于哈希表的Map集合的接口的实现，此操作提供了所有可选的键值对操作，且允许null键和null值（ HashMap类大致相当于Hashtable ，除了它是不同步的并且允许空值。）此类不保证存储顺序，因此若是存储的对象是可变的不建议使用。

package com.java.demo2;

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

//Map
public class Demo9 {
    public static void main(String args[]){
        Map<Integer,String> data = new HashMap<>();
        //V put(K key, V value) 将指定的值与此映射中的指定键相关联。
        data.put(1,"二狗");
        data.put(2,"鸭蛋");
        //在map中键不能重复，重复了之后会将新的值替换掉旧的值并且size不变
        data.put(3,"麻子");
        data.put(3,"二风");
        //通过data.keySet.iterator创建key的迭代器，获取key,然后通过key得到对应的value（map.get（Object key））
        Iterator<Integer> iterator = data.keySet().iterator();
        while(iterator.hasNext()){
            Integer key = iterator.next();
            String value = data.get(key);
            System.out.print(value+" ");//输出结果：二狗 鸭蛋 二风
        }
        System.out.println();
        /*foreach进行遍历
        for (Integer key:data.keySet()) {
            System.out.print(data.get(key)+" ");
        }*/
        Set<Integer> integers = data.keySet();
        //V get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
        for (int t:integers) {
            System.out.print(t+"->"+data.get(t)+" ");//输出结果：1->二狗 2->鸭蛋 3->二风
        }
        System.out.println();
        //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
        System.out.println(data.containsKey(8));//输出结果：false
        //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true 。
        System.out.println(data.containsValue("二风"));//输出结果：true
        //int size() 返回此映射中键 - 值映射的数量。
        System.out.println(data.size());//输出结果：3
        //Set<K> keySet() 返回此映射中包含的键的Set视图。
        System.out.println(data.keySet());//输出结果：[1, 2, 3]
        //default V replace(K key, V value) 仅当指定键当前映射到某个值时，才替换该条目的条目。
        data.replace(2,"老神仙");
        System.out.println(data);//输出结果：{1=二狗, 2=老神仙, 3=二风}
        //default boolean replace(K key, V oldValue, V newValue) 仅当前映射到指定值时，才替换指定键的条目。
        data.replace(3,"二风","少年郎");
        System.out.println(data);//输出结果：{1=二狗, 2=老神仙, 3=少年郎}
        //default boolean remove(Object key, Object value) 仅当指定键当前映射到指定值时才删除该条目的条目。
        System.out.println(data.remove(1,"二狗"));//输出结果：true
        //V remove(Object key) 如果存在，则从该映射中移除键的映射，并且返回此键对应的值。
        System.out.println(data.remove(2));//输出结果：老神仙
    }
}

2、TreeMap

构造器	描述
TreeMap()	使用其键的自然顺序构造一个新的空树图。
TreeMap(Comparator<? super K> comparator)	构造一个新的空树图，根据给定的比较器排序。
HashMap(int initialCapacity, float loadFactor)	使用指定的初始容量和加载因子构造一个空 HashMap
HashMap(Map<? extends K,? extends V> m)	构造一个新的 HashMap ，其映射与指定的 Map相同

TreeMap采用二叉树结构进行数据的存储，是TreeSet的存储数据的形式的实现方式。且TreeMap和TreeSet的方法相类似，不同于HashMap的是多出对于首个元素和尾部元素的获取删除以及对于视图的逆向显示等操作。

package com.java.demo2;

import java.util.TreeMap;
import java.util.TreeSet;

//TreeSet
public class Demo10 {
    public static void main(String args[]){
        TreeMap<Integer,String> data = new TreeMap<>();
        //V put(K key, V value) 将指定的值与此映射中的指定键相关联。
        data.put(1,"二狗");
        data.put(2,"鸭蛋");
        data.put(3,"麻子");
        data.put(4,"二风");
        //K ceilingKey(K key) 返回大于或等于给定键如果没有这样的键，则返回 null
        System.out.println(data.ceilingKey(2));//输出结果：2
        //Map.Entry<K,V> ceilingEntry(K key) 返回与大于或等于给定键的最小键关联的键 - 值映射，如果没有此键，则 null 。
        System.out.println(data.ceilingEntry(3));//输出结果：3=麻子
        //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
        System.out.println(data.containsKey(1));//输出结果：true
        //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true
        System.out.println(data.containsValue("二风"));//输出结果：true
        //NavigableSet<K> descendingKeySet() 返回此映射中包含的键的反向顺序视图。
        System.out.println(data.descendingKeySet());//输出结果:[4, 3, 2, 1]
        //NavigableMap<K,V> descendingMap() 返回此映射中包含的映射的逆序视图。
        System.out.println(data.descendingMap());//输出结果：{4=二风, 3=麻子, 2=鸭蛋, 1=二狗}
        //Map.Entry<K,V> firstEntry() 返回与此映射中的最小键关联的键 - 值映射，如果映射为空，则 null 。
        System.out.println(data.firstEntry());//输出结果：1=二狗
        //K firstKey() 返回此映射中当前的第一个（最低）键。
        System.out.println(data.firstKey());//输出结果：1
        //Map.Entry<K,V> floorEntry(K key) 返回与小于或等于给定键的最大键关联的键 - 值映射，如果没有此键，则 null 。
        System.out.println(data.floorEntry(2));//输出结果：2=鸭蛋
        //K floorKey(K key) 返回小于或等于给定键的最大键，如果没有这样的键，则 null 。
        System.out.println(data.floorKey(2));//输出结果：2
        //SortedMap<K,V> headMap(K toKey) 返回此映射的部分视图，其键严格小于 toKey 。
        System.out.println(data.headMap(2));//输出结果：{1=二狗}
        //K higherKey(K key) 返回严格大于给定键的最小键，如果没有这样的键，则返回 null 。
        System.out.println(data.higherKey(2));//输出结果：3
        //K lastKey() 返回此映射中当前的最后一个（最高）键。
        System.out.println(data.lastKey());//输出结果：4
        //K lowerKey(K key) 返回严格小于给定键的最大键，如果没有这样键，则返回 null 。
        System.out.println(data.lowerKey(2));//输出结果：1
        //Map.Entry<K,V> pollFirstEntry() 删除并返回与此映射中的最小键关联的键 - 值映射，如果映射为空，则 null 。
        System.out.println(data.pollFirstEntry());//输出结果：1=二狗
        System.out.println(data);//输出结果：{2=鸭蛋, 3=麻子, 4=二风}
        //SortedMap<K,V> subMap(K fromKey, K toKey) 返回此映射部分的视图，其键的范围从 fromKey （不包括）到 toKey（不包括）
        System.out.println(data.subMap(2,3));//输出结果：{2=鸭蛋}
    }
}

3、HashTable

Hashtable的使用不被推荐，因为HashMap提供了所有类似的功能，并且速度更快。

总结

Map接口和Collection接口都是包含在类集下的接口，Collection是单值存储集合的顶级父接口而Map是存储一个个键值对数据的接口。并且Collection接口下的Set子接口下的hashSet类和TreeSet类的数据存储的实现都是沿用Map接口下HashMap和TreeMap进行实例化。