Java集合框架-CSDN博客

本文链接：https://blog.csdn.net/qq_41578371/article/details/108790683

Java集合框架

集合框架Class类图

概述

/**
* 集合框架概述
* 1.集合和数组都是对多个数据进行存储操作的结构，简称Java容器
*   此时的存储是指内存方面，不涉及数据持久化操作
* 2.数组的特点(线性表：数组，链表)：
*    优：
*      一旦初始化长度确定
*      数据一旦定义，元素类型确定(object泛型)
*      访问速度快，方便查找(指定位置)
*    缺：
*      长度确定不可修改动态的添加扩容
*      数组中提供的方法非常有限，对于数据添加，删除，插入操作效率低，不方便需要移动元素。
*      获取数组实际元素长度没有现成方法。
*      数据存储的特点有序，可重复。对于无序，不可重复的需求不能满足。
* Java集合可分为：Collection 和 Map体系
*    Collection接口 单列数据(注意集合元素比较，需要元素类型重写equals方法)：
*       list 有序可重复 动态数组长度可变:
*       set 无序不可重复，
*       Map接口 双列数据 key-value:
*       有序无序指的是内存空间是否连续      
* Iterator迭代器接口(迭代器设计模式的一种)：
*       主要用来遍历集合，不涉及Map
*       迭代器设计模式的定义提供一种方法访问容器中的元素，不需要暴露该对象内部细节。迭代器模式为容器而生
*       hasNext()(判断后续元素是否存在),next()方法(指针移动)，底层就是指针的移动(线性表)
*       remove() 遍历过程中可以通过迭代器的remove()移除集合中的元素，next后调用remove()
*foreach(jdk1.5之后的增强for循环)
* 工具类Collections java.util,用来提供集合的操作
* 字符串可以称为字符的容器
*集合在进行使用时，需要重写保存类的equals()和hashcode()方法。
* @author stack
*/

list集合框架图

Collection常用方法(集合的基类)

@Test
    public void test1(){
        //在集合中设计到元素之间比对都需要equals方法支持。

        //不指定具体类型默认是Object类
        Collection collection=new ArrayList();
        //添加单一元素 add()
        collection.add("aaa");
        collection.add(1);
        //添加集合所有元素 addALL()
        Collection collection1=new ArrayList();
        collection1.add("aaa");
        collection1.add(1);
        collection.addAll(collection1);
        System.out.println(collection.size());
        //isEmpty() 判断元素是否为空
        System.out.println(collection.isEmpty());
        //clear() 清空元素
        collection1.clear();
        System.out.println(collection1.size());
        //contains(object) 是否包含对象,判断内容是否包含,调用实际是equals方法
        System.out.println(collection.contains(1));
        //containsAll(Collection c)判断是否包含c集合全部元素
        List<String> a = Arrays.asList("123", "a");
        System.out.println(collection.containsAll(a));
        //remove(object o),移除第一个匹配的元素在集合中。
        System.out.println(collection.remove("aaa"));
        //removeAl(collection )移除集合中所包含的所有元素 求集合差集，要求所有元素存在才能正常移除
        System.out.println(collection.removeAll(collection1));
        System.out.println(collection.size());
        //retainAll(Collection) 获取当前两个集合交集并修改源集合
        System.out.println(collection.retainAll(Arrays.asList("123", "aaa")));
        System.out.println(collection.toString());
        //equals()集合元素对比，是否比较位置相同看具体集合类型
        System.out.println(collection.equals(Arrays.asList("aaa")));
        //hashCode()获取集合的hash值
        System.out.println(collection.hashCode());
        //toArray() 集合 --》数组装换
        System.out.println(collection.toArray());
        //Arrays.asList(泛型类型的可变形参) 数组--》集合
        System.out.println(Arrays.asList("aaa"));
        //iterator()返回一个集合的迭代器用于集合遍历
        Collection collection2=new ArrayList();//默认object类型
        collection2.add(1);
        collection2.add(2);
        Iterator iterator = collection2.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
    }

list接口及其实现类

