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