Map集合和Collection集合是完全分开的
Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个一个元素的方式存储 单列集合
Map中的集合，元素是成对存在的，每个元素都是由键与值两部分组成的，通过键找对应的值 双列集合
Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值
Map中常用的集合为HashMap集合、LinkedHashMap集合
HashMap集合
HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap集合
LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。
Map接口中常用的方法
package com.oracle.demo1;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
put();
System.out.println("======================");
get();
System.out.println("======================");
delete();
System.out.println("======================");
bianli();
System.out.println("======================");
bianli2();
}
/*
* 向集合中添加元素 V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
* 如果集合中存储之前没有这个键，那么返回null 如果存储之前集合中存在这个键，那么会替换到这个键所对应的值， 并且返回替换前这个键所对应的值
*/
public static void put() {
Map<Integer, String> m = new HashMap<Integer, String>();
String v1 = m.put(1, "张三");
String v2 = m.put(2, "李四");
String v3 = m.put(3, "王五");
String v4 = m.put(3, "赵六");
System.out.println(v1 + "---" + v2 + "---" + v4);
System.out.println(m);
}
/*
* 获取Map集合中指定键的值 V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
*/
public static void get() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "张三");
m.put(2, "李四");
m.put(3, "王五");
String v = m.get(1);
System.out.println(v);
}
/*
* 删除元素 V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
* 1、删除传入的键以及对应的值
* 2、返回你要删除的键对应的值
*/
public static void delete() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "张三");
m.put(2, "李四");
m.put(3, "王五");
System.out.println(m);
String v = m.remove(3);
System.out.println(v);
System.out.println(m);
}
/*
* 遍历Map集合 键找值
* 1、获取你的所有键所对应的set集合
* 2、遍历你的set集合，然后取对应的values值
*/
public static void bianli() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "张三");
m.put(2, "李四");
m.put(3, "王五");
// 1、获取装有键的set集合
// Set<Integer> s=m.keySet();
// 2、增强for遍历set集合
for (Integer i : m.keySet()) {
// 获取键
int key = i;
// 获取值
String values = m.get(key);
System.out.println(key + "===" + values);
}
System.out.println("================");
// Iterator遍历
Set<Integer> set = m.keySet();
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
int key = it.next();
String values = m.get(key);
System.out.println(key + "===" + values);
}
}
/*
* 通过映射关系遍历Map
* 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。
* 通过增强for循环和Iterator遍历set集合获取Map中的数据
*/
public static void bianli2() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "张三");
m.put(2, "李四");
m.put(3, "王五");
// 1、先得到set集合
// Set<Map.Entry<Integer, String>> set = m.entrySet();
// Iterator<Map.Entry<Integer, String>> it = set.iterator();
// while (it.hasNext()) {
// Map.Entry<Integer, String> map = it.next();
// int k = map.getKey();
// String v = map.getValue();
// System.out.println(k + "======" + v);
// }
// 增强for遍历集合
for (Map.Entry<Integer, String> map : m.entrySet()) {
int k = map.getKey();
String v = map.getValue();
System.out.println(k + "======" + v);
}
}
}
Map中键找值的方式
键找值方式：即通过元素中的键，获取键所对应的值
操作步骤与图解：
1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键
2.遍历键的Set集合，得到每一个键
3.根据键，获取键所对应的值
Entry键值对
Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
Entry是Map接口中提供的一个静态内部嵌套接口，可以直接用类名调用
getKey()方法：获取Entry对象中的键
getValue()方法：获取Entry对象中的值
entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回
Map中遍历键值对的方式
键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤与图解：
1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。
2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
3.通过键值对(Entry)对象，获取Entry对象中的键与值。
HashMap存储自定义类型键值
package com.oracle.demo1;
public class Person {
String name;
int 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() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return name + "----" + age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
package com.oracle.demo1;
import java.util.HashMap;
public class HashMapDemo {
public static void main(String[] args) {
key();
System.out.println("=============");
values();
}
public static void key() {
//当自定义类作为键时，由于类中没有重写hashCode和equals方法
//所以输入的数据中尽管有重复的数据，也会存进去
//由于Java中对键值对的规范，键不能重复，
//所以需要在自定义类中重写hashCode和equals方法
HashMap<Person, String> hs = new HashMap<Person, String>();
hs.put(new Person("张三", 18), "java");
hs.put(new Person("李四", 34), "php");
hs.put(new Person("张三", 18), "python");
hs.put(new Person("王五", 18), "java");
System.out.println(hs);
}
public static void values() {
//String类作为键，由于String中重写了hashCode和equals方法
//所以当输入的键有重复数据时，会自动识别，保证键的唯一性
HashMap<String, Person> hs = new HashMap<String, Person>();
hs.put("java", new Person("张三", 18));
hs.put("php", new Person("李四", 34));
hs.put("python", new Person("张三", 18));
hs.put("java", new Person("王五", 18));
System.out.println(hs);
}
}
当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法
如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。
package com.oracle.demo1;
import java.util.HashMap;
import java.util.LinkedHashMap;
public class LinkedHashMapDemo {
public static void main(String[] args) {
//LinkedHashMap是有序的，就是怎么存怎么取
LinkedHashMap<String,String> lhm=new LinkedHashMap<String,String>();
lhm.put("abc", "张三");
lhm.put("java", "李四");
lhm.put("aac", "王五");
lhm.put("gdr", "张三");
System.out.println(lhm);
//HashMap不是有序的，不一定怎么存怎么取
HashMap<String,String> hm=new HashMap<String,String>();
hm.put("abc", "张三");
hm.put("java", "李四");
hm.put("aac", "王五");
hm.put("gdr", "张三");
System.out.println(hm);
}
}
静态导入
在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。
静态导入格式：
import static XXX.YYY; 导入后YYY可直接使用。
package com.oracle.demo2;
import static java.lang.System.out;
import static java.util.Arrays.sort;
public class StsticDemo {
public static void main(String[] args) {
out.println("这是静态导入");
int[] arr = { 2, 4, 6, 3, 6, 1, 8 };
sort(arr);
for (int i : arr) {
out.println(i);
}
}
}
可变参数
在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致
package com.oracle.demo2;
public class Demo {
public static void main(String[] args) {
System.out.println(add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
}
// 可变参数 参数类型相同，但是参数个数不定
// int ...a实际上是一个数组
//注：1、如果在一个参数列表中需要传入多种类型，则可变列表必须放到最后
// 如：public static void add(String str,int ...a){}
// 2、在一个参数列表中只能有一个可变参数
public static int add(int... a) {
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum = sum + a[i];
}
return sum;
}
// public static int add(int a, int b) {
// return a + b;
// }
}
Collections集合工具类
常用方法
package com.oracle.demo2;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(4);
list.add(2);
list.add(3);
list.add(9);
list.add(7);
System.out.println(list);
System.out.println("=====================");
// 将集合中元素的顺序打乱
// 该方法返回值是静态的，所以直接用类名调用方法
//该方法仅限于list集合
Collections.shuffle(list);
System.out.println(list);
System.out.println("=====================");
Collections.sort(list);
System.out.println(list);
}
}
集合嵌套
所谓的集合嵌套就是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。
1、 ArrayList嵌套 ArrayList
ArrayList< ArrayList<String> >
Collection< ArrayList<Integer> >
2、 Map嵌套 ArrayList
HashMap<String, ArrayList<Person>>
ArrayList< HashMap<String, String>>
3、 Map集合嵌套
HashMap<String, HashMap<String,String>>
HashMap<String, HashMap<Person,String>>
package com.oracle.demo2;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//集合中Map嵌套Map 的存和取
public class MapQianTao {
public static void main(String[] args) {
// 集合嵌套
HashMap<String, HashMap<Integer, String>> map = new HashMap<String, HashMap<Integer, String>>();
HashMap<Integer, String> m1 = new HashMap<Integer, String>();
m1.put(1, "张三");
m1.put(2, "李四");
map.put("Java01", m1);
HashMap<Integer, String> m2 = new HashMap<Integer, String>();
m2.put(1, "小红");
m2.put(2, "小李");
map.put("Java03", m2);
System.out.println(map);
// 获取元素(keySet) 获取set集合
Set<String> set = map.keySet();
// 遍历set集合
for (String str : set) {
//获取班级名称
String key = str;
//获取班级Map
HashMap<Integer, String> value = map.get(key);
System.out.println(key+"-------"+value);
//获取班级Map中的keySet
Set<Integer> set2=value.keySet();
//遍历学号
for(int i:set2){
//获取学生学号
int key2=i;
//获取学生学号所对应的姓名
String value2=value.get(key2);
System.out.println(key+"----"+key2+"-----"+value2);
}
}
System.out.println("==========================");
//用EntrySet获取元素
//获得映射关系set
Set<Map.Entry<String, HashMap<Integer, String>>> set2=map.entrySet();
for(Map.Entry<String, HashMap<Integer, String>> a:set2){
//获取班级名称
String k1=a.getKey();
//获取班级Map
HashMap<Integer, String> v1=a.getValue();
//获取班级Map的映射关系
Set<Map.Entry<Integer, String>> s3=v1.entrySet();
//遍历
for(Map.Entry<Integer, String> b:s3){
//获取学生学号
int k2=b.getKey();
//获取学生姓名
String v2=b.getValue();
System.out.println(k1+"--"+k2+"-------"+v2);
}
}
}
}
原文：https://www.cnblogs.com/Java-125/p/8877061.html