/**
 * List接口
 * List集合类元素有序可重复，是动态数组(数组长度可变)
 * 可以按照位置进行索引获取元素。对应数据结构线性表
 * Collection接口
 *   List接口
 *      实现类      
 *      ArrayList：如果确定长度，建议使用初始长度的ArrayList,底层也是数组
 *      LinkedList
 *      Vector
 * ArrayList,LinkedList,Vector三者异同
 * 同： 三个类都实现了List接口，存储的数据都是有序可重复的
 * 不同： ArrayList： 作为List接口的主要实现类；线程不安全的，效率高;底层使用Object[]存储 elementData，查找效率高
 *       LinkedList：作为List接口的主要实现类；线程不安全的，效率高;底层使用双向链表(两个指针)。插入，移动元素效率高，不同于数组大量元素移动赋值。查找效率低
 *       Vector： 作为List接口的古老实现类；线程安全的(synchronized方法)，效率低，底层使用Object[]存储 elementData
 * 源码分析：
 *      ArrayList：
 *         jdk7：默认无参购造长度10的数组。 长度不够时grow方法扩容。默认扩容后为原来容量的1.5倍(右移运算)，底层Object数组。类似单例饿汉模式
 *         jdk8: 默认无参构造长度为0的数组，内存中没有创建。第一次调用add方法是才调用长度为10的Object操作，延迟数组创建过程，节省内存开销。类似单例懒汉模式
 *      LinkedList：
 *         jdk1.8中添加操作使用了尾插法进行扩容。Node<>(l, e, null);
 *      Vector：默认无参购造长度10的数组。 长度不够时grow方法扩容，方法上使用了synchronized，线程安全的，扩容默认为原来的2倍。
 * 遍历：
 *   迭代器
 *   foreach
 *   for循环
 * @author stack
 */

list常用方法

import java.util.ArrayList;
import java.util.Arrays;


/**
 * List接口
 * List集合类元素有序可重复，是动态数组(数组长度可变)
 * 可以按照位置进行索引获取元素。对应数据结构线性表
 * Collection接口
 *   List接口
 *      ArrayList：如果确定长度，建议使用初始长度的ArrayList,底层也是数组
 *      LinkedList
 *      Vector
 * ArrayList,LinkedList,Vector三者异同
 * 同： 三个类都实现了List接口，存储的数据都是有序可重复的
 * 不同： ArrayList： 作为List接口的主要实现类；线程不安全的，效率高;底层使用Object[]存储 elementData，查找效率高
 *       LinkedList：作为List接口的主要实现类；线程不安全的，效率高;底层使用双向链表(两个指针)。插入，移动元素效率高，不同于数组大量元素移动赋值。查找效率低
 *       Vector： 作为List接口的古老实现类；线程安全的(synchronized方法)，效率低，底层使用Object[]存储 elementData
 * 源码分析：
 *      ArrayList：
 *         jdk7：默认无参购造长度10的数组。 长度不够时grow方法扩容。默认扩容后为原来容量的1.5倍(右移运算)，底层Object数组。类似单例饿汉模式
 *         jdk8: 默认无参构造长度为0的数组，内存中没有创建。第一次调用add方法是才调用长度为10的Object操作，延迟数组创建过程，节省内存开销。类似单例懒汉模式
 *      LinkedList：
 *         jdk1.8中添加操作使用了尾插法进行扩容。Node<>(l, e, null);
 *      Vector：默认无参购造长度10的数组。 长度不够时grow方法扩容，方法上使用了synchronized，线程安全的，扩容默认为原来的2倍。
 * 遍历：
 *   迭代器
 *   foreach
 *   for
 * @author stack
 */
public class ListTest {
    public static void main(String[] args) {
              //默认为object[]数组
              ArrayList list=new ArrayList();
              list.add(1);
              list.add(2);
              list.add(3);
              System.out.println(list);
              //在指定位置掺入
              list.add(1,4);
              System.out.println(list);
              //在指定位置插集合
            list.addAll(2, Arrays.asList(5,6));
            System.out.println(list);
            //获取指定位置元素
            System.out.println(list.get(1));
            //返回元素在集合出现的位置
            System.out.println(list.indexOf(5));
            //返回元素在最后集合出现的位置
            System.out.println(list.lastIndexOf(6));
            //list对remove()按照索引删除元素 ,remove有两种重载，一种按索引删，一种按元素删
            System.out.println(list.remove(0));
            //修改指定位置元素
            list.set(0, 1);
            System.out.println(list);
            //返回指定位置的集合
            System.out.println(list.subList(1, 3));

    }
}

set接口

