【JavaSE】Java集合

文章目录

Java集合
- - 集合框架概述
  - - 概述
    - 集合框架
  - Collection接口方法
  - Iterator迭代器接口
  - Collection子接口一：List
  - - list接口的框架结构
    - ArrayList的源码分析：
    - - jdk 7情况下
      - jdk 8中ArrayList的变化
      - 小结
    - LinkedList的源码分析
    - Vector的源码分析
    - List接口中的常用方法
  - Collection子接口二：Set
  - - Set接口的框架结构
    - 一、存储无序的、不可重复的数据
    - 二、添加数据的过程（以HashSet为例）：
    - HashSet的使用
    - LinkedHashSet的使用
    - TreeSet的使用
  - Map接口
  - - Map接口的框架结构
    - Map结构的理解
    - HashMap的底层实现原理（以jdk7为例说明）：
    - LinkedHashMap的底层实现原理
    - Map接口中定义的方法
    - TreeMap介绍
    - Properties类
  - Collections工具类
  - - Collections中的一些方法
    - Collection的线程同步方法

Java集合集合框架概述概述

1.集合和数组都是对多个数据进行存储操作的结构，简称Java容器。

说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)

2.1数组在存储多个数据方面的特点：

一旦初始化，其长度就确定了。
数组一旦定义好，其元素类型也就确定了，只能操作指定类型的数据。
比如：String[] arr; int[] arr1; Object[] arr2;

2.2 数组在存储多个数据方面的缺点：

一旦初始化，其长度就不可修改。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，数组无法满足。

集合框架

|—Collection接口：单列集合，用来存储一个个对象

|—List接口：存储有序的、可重复的数据。 -->"动态"数组
- |—ArrayList、LinkedList、Vector
|—Set接口：存储无序的、不可重复的数据。–>高中数学的集合
- |—HashSet、LinkedHashSet、TreeSet

|—Map接口：双列集合，用来存储一对对(key-value)数据 -->高中函数：y=f(x)

|—HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口方法

add(Object e)：将元素e添加到集合中
size()方法：获取添加的元素的个数
addAll()：添加另一个Collection类
clear():清空集合元素
isEmpty():判断当前集合是否为空
contains(Object obj)：当前集合中是否包含obj
containsAll(Collection col1):判断形参col1中额的所有元素是否都存在与col中
remove(Object obj)：从当前集合中移除元素obj，返回true则表示删除成功，false表示删除失败
removeAll(Collection col1)：从当前集合中移除公有的元素，差集操作
retainAll(Collection col1)：获取当前集合和col1的交集，并返回给当前结合
equals(Object obj)：比较两个Collection中的所有元素是否相等
hashCode()：返回当前对象的哈希值
集合 —> 数组：toArray()
拓展：数组 —> 集合：调用Arrays类的静态方法asList()
iterator()：返回Iterator接口的实例，用于遍历集合元素。

package com.zeta;

import org.junit.Test;

import java.time.LocalDateTime;
import java.util.*;


@SuppressWarnings("all")
public class CollectionTest {
    @Test
    public void test1(){
        Collection col = new ArrayList<>();
        //add(Object e)：将元素e添加到集合中
        col.add("abcd");
        col.add(123);
        col.add(true);
        col.add(1000000L);

        //size()方法：获取添加的元素的个数
        System.out.println(col.size());//4

        //addAll()：添加另一个Collection类
        Collection col1 = new ArrayList<>();
        col1.add("456");
        col1.add("true");
        col1.add(LocalDateTime.now());
        col.addAll(col1);

        System.out.println(col.size());//7
        System.out.println(col);

        //clear():清空集合元素
        col.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(col.isEmpty());

    }

    
    @Test
    public void test2(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add(new Date());
        //1.contains(Object obj)：当前集合中是否包含obj
        System.out.println(col.contains(false));
        System.out.println(col.contains(new String("Tom")));//判断的是内容：equals()方法
        System.out.println(col.contains("T"+"o"+"m"));

        //2.containsAll(Collection col1):判断形参col1中额的所有元素是否都存在与col中
        Collection col1 = Arrays.asList(123,4567);
        System.out.println(col.containsAll(col1));

    }

    @Test
    public void test3(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");
        //3.remove(Object obj)：从当前集合中移除元素obj，返回true则表示删除成功，false表示删除失败
        col.remove(1234);
        System.out.println(col);

        //4.removeAll(Collection col1)：从当前集合中移除公有的元素，差集操作
        Collection col1 = Arrays.asList(123,4567);
        col.removeAll(col1);
        System.out.println(col);
    }

