目录
思维导图
1 Map集合
1.1 Map集合概述和使用
Map集合概述
● Interface Map <K,V> K：键的类型；V：值的类型
● 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
● 举例：学生的学号和姓名
001 张三
002 李四
003 王五
创建Map集合的对象
● 多态的方式
● 具体的实现类HashMap
示例代码：
public class Test {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("001","张三");
map.put("002","李四");
map.put("003","王五");
map.put("003","李留");
System.out.println(map);
}
}运行结果;
根据运行结果与代码比较，我们发现后添加003的值把前面003的顶替了，这是为了保证键的唯一性，所以，当键一致时，V put(K key, V value)可做修改使用
1.2 Map集合的基本功能
1.3 Map集合的获取功能
1.4 Map集合的遍历（方式1）
遍历思路：
● 获取所有键的集合，有keySet()方法实现
● 遍历键的集合，获取到每一个键。用增强for实现
● 根据键去找值，用get(Object key)方法实现
示例代码：
public class Test_02 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("001","张三");
map.put("002","李四");
map.put("003","王五");
//获取所有键的集合，有keySet()方法实现
Set<String> keySet = map.keySet();
//遍历键的集合，获取到每一个键。用增强for实现
for (String key : keySet){
//根据键去找值，用get(Object key)方法实现
String value = map.get(key);
System.out.println(key + "," + value);
}
}
}运行结果：
1.5 Map集合的遍历（方式2）
遍历思路：
● 获取所有键值对对象的集合
Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
● 遍历键值对对象的集合，得到每一个键值对对象
用增强for实现，得到每一个Map.Entry
● 根据键值对对象获取键和值
用getKey()得到键
用getValue()得到值
示例代码：
public class Test_03 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("001","张三");
map.put("002","李四");
map.put("003","王五");
//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> me : entrySet){
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "," + value);
}
}
}运行结果：
案例：HashMap集合存储学生对象并遍历
需求：创建一个HashMap集合，键是学号（String），值是学生对象（Student），存储三个键值对元素，并遍历
示例代码：
//学生类
public class Student {
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;
}
}
//测试类
public class Test {
public static void main(String[] args) {
Map<String,Student> map = new HashMap<String,Student>();
Student s1 = new Student("jack",20);
Student s2 = new Student("mary",17);
Student s3 = new Student("jane",23);
map.put("001",s1);
map.put("002",s2);
map.put("003",s3);
Set<String> keySet = map.keySet();
for (String key : keySet){
Student value = map.get(key);
System.out.println(key+","+value.getName()+","+value.getAge());
}
System.out.println("---------------------------------");
Set<Map.Entry<String, Student>> entrySet = map.entrySet();
for (Map.Entry<String, Student> me : entrySet){
String key = me.getKey();
Student value = me.getValue();
System.out.println(key+","+value.getName()+","+value.getAge());
}
}
}
运行结果：
案例：HashMap集合存储学生对象并遍历
需求：创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象
示例代码：
//学生类
public class Student {
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 boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
//测试类
public class Test {
public static void main(String[] args) {
HashMap<Student,String> hm = new HashMap<Student,String >();
Student s1 = new Student("jack",21);
Student s2 = new Student("mary",20);
Student s3 = new Student("jane",17);
Student s4 = new Student("jane",17);
hm.put(s1,"北京");
hm.put(s2,"上海");
hm.put(s3,"天津");
hm.put(s4,"重庆");
Set<Student> keySet = hm.keySet();
for (Student key : keySet){
String value = hm.get(key);
System.out.println(key.getName() + "," + key.getAge() + "," + value);
}
}
}
运行结果：
案例：ArrayList集合存储HashMap元素并遍历
需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String，并遍历。
示例代码：
public class Test {
public static void main(String[] args) {
ArrayList<HashMap<String,String>> array = new ArrayList<HashMap<String,String>>();
HashMap<String,String> hm1 = new HashMap<String,String>();
hm1.put("李白","孟浩然");
hm1.put("杜甫","王维");
array.add(hm1);
HashMap<String,String> hm2 = new HashMap<String,String>();
hm2.put("陆游","王安石");
hm2.put("苏轼","苏辙");
array.add(hm2);
HashMap<String,String> hm3 = new HashMap<String,String>();
hm3.put("柳如是","唐寅");
hm3.put("高启","宋濂");
array.add(hm3);
for (HashMap<String,String> hm : array){
Set<String> keySet = hm.keySet();
for (String key : keySet){
String value = hm.get(key);
System.out.println(key + "," + value);
}
}
}
}
运行结果：
案例：HashMap集合存储ArrayList元素并遍历
需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList
每一个ArrayList的元素是String，并遍历。
示例代码：
public class Test_02 {
public static void main(String[] args) {
HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
ArrayList<String> gy = new ArrayList<String >();
gy.add("齐司礼");
gy.add("查理苏");
hm.put("光与夜之恋",gy);
ArrayList<String> wd = new ArrayList<String >();
wd.add("左然");
wd.add("陆景和");
hm.put("未定事件簿",wd);
ArrayList<String> ly = new ArrayList<String >();
ly.add("白起");
ly.add("李哲言");
hm.put("恋与制作人",ly);
Set<String> keySet = hm.keySet();
for (String key : keySet){
System.out.println(key);
ArrayList<String> value = hm.get(key);
for (String s : value){
System.out.println("\t" + s);
}
}
}
}
运行结果：
案例：统计字符串中每个字符出现的次数
需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
举例：键盘录入“aababcabcdabcde” 在控制台输出：“a(5)b(4)c(3)d(2)e(1)”
示例代码：
public class Test_03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
// HashMap<Character,Integer> hm = new HashMap<Character,Integer>();
TreeMap<Character,Integer> hm = new TreeMap<Character,Integer>();
for (int i = 0; i < line.length(); i++) {
char key = line.charAt(i);
Integer value = hm.get(key);
if (value == null){
hm.put(key,1);
}else {
value++;
hm.put(key,value);
}
}
StringBuilder sb = new StringBuilder();
Set<Character> keySet = hm.keySet();
for (Character key : keySet){
Integer value = hm.get(key);
sb.append(key).append("(").append(value).append(")");
}
String s = sb.toString();
System.out.println(s);
}
}
运行结果：
2 Conllections
2.1 Collections概述和使用
Collections类的概述
● 是针对集合操作的工具类
Collections类的常用方法
● public static <T extends Comparable <? super T>> void sort(List<T> list)：将指定的列表按升序排序
● public static void reverse(List <?> list)：反转指定列表中元素的顺序
● public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
public class CollectionsDemo01 {
public static void main(String[] args) {
//创建集合对象
List<Integer> list = new ArrayList<Integer>();
//添加元素
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
//public static <T extends Comparable<? super T>> void sort(List<T> list)：将指定的列表按升序排序
// Collections.sort(list);
//public static void reverse(List<?> list)：反转指定列表中元素的顺序
// Collections.reverse(list);
//public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
Collections.shuffle(list);
System.out.println(list);
}
}案例：ArrayList存储学生对象并排序
需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
示例代码：
public class Test {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList<Student> array = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("linqingxia", 30);
Student s2 = new Student("zhangmanyu", 35);
Student s3 = new Student("wangzuxian", 33);
Student s4 = new Student("liuyan", 33);
//把学生添加到集合
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
Collections.sort(array, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
for (Student s : array){
System.out.println(s.getName() + "," + s.getAge());
}
}
}
运行结果：
案例：模拟斗地主
需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
示例代码：
public class Test_02 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
//定义花色数组
String[] colors = {"♦", "♣", "♥", "♠"};
//定义点数数组
String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
for (String color : colors){
for (String num : numbers){
array.add(color+num);
}
}
array.add("小王");
array.add("大王");
Collections.shuffle(array);
ArrayList<String> qslArray = new ArrayList<String>();
ArrayList<String> lcArray = new ArrayList<String>();
ArrayList<String> zlsArray = new ArrayList<String>();
ArrayList<String> dpArray = new ArrayList<String>();
for (int i = 0; i < array.size(); i++) {
String poker = array.get(i);
if (i >= array.size() - 3){
dpArray.add(poker);
}else if (i%3 == 0){
qslArray.add(poker);
}else if (i % 3 == 1){
lcArray.add(poker);
} else if (i % 3 == 2) {
zlsArray.add(poker);
}
}
lookPoker("齐司礼",qslArray);
lookPoker("陆沉", lcArray);
lookPoker("查理苏",zlsArray);
lookPoker("底牌",dpArray);
}
public static void lookPoker(String name, ArrayList<String> array) {
System.out.print(name + "的牌是：");
for (String poker : array) {
System.out.print(poker + " ");
}
System.out.println();
}
}
案例：斗地主（升级版）
需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序
示例代码：
public class Test {
public static void main(String[] args) {
//创建HashMap，键是编号，值是牌
HashMap<Integer,String > hm = new HashMap<Integer,String>();
//创建ArrayList，存储编号
ArrayList<Integer> array = new ArrayList<Integer>();
//定义花色数组
String[] colors = {"♦", "♣", "♥", "♠"};
//定义点数数组
String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
//从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
int index = 0;
for(String num : numbers){
for (String color : colors){
hm.put(index,color+num);
array.add(index);
index++;
}
}
hm.put(index,"小王");
array.add(index);
index++;
hm.put(index,"大王");
array.add(index);
index++;
//洗牌(洗的是编号)，用Collections的shuffle()方法实现
Collections.shuffle(array);
//发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
TreeSet<Integer > qslArray = new TreeSet<Integer>();
TreeSet<Integer > lcArray = new TreeSet<Integer>();
TreeSet<Integer > zlsArray = new TreeSet<Integer>();
TreeSet<Integer > dpArray = new TreeSet<Integer>();
for (int i = 0; i < array.size(); i++) {
int a = array.get(i);
if (i >= array.size() - 3){
dpArray.add(a);
} else if (i%3 == 0) {
qslArray.add(a);
}else if (i%3==1){
lcArray.add(a);
} else if (i%3 == 2) {
zlsArray.add(a);
}
}
//调用看牌方法
lookPoker("齐司礼",qslArray,hm);
lookPoker("陆沉",lcArray,hm);
lookPoker("查理苏",zlsArray,hm);
lookPoker("底牌",dpArray,hm);
}
//定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer,String> hm){
System.out.print(name + "的牌是：");
for(Integer key : ts){
String value = hm.get(key);
System.out.print(" " + value);
}
System.out.println();
}
}
1471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
