Java基础学习之Map集合

一 map集合的特点

---以键值对形式来保存数据   key   ---value  只能保存对象

 键(key)值(value)来保存数据，其中值(value)可以重复，但键(key)必须是唯一，相同就覆盖.

 也可以为空，但最多只能有一个key为空，

 它的主要实现类有HashMap(去重)、LinkedHashMap、TreeMap(排序)。 指的都是对key 的操作.

 HashSet 去重 和 HashMap 的关系

 HashSet依赖Map 存储数据,set在保存数据时,实际上是在向Map中key 这一列中存数据

一 首先创建一个HashMap 看一下它的用法

public static void fun1() {
		//创建一个HashMap
       HashMap<String, Integer> map = new HashMap<>();
    Integer k = map.put("前海", 62);// k 表示被覆盖的 value值(null)
    Integer k1 = map.put("后海", 61);
    Integer k2 = map.put("左海", 65);
    Integer k3 = map.put("右海", 60);
    Integer k4 = map.put("右海", 70);
       System.out.println(k);
       System.out.println(k1);
       System.out.println(k2);
       System.out.println(k3);
       System.out.println(k4);
       System.out.println(map);
	}

打印结果:

null
null
null
null
60
{前海=62, 后海=61, 左海=65, 右海=70}

map添加方法返回的是前一个value值  k k1 k2 k3 未创建之前 value值都为null.

以下是map的一些操作方法

public static void fun2() {
		HashMap<String, Integer> map = new HashMap<>();
		//判断包含 
		map.put("前海", 62);
	    map.put("后海", 61);
	    map.put("左海", 65);
	    map.put("右海", 60);
	     boolean b1 = map.containsKey("大海");
	     boolean b2 = map.containsValue(70);
	     System.out.println(b1);
	     System.out.println(b2);
		//获取Map中所有key的Set集合
	    Set<String> set = map.keySet();
	    System.out.println(set);
	    //获取Map中所有value的Collection集合
	   Collection<Integer> vCollection = map.values();
	   System.out.println(vCollection);
	   
	   //删除,根据key 删除整个键值对
	 Integer v =  map.remove("后海");
	   System.out.println(v);
	   System.out.println(map.toString());
	   
	   //清空 Map
	   map.clear();
	   System.out.println(map);
	}

创建一个map key保存学生 value保存 户籍 去重

跟Set 集合一样重写HashCode 和 equals 方法

public static void fun3() {
		//创建一个map key保存学生 value保存 户籍 去重
		//跟Set 集合一样重写HashCode 和 equals 方法
		HashMap<Student, String> map = new HashMap<>();
		map.put(new Student("大海", 11), "北京");
		map.put(new Student("天瑞", 11), "上海");
		map.put(new Student("董小姐", 11), "北海道");
		map.put(new Student("大海", 11), "天津");
	    System.out.println(map);
	}

Student 类中重写

{[天瑞, 11]=上海, [董小姐, 11]=北海道, [大海, 11]=天津}

遍历map的两种方法

public static void fun4() {
		//遍历Map
		HashMap<String, Integer> map = new HashMap<>();
		//判断包含 
		map.put("前海", 62);
	    map.put("后海", 61);
	    map.put("左海", 65);
	    map.put("右海", 60);
	   //通过迭代器
	  Set<String> s1=  map.keySet();
	  Collection<Integer>c1 = map.values();
	  Iterator<String> iterator =s1.iterator();
	  Iterator<Integer> iterator2 = c1.iterator();
	  while (iterator.hasNext()) {
		String string = iterator.next();
		Integer integer = iterator2.next();
		
		System.out.println(string+"="+integer);
	}
	  System.out.println("*******************");

//通过增强for循环
	 for (String key : map.keySet()) {
		Integer value = map.get(key);
		System.out.println(key+"="+value);
		System.out.println("-------------------");
	    }
	}

//另外使用Entry也可以遍历map 

public static void fun5() {
		HashMap<String, Integer> map = new HashMap<>();
		//Entry接口
		//Entry 中保存的是 键值对对象
		// 相当于把Map 中的key 和 value 封装成了一个对象
		map.put("前海", 62);
	        map.put("后海", 61);
	        map.put("左海", 65);
	        map.put("右海", 60);
	 //利用entrySet 遍历集合(迭代器)
	    //增强for循环
	    Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
	     Iterator<Map.Entry<String, Integer>>  iterator = entrySet.iterator();
	      while (iterator.hasNext()) {
		Entry<String , Integer> entry = iterator
				.next();
		 //从对象中获取 key 和 value
//		String key = entry.getKey();
//		Integer value = entry.getValue();
//		System.out.println(key+"="+value);
		System.out.println(entry);
	}
	}

//父类是HashMap(同HashSet)
		//特点:有序的(怎么存的,怎么按顺序打印出来)
		LinkedHashMap<String, Integer> lMap = new LinkedHashMap<>();
		lMap.put("前海", 62);
	    lMap.put("后海", 61);
	    lMap.put("左海", 65);
	    lMap.put("右海", 60);
		System.out.println(lMap);

TreeMap

使用TreeMap排序

public static void fun1() {
		//使用TreeMap 进行排序
		//跟TreeSet相同
		TreeMap<Student, String> treeMap = new TreeMap<>();
		treeMap.put(new Student("大海", 5), "马栏山");
		treeMap.put(new Student("中海", 15), "牛栏山");
		treeMap.put(new Student("小海", 20), "羊栏山");
		System.out.println(treeMap);
	}

package com.lanou3g;

public class Student implements Comparable<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 "[" + 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;
		Student other = (Student) 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;
	}
	@Override
	public int compareTo(Student o) {
		int n = this.age-o.getAge();
		return n==0?-1:n;
	}
	

}