    @Test
    public void test4(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");

        //5.retainAll(Collection col1)：获取当前集合和col1的交集，并返回给当前结合
        Collection col1 = Arrays.asList(123,456,789);
//        col.retainAll(col1);
        System.out.println(col);

        //6.equals(Object obj)：比较两个Collection中的所有元素是否相等
        Collection col2 = new ArrayList();
        col2.add(456);
        col2.add(123);
        col2.add(new String("Tom"));
        col2.add(false);
        col2.add("jack");
        System.out.println(col.equals(col2));
    }

    @Test
    public void test5(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");

        //7.hashCode()：返回当前对象的哈希值
        System.out.println(col.hashCode());

        //8.集合 ---> 数组：toArray()
        Object[] objects = col.toArray();
        System.out.println(Arrays.toString(objects));

        //拓展：数组 ---> 集合？:调用Arrays类的静态方法asList()
        List list = Arrays.asList(new String[]{"a", "b", "c"});
        System.out.println(list);

        //9.iterator()：返回Iterator接口的实例，用于遍历集合元素。
    }
}

Iterator迭代器接口

集合元素的遍历，使用迭代器Iterator接口

内部的方法：hasNext()和next()
集合对象每次调用iterator()方法都将得到一个全新的迭代器对象，指针默认在集合的第一个元素之前
Iterator内部定义了remove()，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调remove()

package com.zeta;

import org.junit.Test;

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


@SuppressWarnings("all")
public class IteratorTest {
    @Test
    public void test1(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");

        Iterator iterator = col.iterator();
        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next()); //报异常：NoSuchElementException
        //方式二：不推荐
//        for (int i=0;i<5;i++){
//            System.out.println(iterator.next());
//        }
        //方式三：推荐
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test2(){
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("Tom"));
        col.add(false);
        col.add("jack");
        Iterator iterator = col.iterator();
        //删除"Tom"
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();//直接删除col中的元素
            }
        }
//        System.out.println(col); "Tom"被删除
        //重新遍历
        iterator = col.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

补充：Collection的forEach遍历方法

col.forEach(System.out::println); //Java8新特性

@Test
    public void test6(){
        
        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new User("Tom",20));
        col.add(false);
        col.add(new User("Jack",21));
        col.forEach(System.out::println);
    }

Collection子接口一：List list接口的框架结构

|—Collection接口：单列集合，用来存储一个个对象

|—List接口：存储有序的、可重复的数据。 -->"动态"数组，替换原有数组

|—ArrayList：作为List接口的主要实现类，线程不安全，效率高；底层使用Object[] elementData存储

|—LinkedList：对于频繁地插入和删除操作，使用此类比ArrayList效率高；底层使用双向链表存储

|—Vector(几乎用不到)：作为List接口的古老实现类，线程安全，效率低；底层使用Object[] elementData存储

ArrayList的源码分析： jdk 7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData

list.add(123);//elementData[0] = new Integer(123);

…

list.add(11);//如果此次添加导致底层数组容量不够，则扩容。

默认情况下扩容为原来长度的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int initialCapacity);

jdk 8中ArrayList的变化

ArrayList list = new ArrayList();//底层elementData初始化为{}。并没有创建长度为10的数组

list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData中

…

后续的添加和扩容与jdk7无异。

小结

jdk7中的ArrayList的对象的创建类似于单例的饿汉式；

jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省了内存。

LinkedList的源码分析

LinkedList list = new LinkedList();内部声明了Node类型的first和last属性，默认为null

list.add(123);//将123封装到Node中，创建了Node对象

其中，Node定义为：(体现了LinkedList的双向链表的说法)

private static class Node {
	E item;
	Node next;
	Node prev; 

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

Vector的源码分析

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组

在扩容方面，默认扩容为原来数组长度的2倍

List接口中的常用方法

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位置的左闭右开区间的子集合

总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：①Iterator迭代器
②增强for循环
③普通的循环

package com.zeta;

import org.junit.Test;

import java.util.*;


@SuppressWarnings("all")
public class ListTest {
    
    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("jack");
        list.add("AA");
        //方式一：Iterator迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("**********************");
        //方式二：增强for循环
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("**********************");

        //方式三：普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }

    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("jack");
        list.add("tom");
        list.add(456);
        list.add(new StringBuilder(new String("ζ")));
        System.out.println(list);

        //int indexOf(Object obj)：返回obj在集合中首次出现的位置。如果不存在，返回-1
        int index = list.indexOf(4567);
        System.out.println(index);//-1

