集合框架
Map集合
Map集合概述和特点
Map接口概述：
- 查看API
- 将键映射到值的对象
- 一个映射不能包含重复的键
- 每个键最多只能映射到一个值
Map接口和Collection接口的不同：
- Map是双列的，Collection是单列的
- Map的键唯一，Collection的子体系Set是唯一的
- Map集合的数据结构针对键有效，跟值无关；Collection集合的数据结构是针对元素有效
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(001, "鹿秀儿");
student.put(002, "鹿遥知");
student.put(003, "鹿某人");
//根据学号获取学生名字
System.out.println(student.get(003));//鹿某人
}
}
Map集合的功能概述
添加功能
-
V put（K key，V value）：添加元素，也可以作为 替换 功能
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
String s1 = student.put(3, "鹿某人");
String s2 = student.put(3, "秀儿");
System.out.println(student);//{1=鹿秀儿, 2=鹿遥知, 3=秀儿}
System.out.println(s1);//null
System.out.println(s2);//鹿某人
}
}
删除功能
- void clear（）：移除所有的键值对元素
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
System.out.println(student);//{1=鹿秀儿, 2=鹿遥知, 3=鹿某人}
//移除所有元素
student.clear();
System.out.println(student);//{}
}
}
- V remove（Object key）：根据键删除键值对元素，并把值返回
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//根据键删除元素，返回删除掉的值
String s = student.remove(2);
System.out.println(student);//{1=鹿秀儿, 3=鹿某人}
System.out.println(s);//鹿遥知
}
}
判断功能
- boolean containsKey（Object key）：判断集合是否包含指定的键
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//判断集合是否包含指定的键
boolean b = student.containsKey(1);
boolean b1 = student.containsKey(4);
System.out.println(b);//true
System.out.println(b1);//false
}
}
- boolean containsValue（Object value）：判断集合是否包含指定的值
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//判断集合是否包含指定的值
boolean b = student.containsValue("鹿秀儿");
boolean b1 = student.containsValue("鹿鹿");
System.out.println(b);//true
System.out.println(b1);//false
}
}
- boolean isEmpty（）：判断集合是否为空
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//判断集合是否为空
boolean empty = student.isEmpty();
System.out.println(empty);//false
student.clear();
boolean empty1 = student.isEmpty();
System.out.println(empty1);//true
}
}
获取功能
- Set<Map.Entry<K,V>> entrySet（）：返回一个键值对的Set集合
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
System.out.println(student);//{1=鹿秀儿, 2=鹿遥知, 3=鹿某人}
Set<Map.Entry<Integer, String>> entries = student.entrySet();
System.out.println(entries);//[1=鹿秀儿, 2=鹿遥知, 3=鹿某人]
}
}
- V get（Object key）：根据键获取值
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//根据键获取值
System.out.println(student.get(2));
}
}
- Set keySet（）：获取集合中所有键的集合
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//获取所有键的集合
System.out.println(student.keySet());//[1, 2, 3]
}
}
- Collection values（）：获取集合中所有值的集合
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
//获取所有值的集合
System.out.println(student.values());//[鹿秀儿, 鹿遥知, 鹿某人]
}
}
长度功能
- int size（）：返回集合中的键值对的对数
import java.util.HashMap;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(1, "鹿秀儿");
student.put(2, "鹿遥知");
student.put(3, "鹿某人");
System.out.println(student.size());//3
}
}
Map集合的遍历之键找值
import java.util.HashMap;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(11, "鹿秀儿");
student.put(21, "鹿遥知");
student.put(31, "鹿某人");
//获取所有键的集合
Set<Integer> i = student.keySet();
//遍历键的集合
for (Integer integer : i) {
System.out.print(integer+"\t");
System.out.println(student.get(integer));
//21 鹿遥知
//11 鹿秀儿
//31 鹿某人
}
}
}
Map集合的遍历之键值对对象找键和值
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> student = new HashMap<>();
student.put(11, "鹿秀儿");
student.put(21, "鹿遥知");
student.put(31, "鹿某人");
Set<Map.Entry<Integer, String>> set = student.entrySet();
for (Map.Entry<Integer, String> entry : set) {
System.out.println(entry.getKey()+"\t"+entry.getValue());
}
}
}
HashMap集合键是Stirng，值是String的案例
HashMap：允许插入null键 null值
import java.util.HashMap;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("子", "鼠");
hashMap.put("丑", "牛");
hashMap.put("寅", "虎");
hashMap.put("卯", "兔");
hashMap.put("辰", "龙");
hashMap.put("巳", "蛇");
hashMap.put("午", "马");
hashMap.put("未", "羊");
hashMap.put("申", "猴");
hashMap.put("酉", "鸡");
hashMap.put("戌", "狗");
hashMap.put("亥", "猪");
hashMap.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String s, String s2) {
System.out.println(s + "\t" + s2);
}
});
}
}
HashMap集合键是String，值是Student的案例
import java.util.HashMap;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
HashMap<String, Student> hashMap = new HashMap<>();
hashMap.put("全校第一",new Student("鹿秀儿", 1003) );
hashMap.put("全级第一",new Student("鹿秀秀", 1005) );
hashMap.put("全班第一",new Student("鹿遥知", 1007) );
hashMap.forEach(new BiConsumer<String, Student>() {
@Override
public void accept(String s, Student student) {
System.out.println(s + "\t" + student.getName() + "\t" + student.getStudentNum());
}
});
}
}
public class Student {
private String name;
private int studentNum;
public Student() {
}
public Student(String name, int studentNum) {
this.name = name;
this.studentNum = studentNum;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStudentNum() {
return studentNum;
}
public void setStudentNum(int studentNum) {
this.studentNum = studentNum;
}
}
HashMap集合键是Student，值是String的案例
键唯一；注意重写hashCode（）方法和equals（）方法
import java.util.HashMap;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
HashMap<Student, String> hashMap = new HashMap<>();
hashMap.put(new Student("鹿秀儿", 1003) ,"全校第一");
hashMap.put(new Student("鹿秀秀", 1005) ,"全级第一");
hashMap.put(new Student("鹿遥知", 1007) ,"全班第一");
hashMap.forEach(new BiConsumer<Student, String>() {
@Override
public void accept(Student student, String s) {
System.out.println(student.getName() + "\t" + student.getStudentNum()+"\t"+s);
//鹿遥知 1007 全班第一
//鹿秀秀 1005 全级第一
//鹿秀儿 1003 全校第一
}
});
}
}
public class Student {
private String name;
private int studentNum;
public Student() {
}
public Student(String name, int studentNum) {
this.name = name;
this.studentNum = studentNum;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStudentNum() {
return studentNum;
}
public void setStudentNum(int studentNum) {
this.studentNum = studentNum;
}
}
LinkedHashMap的概述和使用
LinkedHashMap的概述：
Map接口的哈希表和链接列表实现，具有可预知的迭代顺序
LinkedHashMap的特点：
底层的数据结构是链表和哈希表，元素有序，并且唯一
元素的有序性由链表数据结构保证；唯一性由 哈希表数据结构保证
Map集合的数据结构只和键有关
import java.util.LinkedHashMap;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
LinkedHashMap<Integer, String> hashMap = new LinkedHashMap<>();
hashMap.put(1, "鹿秀儿");
hashMap.put(2, "鹿秀");
hashMap.put(3, "路遥知");
hashMap.put(4, "秀儿");
hashMap.forEach(new BiConsumer<Integer, String>() {
@Override
public void accept(Integer integer, String s) {
System.out.println(integer + "\t" + s);
}
});
}
}
TreeMap集合键是String值是String的案例
TreeMap键不允许插入null
TreeMap：
- 键的数据结构是红黑树,可保证键的排序和唯一性
- 排序分为自然排序和比较器排序
- 线程是不安全的效率比较高
import java.util.TreeMap;
public class MyTest {
public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(10, "aaa");
treeMap.put(5, "aaa");
treeMap.put(1, "aaa");
treeMap.put(63, "aaa");
treeMap.put(10, "aaa");
treeMap.put(19, "aaa");
System.out.println(treeMap);//{1=aaa, 5=aaa, 10=aaa, 19=aaa, 63=aaa}
}
}
TreeMap集合键是Student值是String的案例
import java.util.TreeMap;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
TreeMap<Student, String> treeMap = new TreeMap<>();
treeMap.put(new Student("鹿秀儿", 19), "我是鹿秀儿");
treeMap.put(new Student("鹿遥知", 22), "我是鹿遥知");
treeMap.put(new Student("路遥知", 27), "我是路遥知");
treeMap.put(new Student("路遥知", 19), "我是路遥知");
treeMap.forEach(new BiConsumer<Student, String>() {
@Override
public void accept(Student student, String s) {
System.out.println(student.getName() + "\t" + student.getAge() + "\t" + s);
//路遥知 19 我是路遥知
//鹿秀儿 19 我是鹿秀儿
//鹿遥知 22 我是鹿遥知
//路遥知 27 我是路遥知
}
});
}
}
public class Student implements Comparable{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 int compareTo(Object o) {
Student student= (Student) o;
int a=this.age-student.age;
int b= (a == 0) ? this.name.compareTo(student.name): a;
return b;
}
}
统计字符串中每个字符出现的次数
需求：统计字符串中每个字符出现的次数
import java.util.HashMap;
import java.util.Scanner;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请随便输入一段字符串");
String s = sc.nextLine();//aababcabcdabcde
HashMap<Character, Integer> hashMap = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
if (!hashMap.containsKey(s.charAt(i))){
hashMap.put(s.charAt(i), 1);
}else{
int m=hashMap.get(s.charAt(i));
m++;
hashMap.put(s.charAt(i), m);
}
}
hashMap.forEach(new BiConsumer<Character, Integer>() {
@Override
public void accept(Character character, Integer integer) {
System.out.print(character + "(" + integer + ")");//a(5)b(4)c(3)d(2)e(1)
}
});
}
}
集合嵌套之HashMap嵌套HashMap
import java.util.HashMap;
import java.util.function.BiConsumer;
public class MyTest {
public static void main(String[] args) {
//基础班集合
HashMap<String, Integer> jcMap = new HashMap<>();
jcMap.put("张三", 20);
jcMap.put("李四", 22);
//就业班集合
HashMap<String, Integer> jyMap = new HashMap<>();
jyMap.put("王五", 21);
jyMap.put("赵六", 23);
//大集合用来装两个小集合
HashMap<String, HashMap<String, Integer>> max = new HashMap<>();
max.put("基础班", jcMap);
max.put("就业班", jyMap);
max.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
@Override
public void accept(String s, HashMap<String, Integer> m) {
System.out.println(s);
m.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String s, Integer integer) {
System.out.println("\t" + s + "\t" + integer);
/*就业班
王五 21
赵六 23
基础班
李四 22
张三 20*/
}
});
}
});
}
}
集合嵌套之HashMap嵌套ArrayList
import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class MyTest {
public static void main(String[] args) {
ArrayList<String> sglist = new ArrayList<>();
sglist.add("吕布");
sglist.add("周瑜");
ArrayList<String> xalist = new ArrayList<>();
xalist.add("令狐冲");
xalist.add("林平之");
ArrayList<String> sdlist = new ArrayList<>();
sdlist.add("郭靖");
sdlist.add("杨过");
HashMap<String, ArrayList<String>> max = new HashMap<>();
max.put("三国演义", sglist);
max.put("笑傲江湖", xalist);
max.put("神雕侠侣", sdlist);
max.forEach(new BiConsumer<String, ArrayList<String>>() {
@Override
public void accept(String s, ArrayList<String> strings) {
System.out.println(s);
strings.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println("\t" + s);
/*神雕侠侣
郭靖
杨过
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之*/
}
});
}
});
}
}
集合嵌套之ArrayList嵌套HashMap
import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class MyTest {
public static void main(String[] args) {
HashMap<String, String> sgmap = new HashMap<>();
sgmap.put("周瑜", "小乔");
sgmap.put("吕布", "貂蝉");
HashMap<String, String> sdmap = new HashMap<>();
sdmap.put("郭靖", "黄蓉");
sdmap.put("杨过", "小龙女");
HashMap<String, String> xamap = new HashMap<>();
xamap.put("令狐冲", "任盈盈");
xamap.put("林平之", "岳灵珊");
ArrayList<HashMap<String, String>> maps = new ArrayList<>();
maps.add(sgmap);
maps.add(sdmap);
maps.add(xamap);
maps.forEach(new Consumer<HashMap<String, String>>() {
@Override
public void accept(HashMap<String, String> map) {
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String s, String s2) {
System.out.println(s + "---" + s2);
}
});
System.out.println();
/*吕布---貂蝉
周瑜---小乔
杨过---小龙女
郭靖---黄蓉
令狐冲---任盈盈
林平之---岳灵珊*/
}
});
}
}
HashMap和Hashtable的区别
HashMap和Hashtable的区别：查看API可以知道
HashMap：线程不安全，效率高，允许null值和null键
Hashtable：线程安全 , 效率低，不允许null值和null键
Collections工具类的概述和常见方法讲解
Collections类概述：针对集合操作 的工具类
Collections成员方法
- public static void sort（List list）：排序,默认按照自然顺序
import java.util.ArrayList;
import java.util.Collections;
public class MyTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(100);
list.add(203);
list.add(20333);
list.add(2014);
Collections.sort(list);
System.out.println(list);//[20, 100, 203, 2014, 20333]
}
}
- public static int binarySearch（List<?> list，T key）：二分查找
import java.util.ArrayList;
import java.util.Collections;
public class MyTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(100);
list.add(203);
list.add(20333);
list.add(2014);
System.out.println(Collections.binarySearch(list, 100));//1
}
}
- public static T max（Collection<?> coll）：获取最大值
import java.util.ArrayList;
import java.util.Collections;
public class MyTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(100);
list.add(203);
list.add(20333);
list.add(2014);
System.out.println(Collections.max(list));//20333
}
}
- public static void reverse（List<?> list）：反转
import java.util.ArrayList;
import java.util.Collections;
public class MyTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(100);
list.add(203);
list.add(20333);
list.add(2014);
Collections.reverse(list);
System.out.println(list);//[2014, 20333, 203, 100, 20]
}
}
- public static void shuffle（List<?> list）：随机置换
import java.util.ArrayList;
import java.util.Collections;
public class MyTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(100);
list.add(203);
list.add(20333);
list.add(2014);
Collections.shuffle(list);
System.out.println(list);//[20, 2014, 203, 20333, 100]
}
}
模拟斗地主洗牌和发牌
import java.util.*;
public class doudizhu {
public static void main(String[] args) {
//创建牌盒
ArrayList<String> pokerBox = new ArrayList<>();
//把牌放进去
String[] colors = {"♠","♥","♦","♣"};
String[] nums={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for (String color : colors) {
for (String num : nums) {
String poker = color.concat(num);
pokerBox.add(poker);
}
}
//放大小王
pokerBox.add("☀");
pokerBox.add("☼");
//洗牌
Collections.shuffle(pokerBox);
Collections.shuffle(pokerBox);
Collections.shuffle(pokerBox);
//发牌
ArrayList<String> 鹿 = new ArrayList<>();
ArrayList<String> 遥 = new ArrayList<>();
ArrayList<String> 知 = new ArrayList<>();
ArrayList<String> 底 = new ArrayList<>();
for (int i = 0; i < pokerBox.size(); i++) {
if(i>=pokerBox.size()-3){
底.add(pokerBox.get(i));
}else if(i%3==0){
鹿.add(pokerBox.get(i));
}else if(i%3==1){
遥.add(pokerBox.get(i));
}else if(i%3==2){
知.add(pokerBox.get(i));
}
}
lookPoker("鹿", 鹿);
lookPoker("遥", 遥);
lookPoker("知", 知);
lookPoker("底", 底);
}
private static void lookPoker(String name, ArrayList<String> list) {
System.out.println(name);
for (String poker : list) {
System.out.print(poker+"\t");
}
System.out.println();
}
}
模拟斗地主洗牌和发牌并对牌进行排序的原理图解
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class 斗地主排序版 {
public static void main(String[] args) {
HashMap<Integer, String> hm = new HashMap<>();
ArrayList<Integer> indexs = new ArrayList<>();
String[] colors = {"♠", "♥", "♦", "♣"};
String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
//生成牌
int index = 0;
for (String num : nums) {
for (String color : colors) {
hm.put(index, num.concat(color));
indexs.add(index);
index++;
}
}
//手动添加大小王
// System.out.println(index);
hm.put(index, "●");
indexs.add(index);
index++;
hm.put(index, "☀");
indexs.add(index);
// System.out.println(hm);
// System.out.println(indexs);
//洗牌
Collections.shuffle(indexs);
Collections.shuffle(indexs);
Collections.shuffle(indexs);
//发牌：发索引集合
//发牌：得有三个人来斗地主，还得留三张底牌
TreeSet<Integer> 星仔 = new TreeSet<>();
TreeSet<Integer> 刀仔 = new TreeSet<>();
TreeSet<Integer> 高进 = new TreeSet<>();
TreeSet<Integer> 底牌 = new TreeSet<>();
for (int i = 0; i < indexs.size(); i++) {
//留底牌
if (i >= indexs.size() - 3) {
底牌.add(indexs.get(i));
} else if (i % 3 == 0) {
星仔.add(indexs.get(i));
} else if (i % 3 == 1) {
刀仔.add(indexs.get(i));
} else {
高进.add(indexs.get(i));
}
}
//看牌:键找值
lookPoker("星仔", 星仔,hm);
lookPoker("刀仔 ", 刀仔, hm);
lookPoker("高进", 高进, hm);
lookPoker("底牌", 底牌, hm);
}
private static void lookPoker(String name, TreeSet<Integer> set, HashMap<Integer, String> hm) {
System.out.println(name);
for (Integer key : set) {
String s = hm.get(key);
System.out.print(s+"\t");
}
System.out.println();
}
}
完
扫一扫
360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
