由浅到深认识Java语言（29）：集合

该文章Github地址：https://github.com/AntonyCheng/java-notes

在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template & CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！

上一章：由浅到深认识Java语言（28）：集合

40.集合

Map

Map接口是键值对集合的一个基本接口，是双列集合的顶级接口，没有父接口；

键值对解释：就是由键和值组成的一对关系，键就是 Key，值就是 Value，通过键就能找到值；

键不可以重复，但是值可以重复；

主要实现类：HashMap 类增删查改；

get(Key k) 查询单个值，返回的就是 Key 对应的 Value，System.out.println 查询整个 Map；

put(Key k,Value v) 增加 Map 中的键值对；该方法一般返回 value 的数据类型，返回内容为 null，但是当 put 进重复的 key 时，会覆盖原有键所对应的 value 值；

Student 类：

package top.sharehome.Bag;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}

Demo 类：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		Student stu1 = new Student("xiaoming", 20);
		Student stu2 = new Student("xiaozhang", 21);
		Student stu3 = new Student("xiaochen", 22);
		map.put(001, stu1);
		map.put(002, stu2);
		map.put(003, stu3);
		Object object = map.get(001);
		System.out.println(object);
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

remove(Key k) 删除该 Key 所对应的键值对，并且返回该键值对，当然 clear() 能够实现删除整个Map；

Student 类：

package top.sharehome.Bag;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}

Demo 类：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		Student stu1 = new Student("xiaoming", 20);
		Student stu2 = new Student("xiaozhang", 21);
		Student stu3 = new Student("xiaochen", 22);
		map.put(001, stu1);
		map.put(002, stu2);
		map.put(003, stu3);
		Object remove = map.remove(001);
		System.out.println(remove);
		System.out.println(map);
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

put(Key k,Value v) 不仅可以增加内容，还可以通过输入要改的键来修改值；

Student 类：

package top.sharehome.Bag;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}

Demo 类：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		Student stu1 = new Student("xiaoming", 20);
		Student stu2 = new Student("xiaozhang", 21);
		map.put(001, stu1);
		map.put(002, stu2);
		System.out.println("map = " + map);
		map.put(001, stu2);
		System.out.println("修改后map = " + map);
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

keySet() 将 Map 中所有的键保存在一个数组里面，整体返回出来；

Student 类：

package top.sharehome.Bag;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}

Demo 类：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		Student stu1 = new Student("xiaoming", 20);
		Student stu2 = new Student("xiaozhang", 21);
		Student stu3 = new Student("xiaochen", 22);
		map.put(001, stu1);
		map.put(002, stu2);
		map.put(003, stu3);
		Set keySet = map.keySet();
		System.out.println(keySet);
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

containKey(K) 判断集合是否包含这个键，包含返回 true；

示例如下：

package top.sharehome.BigJava;

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