        //int lastIndexOf(Object obj)：返回obj在当前集合中末位出现的位置
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);

        //Object remove(int index)：移除指定index位置的元素，并返回此元素
        Object obj = list.remove(4);
        System.out.println(obj);
        System.out.println(list);

        //Object set(int index,Object ele)：设置指定index位置的元素为ele
        list.set(1,"AA");
        System.out.println(list);

        //List subList(int fromIndex,int toIndex)：返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
    }

    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("jack");
        list.add(new String("tom"));
        System.out.println(list);

        //void add(int index,Object ele):在index位置插入ele元素
        list.add(1,"ζ");
        System.out.println(list);

        //boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(0,list1);
        System.out.println(list);
        System.out.println("list的长度为："+list.size());//8

        //Object get(int index)：获取指定index位置的元素
        System.out.println(list.get(4));
    }
}

面试题

区分list中的remove(int index)和remove(Object obj)方法

当直接输入数字时，默认调用remove(int index)，当对数字进行封装(new Integer(num))时，调用remove(Object obj)方法。

package com.exer;

import org.junit.Test;

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


@SuppressWarnings("all")
public class ListExer {
    @Test
    public void testListRemove(){
        
        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);//list确实被改变了，index为2的位置被删除
        System.out.println(list);//[1,2]
    }
    public static void updateList(List list){
//        list.remove(2);//2 是索引，不是数据
        list.remove(new Integer(2));
    }
}

Collection子接口二：Set Set接口的框架结构

|—Collection接口：单列集合，用来存储一个个对象

|—Set接口：存储无序的、不可重复的数据。–>高中数学的集合

|—HashSet:作为Set接口的主要实现类；线程不安全；可以存储null值。

|—LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。

对于频繁的遍历操作，LinkedHashSet效率高于HashSet

|—TreeSet:可以按照添加对象的指定属性进行排序。

Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法

要求

向Set中添加数据时，其所在的类一定要重写hashCode()和equals()
重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码（哈希值）

重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该用来计算hashCode()

一、存储无序的、不可重复的数据

以HashSet为例说明：
1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

2.不可重复性：保证添加的元素按照equals()判断时，不能返回true. 即相同的元素只能添加一个。

二、添加数据的过程（以HashSet为例）：

我们向HashSet中添加元素a，首先调用a所在类的hashCode()方法，
此哈希值接着通过某种算法在HashSet底层数组中的存放位置（即为索引），
判断数组此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功；—> 情况1
如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的值：
- 如果hash值不相同，则元素a添加成功；—> 情况2
- 如果hash值相同，进而需要调用元素a所在类的equals()方法：
  - equals()返回true，元素a添加失败
  - equals()返回false，元素a添加成功—> 情况3

对于添加成功的情况2和情况3而言：元素a与已经存在的指定索引位置上的元素以链表的方式存储：
jdk7：元素a放到数组中，指向原来的元素
jdk8：原来的元素放在数组中，指向元素a
总结：“七上八下”
HashSet底层：数组+链表的结构。

HashSet的使用

@Test
    public void test1(){
        Set set = new HashSet();
        set.add(123);
        set.add(456);
        set.add("jack" );
        set.add("ζ");
        set.add(new User("Tom",20));
        set.add(new User("Tom",20));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

LinkedHashSet的使用

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

@Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(123);
        set.add(456);
        set.add("jack" );
        set.add("ζ");
        set.add(new User("Tom",20));
        set.add(new User("Tom",20));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

TreeSet的使用

1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator），定制排序的优先级高于自然排序（即同时存在时，定制排序会覆盖自然排序）
3.自然排序中比较两个对象是否相同的标准为：compareTo()方法返回0，不再是equals()方法
4.定制排序中比较两个对象是否相同的标准为：compare()方法返回0，不再是equals()方法

 @Test
    public void test1(){
        TreeSet set = new TreeSet();
        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("ζ");
//        set.add(new User("Tom",20));
        //举例一：从小到大输出
//        set.add(123);
//        set.add(234);
//        set.add(987);
//        set.add(654);
//        Iterator iterator = set.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        //举例二：
        set.add(new User("Tom",20));
        set.add(new User("Marry",19));
        set.add(new User("John",21));
        set.add(new User("George",18));
        set.add(new User("George",20));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
    }

    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User){
                    User u1 = (User) o1;
                    User u2 = (User) o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);//传入Comparator对象的参数，实现定制排序
        set.add(new User("Tom",20));
        set.add(new User("Marry",19));
        set.add(new User("John",21));
        set.add(new User("George",18));
        set.add(new User("George",20));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
         
    }