Student 类实现了comparable接口,重写了compareTo方法.或者向下面一样创建个比较器类 要TreepMap 实现kjf类

class kjf implements Comparator<Student>{

	@Override
	public int compare(Student o1, Student o2) {
		int n = o1.getAge()-o2.getAge();
		return n==0?-1:n;
	}

工具类collections 的3中常用方法

public static void fun2() {
		//  洗牌方法 .随机打乱集合的顺序
		ArrayList<Integer> list  = new ArrayList<>();
		list.add(1);
		list.add(3);
		list.add(4);
		list.add(2);
		list.add(5);
		list.add(8);
		list.add(9);
		list.add(7);
		list.add(6);
		System.out.println(list);
//		Collections.shuffle(list);
		System.out.println("-----------------");
		System.out.println(list);
		//反转
		Collections.reverse(list);
		System.out.println(list);
		//排序
		Collections.sort(list);
		//二分查找
		int index=Collections.binarySearch(list, 15);
		System.out.println(list);
		System.out.println(index);
	}

利用collections 中的排序方法 排序对象

使用该方法时,也需要实现Comparable 接口  写排序规则.

ArrayList<Student> list  = new ArrayList<>();
		list.add(new Student("大海", 18));
		list.add(new Student("中海", 15));
		list.add(new Student("小海", 60));
		Collections.sort(list);
		System.out.println(list);
	}

下面看一个Map应用的小例子:

 1.创建一副牌1-k 大王 小王   (使用Map集合)

 2.洗牌

 3.发牌 三个人 和底牌

 4.看牌 需要排序

 *思路:

 1.创建一个Map 

 2.拼接牌的字符串

 3.放到集合中 集合中的key 为0-53

 4.创建list 洗牌

 5.发索引

 6.将索引保存到 能排序的treeset

 7.通过索引找到对应的牌

package com.lanou3g;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class Demo04 {
	public static void main(String[] args) {
		//创建一个Map
		HashMap<Integer, String> card = new HashMap<>();
		//创建一个list保存索引
		ArrayList<Integer> list = new ArrayList<>();
		int index =0;
		// 拼接牌的字符串
		// 字符串1保存 牌数
		String [] arr1 = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
		String [] arr2 = {"♠️","♥️","♣️","♦️"};
		for (int i = 0; i < arr2.length; i++) {
			for (int j = 0; j < arr1.length; j++) {
				String str = arr2[i]+arr1[j];
				//放入map中
				card.put(index, str);
				list.add(index);
				index++;
			}
		}
		System.out.println(card);
		
		 //大王 小王放入map
	 	  card.put(index, "小王");
	 	  list.add(index);
		  card.put(++index, "大王");
		  System.out.println(card);
		  list.add(index);
		  System.out.println(list);
		//洗牌 
		  Collections.shuffle(list);
		  System.out.println(list);
		//发牌
		  TreeSet<Integer> set1 = new TreeSet<>();
		  TreeSet<Integer> set2 = new TreeSet<>();
		  TreeSet<Integer> set3 = new TreeSet<>();
		  TreeSet<Integer> set4 = new TreeSet<>();
		//发list 索引
		  for (int i = 0; i < list.size(); i++) {
			//取出每一个索引
			  Integer n =list.get(i);
			  if (i>list.size()-3) {
				set4.add(n);
			}else {
				if (i%3 == 0) {
					set1.add(n);
				}else {
					if (i%3==1) {
						set2.add(n);
					}else {
						set3.add(n);
					}
				}
			}
		}
		  //看牌 调用看牌的方法
		  kanPai(card, set1, "大海");
		  kanPai(card, set2, "阿凡达");
		  kanPai(card, set3, "瑞");
		  kanPai(card, set4, "底牌");  
	}
	// 看牌 通过索引找到对应的牌
	  
			 public static void kanPai(HashMap<Integer, String> card,
					 TreeSet<Integer> set,
					 String name) {
				 System.out.println(name+"的牌:" );
				//遍历set
				 for (Integer key : set) {
					//从Map通过索引 中取出牌
					 String value = card.get(key);
					 System.out.print(value+" ");
				}
				 System.out.println();
			 }

}

map嵌套

/*
	 * Map嵌套
	 * Java学科
	 * java 1班  -- 保存是学生 和 户籍
	 * key shi 学生  value 是字符串
	 * java 2班  -- 保存是学生 和 户籍
	 * 
	 * Java学科 是一个map
	 * key 是班级的 小map
	 * 保存了两个键值对 ----  1班 和 2班 value 是字符串 1班或2班
	 * 遍历一下
 */

import java.util.HashMap;

public class Demo05 {
     public static void main(String[] args) {
		//Java 一班
    	 HashMap<Student, String> map1 = new HashMap<>();
    	 map1.put(new Student("前海", 11),"牛蓝山");
    	 map1.put(new Student("后海", 15),"祖兰山");
    	 // Java 二班
    	 HashMap<Student, String> map2 = new HashMap<>();
    	 map2.put(new Student("左瑞", 10),"黑栏山");
    	 map2.put(new Student("右瑞", 19),"白栏山");
    	 
    	 //创建 Java学科
    	 HashMap<HashMap<Student, String>, String> javamap = new HashMap<>();
    	 javamap.put(map1, "Java一班");
    	 javamap.put(map2, "Java二班");
    	 System.out.println(javamap);
    	 //遍历
    	 for (HashMap<Student, String> ban : javamap.keySet()) {
    		 //打印班
    		 System.out.println(javamap.get(ban));
    		 //遍历班
			for (Student stu : ban.keySet()) {
				//打印学生和户籍
				System.out.print("户籍:"+ban.get(stu)+"  ");
				System.out.print("学生:"+stu+"  ");
			}
			System.out.println();
		}
	}
}