public class Demo {
    public static void main(String[] args) {
        Map<Integer,String> m = new HashMap<>();
        m.put(1,"xiaohong");
        m.put(2,"xiaoming");
        m.put(3,"xiaochen");
        m.put(4,"xiaofang");
        m.put(5,"xiaoying");
        boolean b1 = m.containsKey(3);
        boolean b2 = m.containsKey(6);
        System.out.println(b1);
        System.out.println(b2);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

containValue(V) 判断集合是否包含这个值，包含返回 true；

示例如下：

package top.sharehome.BigJava;

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

public class Demo {
    public static void main(String[] args) {
        Map<Integer,String> m = new HashMap<>();
        m.put(1,"xiaohong");
        m.put(2,"xiaoming");
        m.put(3,"xiaochen");
        m.put(4,"xiaofang");
        m.put(5,"xiaoying");
        boolean b1 = m.containsValue("xiaohong");
        boolean b2 = m.containsValue("xiaoli");
        System.out.println(b1);
        System.out.println(b2);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

size() 返回集合长度，Map集合中键值对的个数；

主要是用来判断该Map是否为空；

示例如下：

package top.sharehome.BigJava;

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

public class Demo {
    public static void main(String[] args) {
        Map<Integer,String> m = new HashMap<>();
        m.put(1,"xiaohong");
        m.put(2,"xiaoming");
        m.put(3,"xiaochen");
        m.put(4,"xiaofang");
        m.put(5,"xiaoying");
        int i = m.size();
        System.out.println(i);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

value() Map集合中的所有的值拿出存储到 Collection<V> 集合中

该方法的返回值就是一个Collection，所以不能用它的实现类去接收，我们也不必考虑它的转换过程，但一定要跟上泛型；；

示例如下：

package top.sharehome.BigJava;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Map<Integer,String> m = new HashMap<>();
        m.put(1,"xiaohong");
        m.put(2,"xiaoming");
        m.put(3,"xiaochen");
        m.put(4,"xiaofang");
        m.put(5,"xiaoying");
        Collection<String> coll = m.values();
        System.out.println(coll);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

遍历Map

方式一(常用)

方法解释：

首先要有一个 Map 集合，只要我们能够拿到所有的键，就可以让我们返回所有对应的值；
然后通过 map.ksySet() 方法获取所有的键，返回并包装成一个 Collection 接口下的 Set 子接口，此时我们就可以根据遍历 Collection 的迭代器方法来遍历该 Map；
然后获得一个迭代器，在循环语句中，将所有 key 赋值为每一次循环的 iterator.next()，再通过 Map.get(key) 方法获得所有 key 所对应的 value；
最后输出出来；

示例如下：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		map.put(4, "d");
		map.put(5, "e");
		//map集合里放的是键值对，Key和Value的映射关系
		//获得Map中所有的键，就能够遍历出所有的值；  ==>  map中的 keySet() 方法
		Set keySet = map.keySet();
		//返回一个包含所有键的 Set ，即可获得该 Set 的迭代器
		Iterator iterator = keySet.iterator();
		//步骤和 Collection 迭代方式一样
		while(iterator.hasNext()) {
			Object key = iterator.next();
			//这里要通过 map 中的 get() 方法得到每一个键所对应的值
			Object value = map.get(key);
			System.out.println("Key = "+key+" ==> value = "+value);
		}
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

方式二

方法解释：

通过 Map 集合的 values() 方法获得集合中所有的值；

该方法将所有的值放入一个容器并返回一个 Collection 接口下的 List 子接口（因为 Map 集合中的值可以重复）

示例如下：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		map.put(4, "d");
		map.put(5, "e");
		map.put(6, "a");
		Set keys = map.keySet();
		Collection values = map.values();
		System.out.println(keys);
		System.out.println(values);
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

方式三(须知)

方法解释：

使用 Map 中的 entrySet() 内部类，能够直接获取 Map 中的所有映射关系（Entry），并且返回一个 Set 接口，这个接口中存储的元素比较特殊，存储的是 Map 集合中键值对映射关系的对象，内部接口 Map.Entry<K,V> ；

然后又可以用 Set 接口中的迭代器方法做遍历，参见方式一；

映射关系相关的接口 Map.Entry<K,V>：

接口常见方法：

equals(Object O) 比较指定对象与该映射项是否相等；

getKey() 返回该映射项对应的键；

getValue() 返回该映射项对应的值；

setValue(Value V) 用指定的值替换该映射项的值；

方法示例：

package top.sharehome.Bag;

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

public class Demo {
	public static void main(String[] args) {
		Map map = new HashMap();
		Map mapTest = new HashMap();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		map.put(4, "d");
		map.put(5, "e");
		map.put(6, "a");
		mapTest.putAll(map);
		Set entrySet1 = map.entrySet();
		Set entrySet2 = mapTest.entrySet();
		Iterator iterator1 = entrySet1.iterator();
		Iterator iterator2 = entrySet2.iterator();
		Object next1 = iterator1.next();
		Object next2 = iterator2.next();
		//以下判断是向下转型
		if(next1 instanceof Map.Entry) {
			if(next2 instanceof Map.Entry) {
				//以下两条是强转，因为 Object 中没有 entry 里的方法
				Entry entry1 = (Entry) next1;
				Entry entry2 = (Entry) next2;
				boolean equals = entry1.equals(entry2);
				Object key1 = entry1.getKey();
				Object key2 = entry2.getKey();
				Object value1 = entry1.getValue();
				Object value2 = entry2.getValue();
				System.out.println("equals = " + equals);
				System.out.println("key1 = " + key1);
				System.out.println("key2 = " + key2);
				System.out.println("value1 = " + value1);
				System.out.println("value2 = " + value2);
				Object setValue1 = entry1.setValue("A");
				Object setValue2 = entry2.setValue("B");
				System.out.println("setValue1 = " + setValue1);
				System.out.println("wetValue2 = " + setValue2);
			}
		}
	}
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

方式三示例如下：

package top.sharehome.BigJava;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Map<Integer,String> m = new HashMap<>();
        m.put(1,"xiaohong");
        m.put(2,"xiaoming");
        m.put(3,"xiaochen");
        m.put(4,"xiaofang");
        m.put(5,"xiaoying");
        Set<Map.Entry<Integer,String>> s = m.entrySet();
        Iterator<Map.Entry<Integer,String>> it = s.iterator();
        while (it.hasNext()){
            Map.Entry<Integer,String> e = it.next();
            Integer key = e.getKey();
            String value = e.getValue();
            System.out.println("key = "+key+" ==> value = "+value);
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

HashMap(常用)

HashMap集合特点
- 是哈希表结构
- 为了保证唯一性，用于键的对象，必须重写 hashCode 和 equals 方法，不然会出现该对象作为键时，插入内容相同的对象而会被判定成两个不一样的对象；
- 线程不安全集合，运行速度快
- 集合允许使用 null 作为键或者值

LinkedHashMap

继承于 HashMap ，实现 Map 接口，LinkedHashMap底层实现原理是哈希表，双向连，存取有序，其他的特性和它的父类 HashMap 一样；

示例如下：

我们从键盘获取，来存储 3 个学生对象；

package top.sharehome.BigJava;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生个数：");
        int stuNum = sc.nextInt();
        Map<Integer, String> m = MyScan(stuNum);
        System.out.println("下面是第一种遍历方式：");
        Set<Integer> set1 = m.keySet();
        Iterator<Integer> it1 = set1.iterator();
        while (it1.hasNext()) {
            int key = it1.next();
            String value = m.get(key);
            System.out.println("key = " + key + " ==> value =" + value);
        }
        System.out.println("下面是第二种遍历方式：");
        Set<Map.Entry<Integer, String>> set2 = m.entrySet();
        Iterator<Map.Entry<Integer, String>> it2 = set2.iterator();
        while (it2.hasNext()) {
            Map.Entry<Integer, String> e = it2.next();
            int key = e.getKey();
            String value = e.getValue();
            System.out.println("key = " + key + " ==> value =" + value);
        }
    }

    public static LinkedHashMap<Integer, String> MyScan(int num) {
        Scanner sc = new Scanner(System.in);
        LinkedHashMap<Integer, String> m = new LinkedHashMap<>();
        for (int i = 0; i < num; i++) {
            System.out.println("请输入第" + (i + 1) + "个学生的序号和名字：");
            int stuNum = sc.nextInt();
            String name = sc.next();
            m.put(stuNum, name);
        }
        sc.close();
        return m;
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Hashtable

这是 Map 接口的实现类，这个类诞生于 JDK1.0 版本，而 Map 接口诞生于 JDK1.2 版本，所以 Hashtable 类从 JDK1.2 开始，改进为实现 Map 接口；

Hashtable 类的特点
- 底层数据结构是哈希表
- 线程安全的，运行速度慢，被更加先进的 HashMap 取代
- 不允许 null 值和 null 键

Vector

List 接口的实现 Vector，命运和 Hashtable 一样；

Vector 类的特点
- 底层实现结构式数组
- 数组的默认容量是 10，每次扩容是原来的两倍
- 线程安全，运行速度，被 ArrayList 取代

TreeMap

TreeMap 特点
- 底层实现是红黑树结构（添加查询速度都是比较快的）
- 存储到 TreeMap 中的元素会对键进行排序，排序的依据：
  - 对象的自然顺序，作为键的对象，实现了接口 Comparable
  - 自己提供比较器，实现接口 Comparator （优先级高）
- 线程不安全，运行速度快

示例如下：

package top.sharehome.BigJava;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Map<Student, Integer> m = new TreeMap<>(new MyCom());
        m.put(new Student("xiaochen", 21), 1);
        m.put(new Student("xiaoyang", 22), 1);
        m.put(new Student("xiaohong", 19), 1);
        Set<Student> set = m.keySet();
        Iterator<Student> it = set.iterator();
        while (it.hasNext()) {
            Student key = it.next();
            int value = m.get(key);
            System.out.println("key = " + key + " ==> value = " + value);
        }
    }
}

class MyCom implements Comparator<Student> {
    public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();
    }
}

class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;

        Student student = (Student) o;

        if (getAge() != student.getAge()) return false;
        return getName() != null ? getName().equals(student.getName()) : student.getName() == null;
    }

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

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Properties

Properties 集合特点

继承 Hashtable，实现 Map 接口
底层是哈希表结构
线程是安全的，运行速度慢
这个集合没有泛型的写法，键和值的数据类型锁定为 String 类型

这个集合有自己的特有方法

setProperties(String key,String value) 存放元素，不能用 put ，因为 put 的泛型被取消掉

示例如下：

package top.sharehome.BigJava;

import java.util.Properties;

public class Demo {
    public static void main(String[] args) {
        Properties p = new Properties();
        p.setProperty("a", "1");
        p.setProperty("b", "1");
        p.setProperty("c", "1");
        System.out.println(p);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

getProperties(String Key) 获取value

示例如下：

package top.sharehome.BigJava;

import java.util.Properties;

public class Demo {
    public static void main(String[] args) {
        Properties p = new Properties();
        p.setProperty("a", "1");
        p.setProperty("b", "2");
        p.setProperty("c", "3");
        System.out.println(p.getProperty("a"));
        System.out.println(p.getProperty("b"));
        System.out.println(p.getProperty("c"));
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

stringPropertyNames() 返回一个 Set 集合，等同于 Map 里的 keySet()

示例如下：

package top.sharehome.BigJava;

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

public class Demo {
    public static void main(String[] args) {
        Properties p = new Properties();
        p.setProperty("a", "1");
        p.setProperty("b", "2");
        p.setProperty("c", "3");
        Set<String> s = p.stringPropertyNames();
        Iterator<String> it = s.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

此集合可以和 IO 流对象结合使用，实现数据的持久存储
和 IO 流相关的方法：load() 输入流；

遍历 Properties 集合

示例如下：

package top.sharehome.BigJava;

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

public class Demo {
    public static void main(String[] args) {
        Properties p = new Properties();
        p.setProperty("a", "1");
        p.setProperty("b", "2");
        p.setProperty("c", "3");
        Set<String> s = p.stringPropertyNames();
        Iterator<String> it = s.iterator();
        while (it.hasNext()){
            String key =  it.next();
            String value = p.getProperty(key);
            System.out.println("key = "+key+" ==> value ="+value);
        }
    }
}