User类

public class User implements Comparable{//继承Comparable接口，实现自然排序
    private  String name;
    private int age;



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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if (compare!=0){
                return compare;
            }else {
                return Integer.compare(this.age,user.age);
            }
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}

Map接口 Map接口的框架结构

|—Map：双列数据，存储key-value对的数据 --类似于高中数学的函数

|—HashMap：作为Map的主要实现类；线程不安全，效率高；可以存储null的key和value

|—LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序进行遍历

原因：在原有的HashMap底层结构的基础上，添加了一对指针，指向前一个和后一个键值对，对于频繁的遍历操作，此类执行效率高于HashMap

|—TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序和定制排序。

底层使用红黑树

|—Hashtable：作为古老的实现类；线程安全，效率低；不能存储null的key和value

|—Properties：常用来处理配置文件。key和value都是String类型

HashMap的底层：数组+链表（jdk7及以前）

数组+链表+红黑树（jdk8）

Map结构的理解

Map中的key：无序的、不可重复的，使用Set存储所有的key —> key所在的类要重写equals()和hashCode()方法（以HashMap为例）

Map中的value：无序的、可重复的，使用 Collection存储所有的value —> value所在的类要重写equals()方法

一个键值对：key-value构成了一个Entry对象。

Map中的Entry：无序的、不可重复的，使用Set存储所有的Entry

HashMap的底层实现原理（以jdk7为例说明）：

HashMap map = new HashMap();

在实例化以后，底层创建了长度是16的一维数组Entry[] table;

…(可能已经执行过多次put)

map.put(key1,value1);

首先，调用key1所在类的hashCode()计算key1的哈希值，此哈希值经过某种算法以后，得到在Entry数组中的存放位置

如果此位置上的数据为空，此时的key1-value1添加成功； —情况1
如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
- 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。 —情况2
- 如果key1的哈希值和已经存在的某一个数据的哈希值相同，继续比较：调用key1所在类的equals方法，比较：
  - 如果equals()返回false：此时key1-value1添加成功； —情况3
  - 如果equals()返回true：使用value1替换相同key的value值。（覆盖）

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断的添加添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空），默认扩容方式：扩容为原来的2倍，并将原来的数据复制过来。

jdk8相较于jdk7在底层实现方面的不同：

new HashMap()：底层没有创建一个长度为16的数组
jdk8底层的数组是：Node[],而非Entry[]
首次调用put()方法时，底层创建长度为16的数组
jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树
当数组的某一个索引位置上的元素以链表存在的数据个数 > 8 且当前数组的长度 > 64,此时此索引位置上的所有数据改为用红黑树存储。

一些参数：

DEFAULT_INITIAL_CAPACITY：HashMap的默认容量：16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值（=容量填充因子）：160.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64

LinkedHashMap的底层实现原理

源码中：

static class Entry extends HashMap.Node {//继承了HashMap的Node
    Entry before, after;//能够记录添加的元素的先后顺序
    Entry(int hash, K key, V value, Node next) {
    	super(hash, key, value, next);
    }
}

Map接口中定义的方法

添加、删除、修改操作：

Object put(Object key,Object value)：将指定key-value添加到（或修改）当前map对象中
void putAll(Map m)：将m中所有的key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据

元素查询的操作：

Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图的操作方法：

Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

总结：常用方法

添加：put(Object key,Object value)
删除：remove(Object key)
修改：put(Object key,Object value)
查询：get(Object key)
长度：size()
遍历：keySet()/values()/entrySet()

package com.map;

import org.junit.Test;

import java.util.*;


@SuppressWarnings("all")
public class MapTest {
    
    @Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("ZZ",1234);
        map.put("BB",332);
        map.put("CC",456);

        //遍历所有的key集：keySet()
        map.keySet().forEach(System.out::println);