/**
 * Collection
 *   set接口: 无序，不重复数据，添加相同元素判定失败，判断元素是否相等调用的equals方法,散列表。散列是一种查找技术。
 *   存储元素依靠散列函数构建散列值(hashcode)，来寻找散列表中的位置进行数据存储。散列解决冲突：开放地址法，拉链法。
 *   不可重复性的存储首先要先判断hashcode的值。便是在散列中的位置是否相同。不同的话直接存储。如果相同再去调用equals方法，判断
 *   对象内容是否一样。如何一样的话判断重复。不一样的话就去解决散列冲突进行存储。底层散列表(开散列表)，通过拉链法解决冲突-链表存储。1.7链表头插，1.8尾插
 *   hashcode值让散列表的扩容，散列表采用的是数组。
 *     HashSet：
 *          set接口首要实现类，线程不安全的，可以存储null(底层存储是HashMap)
 *     LinkedHashSet:(底层也是HashMap)
 *          继承自HashSet子类，特点是加入前后指针，使得遍历时按照添加顺序输出，按照双向链表遍历输出，内存存储实际还是无序
 *          通过指针让LinkedHashSet看起来有序
 *     TreeSet:
 *           底层使用红黑树有序，放入红黑树的类是可以排序的，在红黑树中有序存储，可以安照对象指定属性排序。
 *           TreeSet添加的数据是相同类型。遍历顺序按照大小排序输出。排序需要重写两种排序方式自然排序(继承ComParable实现compareTo()方法)和定制排序(在TreeSet指定排序比较器Comparator实现Compare方法)。
 *           TreeSet(Comparator);
 *           自然排序: 比较两个对象相等的标准是compareTo Com
 *           定制排序: 比较两个对象相等的标准是compare
 *    向set元素中添加元素需要在类中重写HashCode,equals方法。重写的方法尽量保持一致性。
 *    set具有的方法同Collection一样。
 *
 * @author stack
 */

set底层数据结构图

TreeSet实现排序

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;

/**
 * Collection
 *   set接口: 无序，不重复数据，添加相同元素判定失败，判断元素是否相等调用的equals方法,散列表。散列是一种查找技术。
 *   存储元素依靠散列函数构建散列值(hashcode)，来寻找散列表中的位置进行数据存储。散列解决冲突：开放地址法，拉链法。
 *   不可重复性的存储首先要先判断hashcode的值。便是在散列中的位置是否相同。不同的话直接存储。如果相同再去调用equals方法，判断
 *   对象内容是否一样。如何一样的话判断重复。不一样的话就去解决散列冲突进行存储。底层散列表(开散列表)，通过拉链法解决冲突-链表存储。1.7链表头插，1.8尾插
 *   hashcode值让散列表的扩容，散列表采用的是数组。
 *     HashSet：
 *          set接口首要实现类，线程不安全的，可以存储null(底层存储是HashMap)
 *     LinkedHashSet:(底层也是HashMap)
 *          继承自HashSet子类，特点是加入前后指针，使得遍历时按照添加顺序输出，按照双向链表遍历输出，内存存储实际还是无序
 *          通过指针让LinkedHashSet看起来有序
 *     TreeSet:
 *           底层使用红黑树有序，放入红黑树的类是可以排序的，在红黑树中有序存储，可以安照对象指定属性排序。
 *           TreeSet添加的数据是相同类型。遍历顺序按照大小排序输出。排序需要重写两种排序方式自然排序(继承ComParable实现compareTo)和定制排序(在TreeSet指定排序比较器)。
 *           TreeSet(Comparator);
 *           自然排序: 比较两个对象相等的标准是compareTo
 *           定制排序: 比较两个对象相等的标准是compare
 *    向set元素中添加元素需要在类中重写HashCode,equals方法。重写的方法尽量保持一致性。
 *    set具有的方法同Collection一样。
 *
 * @author stack
 */
/*
排序练习 //treeSet需要实现排序接口底层红黑树
 */
/*
 排序结果返回模板 -1小于，0 相等，1 大于。
 return (x < y) ? -1 : ((x == y) ? 0 : 1);
 */

    //实现自然排序实现Comparable中的compareTo方法
class Employee implements Comparable<Employee>{
    private String name;
    private  int age;
    private int day;

    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 int getDay() {
        return day;
    }

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

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

