Java学习Map接口

Posted 2020-10-31 低调的小孩儿

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);
			}
		}
		
	}
}