        System.out.println("*****************");
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj:values){
            System.out.println(obj);
        }
        System.out.println("*****************");
        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+" ---> "+entry.getValue());
        }
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator1 = keySet.iterator();
        while (iterator1.hasNext()){
            Object key = iterator1.next();
            Object value = map.get(key);
            System.out.println(key+" ==> "+value);
        }
    }


    
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("ZZ",123);
        map.put("BB",332);
        map.put("CC",456);
        //Object get(Object key)
        System.out.println(map.get("AA"));
        //boolean containsKey(Object key)
        boolean bb = map.containsKey("BB");
        System.out.println(bb);
        //boolean containsValue(Object value)
        bb = map.containsValue(123);
        System.out.println(bb);

        System.out.println(map.size());
        map.clear();
        System.out.println(map.isEmpty());
        System.out.println(map.size());

    }

    
    @Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put("ZZ",123);
        map.put("BB",332);
        map.put("CC",456);
        //修改
        map.put("AA",55);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("EE",123);
        map1.put("GG",123);
        map.putAll(map1);
        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear();
        System.out.println(map.size());
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new LinkedHashMap();
        map.put(123,"AA");
        map.put(345,"BB");
        map.put(12,"CC");
        map.entrySet().forEach(System.out::println);

    }
    @Test
    public void test1(){
        Map map = new HashMap();
//        map = new Hashtable();
        map.put(null,123);

    }
}

TreeMap介绍

TreeMap在原理上类似于TreeSet；向TreeMap中添加key-value，要求key必须是由同一个类创建的对象，因为要按照key进行排序（自然排序、定制排序）。

package com.map;

import org.junit.Test;

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


@SuppressWarnings("all")
public class TreeMapTest {
    //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    //因为要按照key进行排序：自然排序、定制排序
    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",20);
        User u2 = new User("Jerry",18);
        User u3 = new User("Mike",21);
        User u4 = new User("George",19);
        map.put(u1,78);
        map.put(u2,95);
        map.put(u3,89);
        map.put(u4,80);

        map.entrySet().forEach(System.out::println);
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入的数据类型不匹配");

            }
        });
        User u1 = new User("Tom",20);
        User u2 = new User("Jerry",18);
        User u3 = new User("Mike",21);
        User u4 = new User("George",19);
        map.put(u1,78);
        map.put(u2,95);
        map.put(u3,89);
        map.put(u4,80);

        map.entrySet().forEach(System.out::println);
    }
}


//User类
package com.map;


public class User implements Comparable{
    private  String name;
    private int age;

    

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //按照姓名从大到小，年龄从小到大的顺序排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if (compare!=0){
                return compare;
            }else {
                return Integer.compare(this.age,user.age);
            }
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}

Properties类

Properties：常用来处理配置文件：key和value都是String类型

package com.map;

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


@SuppressWarnings("all")
public class PropertiesTest {
    //Properties：常用来处理配置文件：key和value都是String类型
    public static void main(String[] args) throws Exception {
        Properties pros = new Properties();
        FileInputStream fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//加载流对应的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");
        System.out.println("name = "+name+",password = "+password);
        fis.close();
    }
}

jdbc.properties

name=zeta
password=123456

Collections工具类

Collections：操作Collection、Map的工具类

Collection和Collections的区别:

Collection为单例集合的接口
Collections为操作Collection、Map的工具类

Collections中的一些方法

reverse(List list)：反转List中元素的顺序
shuffle(List list)：对List随机排序
sort(List list [,Comparator])：对List自然排序/定制排序
swap(List list,int i,int j)：交换list中索引i和索引j处的元素
Object max(List list,[Comparator]) / min(…) : 求list(自然排序或定制排序)中的最大值/最小值
frequency(List list ,Object o)：返回元素o在list中出现的次数
Collections.copy(List dest,List src) : 拷贝src中的元素到dest中

@Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(3);
        list.add(12);
        list.add(12);
        list.add(456);
        list.add(4);

        //错误：报异常IndexOutOfBoundsException
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
        //正确
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list);
        System.out.println(dest);
    }

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(3);
        list.add(12);
        list.add(12);
        list.add(456);
        list.add(4);
        list.add(56);
        list.add(78);
        list.add(89);
        System.out.println(list);
        //reverse(List list)：反转List中元素的顺序
        Collections.reverse(list);
        System.out.println(list);
        //shuffle(List list)：对List随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //sort(List list)：对List自然排序
        Collections.sort(list);
        System.out.println(list);
        //swap(List list,int i,int j)：交换list中索引i和索引j处的元素
        Collections.swap(list,2,3);
        System.out.println(list);
        //Object max(List list,[Comparator]) / min(...)

        //frequency(List list ,Object o)：返回元素o在list中出现的次数
        System.out.println(Collections.frequency(list, 12));

    }

Collection的线程同步方法

Collections类中提供了多个synchronizedXxx()方法，这些方法可以将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

public void test3(){
        List list = new ArrayList();
        list.add(123);
        list.add(3);
        list.add(12);
        list.add(12);
        list.add(456);
        list.add(4);
        
        //返回值为线程安全的list
        List list1 = Collections.synchronizedList(list);
    }

【JavaSE】Java集合

Python相关栏目本月热门文章