    @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 &&
                day == employee.day &&
                Objects.equals(name, employee.name);
    }

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

    public Employee(){

    }

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

    @Override
    public int compareTo(Employee o) {
        //instanceof判断类型是否相同
        if(o instanceof Employee){
        //按照姓名排序
        return this.name.compareTo(o.getName());
        }throw new RuntimeException("类型不匹配");
    }
}

/**
 * @author stack
 */
public class SetTest {

    //自然排序按照姓名排序实现Comparable接口中的compareTo方法
    @Test
    public void test1() {
        TreeSet<Employee> treeSet=new TreeSet<>();
        Employee e1=new Employee("liudehua", 55, 5);
        Employee e2=new Employee("zhangxueyou", 50, 5);
        Employee e3=new Employee("liming", 54, 5);
        Employee e4=new Employee("guofucheng", 49, 5);
        Employee e5=new Employee("liangchaowei", 59, 5);

        treeSet.add(e1);
        treeSet.add(e2);
        treeSet.add(e3);
        treeSet.add(e4);
        treeSet.add(e5);

        Iterator<Employee> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //定制排序按照年龄排序构造器参数传递Comparator实现compare方法
    @Test
    public void test2(){
        TreeSet<Employee> treeSet=new TreeSet<>(
                new Comparator<Employee>() {
                    @Override
                    public int compare(Employee o1, Employee o2) {
                        if(o1 instanceof  Employee && o2 instanceof Employee) {
                            return Integer.compare(o1.getAge(), o2.getAge());
                        }else {
                            throw new RuntimeException("类型不匹配");
                        }
                    }
                }
        );
        Employee e1=new Employee("liudehua", 55, 5);
        Employee e2=new Employee("zhangxueyou", 50, 5);
        Employee e3=new Employee("liming", 54, 5);
        Employee e4=new Employee("guofucheng", 49, 5);
        Employee e5=new Employee("liangchaowei", 59, 5);

        treeSet.add(e1);
        treeSet.add(e2);
        treeSet.add(e3);
        treeSet.add(e4);
        treeSet.add(e5);

        Iterator<Employee> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

set集合可用于对重复元素进行筛选，因为set中存储元素无序不重复。set存储数据尤其要注意重写hashcode和equals方法，remove移除需要计算源对象的hash值而不是集合里面的hash值。list存储的元素是有序重复。实现时需要重写equals方法。
set：hashset,linkedhashset,TreeSet List:ArrayList,LinkedLisk,Vector(线程安全的)

Map

概述

/**
 * Map接口
 *   存储的是双列数据，存储的是key-value对的数据
 *   HashMap: 作为Map的实现类 线程不安全，效率高，可以存储null的Key和Value(健壮性高)
 *       底层hashMap(数组+链表)jdk1.7和JDK1.7之前//(数组+链表+红黑树)jdk1.8
 *       LinkedHashMap：有序键值对(添加了双向指针)保证遍历出来的顺序与添加顺序相同。
 *                     对于频繁的遍历操作，此类的执行效率高于HashMap
 *   TreeMap:对添加的key-value进行排序，实现有序遍历。对Key进行排序。考虑自然排序和定制排序。
 *           底层使用了红黑树(二插排序树，平衡).需要放入相同类型的key
 *   Hashtable:jdk1.0 古老的实现类 ，线程安全的，效率低,不可以存储null的Key和Value(健壮性低)
 *       Properties:map的一种。常用来处理配置文件。key和value都是String类型。
 *
 *面试题：
 *  1.hashMap底层实现原理
 *
 *  2.HashMap和HashTable的异同：
 *    hashMap:
 *    作为Map的实现类 线程不安全，效率高，可以存储null的Key和Value(健壮性高)
 *    底层hashMap(数组+链表)jdk1.7和JDK1.7之前//(数组+链表+红黑树)jdk1.8
 *    hashTable:
 *    jdk1.0 古老的实现类 ，线程安全的，效率低,不可以存储null的Key和Value(健壮性低)
 *
 *  3.CurrentHashMap与HashTable的异同
 *
 * Map结构：(key-value一一对应)
 *    key:无序，不可重复 --》key需要重写equals()和hashcode方法(hashMap)，重写自然排序和定制排序(TreeMap)
 *    value:无序，可重复
 *    一个key-value构成了一个entry对象，Entry是无序的，不可重复的。
 *
 * HashMap底层实现原理：
 *    jdk1.7:
 *    HashMap map =new HashMap():在实例化后在底层创建了一个长度为16的一维数组Entry[] table
 *    map.put(k,v):首先调用key的hashcode计算hash值，经过散列函数，得到在Entry数组存放位置。如果
 *                 此位置数据为空，则此时(k,v)entry添加成功。如果此位置数据不为空(代表着此位置存放一个或多个数据(链表形式))
 *                 ，比较key1和已经存在实体Entry的key的hash值，如果key的hash值与所有Entry的key的hash值的hash值不对，则添加成功
 *                 如果hash值与某一个存在的hash值相同，继续比较，调用key的equals方法比较，如果equals()比较结果不同，添加成功。如果比较
 *                 相同则使用新的value去替换覆盖老的value值。散列结构开散列采用的拉链法解决冲突。真实数据是在链表中存储的。数组只是记录的散列值便是散列地址。
 *                 在不断添加过程中设计扩容的问题(超出临界值且存放的位置非空)默认扩容方式扩容为entry数组原来容量的2倍，并将原有的copy过来。
 *                 元素添加采用了头插法。
 *   jdk1.8:
 *      HashMap map =new HashMap()；底层没有创建了一个长度为16的一维数组；数组为Node[];
 *      首次调用put方法时底层创建长度为16的数组。
 *      底层结构改为了数组+链表+红黑树
 *      当散列数组的的某一个索引位置上的元素以链表的形式存储的数据个数>8且散列值数组长度>64时，此时索引的位置上的所有
 *      数组改为红黑树(二叉排序查找树)存储。提高了存储和查找效率
 *
 *
 *名词：
 *   加载因子：默认值0.75，初始化hashMap ，提前扩容：提高hash表利用率，减少链表长度
 *   临界值：扩容的临界值，默认16*0.75
 *   默认初始化容量16
 *   链表长度：8 超过8时会转换成红黑树
 *   被树化时hash表的容量：64
 *
 * Map 常用方法
 *
 *说明：hash值并不等与散列值，散列值是在hash的基础上通过散列函数映射得到的。
 * @author stack
 */

map常用操作

import org.junit.Test;

import java.util.*;

/**
 * Map接口
 *   存储的是双列数据，存储的是key-value对的数据
 *   HashMap: 作为Map的实现类 线程不安全，效率高，可以存储null的Key和Value(健壮性高)
 *       底层hashMap(数组+链表)jdk1.7和JDK1.7之前//(数组+链表+红黑树)jdk1.8
 *       LinkedHashMap：有序键值对(添加了双向指针)保证遍历出来的顺序与添加顺序相同。
 *                     对于频繁的遍历操作，此类的执行效率高于HashMap
 *   TreeMap:对添加的key-value进行排序，实现有序遍历。对Key进行排序。考虑自然排序和定制排序。
 *           底层使用了红黑树(二插排序树，平衡).需要放入相同类型的key
 *   Hashtable:jdk1.0 古老的实现类 ，线程安全的，效率低,不可以存储null的Key和Value(健壮性低)
 *       Properties:map的一种。常用来处理配置文件。key和value都是String类型。
 *
 *面试题：
 *  1.hashMap底层实现原理
 *
 *  2.HashMap和HashTable的异同：
 *    hashMap:
 *    作为Map的实现类 线程不安全，效率高，可以存储null的Key和Value(健壮性高)
 *    底层hashMap(数组+链表)jdk1.7和JDK1.7之前//(数组+链表+红黑树)jdk1.8
 *    hashTable:
 *    jdk1.0 古老的实现类 ，线程安全的，效率低,不可以存储null的Key和Value(健壮性低)
 *
 *  3.CurrentHashMap与HashTable的异同
 *
 * Map结构：(key-value一一对应)
 *    key:无序，不可重复 --》key需要重写equals()和hashcode方法(hashMap)，重写自然排序和定制排序(TreeMap)
 *    value:无序，可重复
 *    一个key-value构成了一个entry对象，Entry是无序的，不可重复的。
 *
 * HashMap底层实现原理：
 *    jdk1.7:
 *    HashMap map =new HashMap():在实例化后在底层创建了一个长度为16的一维数组Entry[] table
 *    map.put(k,v):首先调用key的hashcode计算hash值，经过散列函数，得到在Entry数组存放位置。如果
 *                 此位置数据为空，则此时(k,v)entry添加成功。如果此位置数据不为空(代表着此位置存放一个或多个数据(链表形式))
 *                 ，比较key1和已经存在实体Entry的key的hash值，如果key的hash值与所有Entry的key的hash值的hash值不对，则添加成功
 *                 如果hash值与某一个存在的hash值相同，继续比较，调用key的equals方法比较，如果equals()比较结果不同，添加成功。如果比较
 *                 相同则使用新的value去替换覆盖老的value值。散列结构开散列采用的拉链法解决冲突。真实数据是在链表中存储的。数组只是记录的散列值便是散列地址。
 *                 在不断添加过程中设计扩容的问题(超出临界值且存放的位置非空)默认扩容方式扩容为entry数组原来容量的2倍，并将原有的copy过来。
 *                 元素添加采用了头插法。
 *   jdk1.8:
 *      HashMap map =new HashMap()；底层没有创建了一个长度为16的一维数组；数组为Node[];
 *      首次调用put方法时底层创建长度为16的数组。
 *      底层结构改为了数组+链表+红黑树
 *      当散列数组的的某一个索引位置上的元素以链表的形式存储的数据个数>8且散列值数组长度>64时，此时索引的位置上的所有
 *      数组改为红黑树(二叉排序查找树)存储。提高了存储和查找效率
 *
 *
 *名词：
 *   加载因子：默认值0.75，初始化hashMap ，提前扩容：提高hash表利用率，减少链表长度
 *   临界值：扩容的临界值，默认16*0.75
 *   默认初始化容量16
 *   链表长度：8 超过8时会转换成红黑树
 *   被树化时hash表的容量：64
 *
 * Map 常用方法
 *
 *说明：hash值并不等与散列值，散列值是在hash的基础上通过散列函数映射得到的。
 * @author stack
 */
public class MapTest {

    @Test
    public void test1(){
        Map map=new HashMap();
        //put方法添加元素
        map.put("1", "a");
        map.put("3", "b");
        map.put("2", "c");
        map.put("4", "d");
        System.out.println(map);
        //相同键替换
        map.put("1", "A");
        System.out.println(map);
        //putAll()添加map
        Map map1=new HashMap();
        map1.putAll(map);
        System.out.println(map1);
        //remove(key) 移除指定键值的map
        System.out.println(map1.remove("1"));
        System.out.println(map1);
        //clean()清空map集合
        map1.clear();
        System.out.println(map1.size());
    }

    @Test
    public void test2(){
        Map map=new HashMap();
        //put方法添加元素
        map.put("1", "a");
        map.put("3", "b");
        map.put("2", "c");
        map.put("4", "d");
        //get()
        System.out.println(map.get("1"));
        System.out.println(map.get("5"));
        //判断是否包含指定key
        boolean b = map.containsKey("1");
        System.out.println(b);
        //判断是否包含指定value
        System.out.println(map.containsValue("b"));
        //判断长度是否为0
        System.out.println(map.isEmpty());
        //判断map是否相同equals
        map.equals(1);
    }


    @Test
    public void test3(){
        //map集合的遍历
        Map map=new HashMap();
        //put方法添加元素
        map.put("1", "a");
        map.put("3", "b");
        map.put("2", "c");
        map.put("4", "d");
        //遍历 获取key的集合
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("-----------------");
        //遍历获取值的集合
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }
        System.out.println("------------------");
        //遍历所有key-value entry/node
        Set set1 = map.entrySet();
        for (Object o : set1) {
            Map.Entry entry= (Map.Entry) o;
            System.out.println(entry.getKey()+"--"+entry.getValue());
            System.out.println(o);
        }
    }

    @Test
    public void test4(){

    }
}

Properties

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * @author stack
 */
public class PropertiesTest {
    // Properties是hashtable的一个子类用来处理配置文件属性文件都是key-value的
    // 字符串类型 文件流要注意关闭操作

    public static void main(String[] args) throws IOException {
        Properties properties=new Properties();
        File file;
        FileInputStream fileInputStream=new FileInputStream("jdbc.properties");
        properties.load(fileInputStream);
        String name=properties.getProperty("name");
        String password=properties.getProperty("password");
        System.out.println(name+"--"+password);
        fileInputStream.close();
    }

}

Collections工具类

/**
 *Collections操作集合(list map)框架的工具类
 *
 * 面试题：
 *   Collections与Collection的区别：
 *   Collections是集合框架的工具类。
 *   Collection集合框架的接口包括ArrayList,LinkedList
 *   vector
 * @author stack
 */