目录:
Map集合
HashMap和Hashtable的区别
Collections(集合工具类)
集合练习
模拟斗地主(洗牌,发牌,看牌)
Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效,跟值无关;Collection集合的数据结构是针对元素有效
1、map
Map集合的功能概述:
a:添加功能
V put(K key,V value):添加元素。这个其实还有另一个功能?替换
如果键是第一次存储,就直接存储元素,返回null
如果键不是第一次存在,就用值把以前的值替换掉,返回以前的值
b:删除功能
void clear():移除所有的键值对元素
V remove(Object key):根据键删除键值对元素,并把值返回
c:判断功能
boolean containsKey(Object key):判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty():判断集合是否为空
d:获取功能
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set keySet():获取集合中所有键的集合
Collection values():获取集合中所有值的集合
e:长度功能
int size():返回集合中的键值对的对数
2、HashMap和Hashtable的区别
// HashMap 基于哈希表的 Map接口的实现。这种实现提供了所有可选的Map操作,并允许 null值和 null关键。 线程不安全效率高
// Hashtable 不允许存 null 键和null值 线程安全 效率低
3、 Collections(集合工具类)
Collections:集合工具类 包含对集合排序 二分查找 打乱集合元素顺序 获取最大值等功能
public static <T> void sort(List<T> list) :将指定的集合进行排序
public static <T> int binarySearch(List<?> list,T key):在指定的集合中,进行指定元素的二分查找
public static <T> T max(Collection<?> coll) 获取结合中最大的元素
public static void reverse(List<?> list) 将集合中的元素反转
public static void shuffle(List<?> list) 将集合中的元素随机置换
public static <T> void sort(List<T> list) : 将指定集合的元素进行排序
public static <T> void sort(List<T> list, Comparator<T> c)根据指定比较器产生的顺序对指定列表进行排序
4、集合练习
集合练习
1、请编写程序,统计一个字符串中每个字符出现的次数
思路:1.遍历字符串,截取每一个字符
2.判断字符是不是第一次出现 map.get(ch)==null的话就是第一次出现
3.如果不是第一次出现就获取它的值,加1在进行保存
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class MapDemo {
public static void main(String[] args) {
TreeMap<Character, Integer> map = new TreeMap<>();
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一段字符串");
String str=scanner.next();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (map.get(c)==null){
map.put(c,1);
}else if (map.get(c)!=null){
Integer value = map.get(c);
value++;
map.put(c,value);
}
}
StringBuffer sb = new StringBuffer();
Set<Character> keySet = map.keySet();
for (Character cha:keySet){
sb.append(cha).append("(").append(map.get(cha)).append(")");
}
System.out.println(sb);
}
}
2、请编写程序,存储自定义对象到HashMap集合中,并采用两种方式遍历
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class HashMapDemo {
public static void main(String[] args) {
HashMap<String, Person> hashMap = new HashMap<>();
hashMap.put("s001",new Person("张三",23));
hashMap.put("s002",new Person("张三",23));
hashMap.put("s003",new Person("李四",25));
hashMap.put("s004",new Person("李四",23));
hashMap.put("s005",new Person("赵六",26));
hashMap.put("s006",new Person("王八",28));
Person put = hashMap.put("s001", new Person("张三", 27));
System.out.println(put);//返回的是被替换掉的键
// System.out.println(hashMap);跟值无关,键一样值就会覆盖
//方式1 先获取键的集合
Set<String> keySet = hashMap.keySet();
for (String s : keySet) {
Person value = hashMap.get(s);
System.out.println(s+"=="+value);
}
System.out.println("-----------------");
//方式2获取键值对集
Set<Map.Entry<String, Person>> entries = hashMap.entrySet();
for (Map.Entry<String, Person> entry : entries) {
String key = entry.getKey();
Person value = entry.getValue();
System.out.println(key+"=="+value);
}
}
}
3、请编写程序,存储自定义对象到TreeMap集合中,并采用两种方式遍历
public class Student implements Comparable<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 int compareTo(Student o) {
int i = this.name.compareTo(o.name);
int num=i==0?this.age-o.age:i;
return num;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreemapDemo {
public static void main(String[] args) {
TreeMap<Student, Integer> treeMap = new TreeMap<Student, Integer>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int i = o1.getAge() - o2.getAge();
int num=i==0?o1.getName().compareTo(o2.getName()):i;
return num;
}
});
treeMap.put(new Student("王五",18),23);
treeMap.put(new Student("王五",18),23);
treeMap.put(new Student("王五",19),24);
treeMap.put(new Student("赵六",18),25);
treeMap.put(new Student("钱期",20),26);
treeMap.put(new Student("王八",23),27);
treeMap.put(new Student("周九",22),23);
Set<Student> keySet = treeMap.keySet();
for (Student stu : keySet) {
Integer value = treeMap.get(stu);
System.out.println(stu+"=="+value);
}
System.out.println("-------------------------------------");
TreeMap<Student, Integer> map = new TreeMap<>();
map.put(new Student("王五",18),23);
map.put(new Student("王五",18),23);
map.put(new Student("王五",19),24);
map.put(new Student("赵六",18),25);
map.put(new Student("钱期",20),26);
map.put(new Student("王八",23),27);
map.put(new Student("周九",22),23);
Set<Map.Entry<Student, Integer>> entries = map.entrySet();
for (Map.Entry<Student, Integer> entry : entries) {
Student key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"=="+value);
}
}
}
3、请编写程序,完成集合嵌套,并遍历
传智播客
jc 基础班
张三 20
李四 22
jy 就业班
王五 21
赵六 23
HashMap嵌套HashMap
package QtDemo;
import java.util.HashMap;
import java.util.Set;
public class demo {
public static void main(String[] args) {
// 传智播客
// jc 基础班
// 张三 20
// 李四 22
// jy 就业班
// 王五 21
// 赵六 23
HashMap<String, Integer> jc = new HashMap<>();
jc.put("张三",20);
jc.put("李四",22);
HashMap<String, Integer> jy = new HashMap<>();
jy.put("王五",21);
jy.put("赵六",23);
HashMap<String, HashMap<String, Integer>> map = new HashMap<>();
map.put("基础班",jc);
map.put("就业班",jy);
HashMap<String, HashMap<String, HashMap<String, Integer>>> cz = new HashMap<>();
cz.put("传智播客",map);
Set<String> keySet = cz.keySet();
for (String s : keySet) {
System.out.println(s);
HashMap<String, HashMap<String, Integer>> map1 = cz.get(s);
Set<String> keySet1 = map1.keySet();
for (String s1 : keySet1) {
System.out.println(" "+s1);
HashMap<String, Integer> map2 = map1.get(s1);
Set<String> keySet2 = map2.keySet();
for (String s2 : keySet2) {
Integer value = map2.get(s2);
System.out.println(" "+s2+" " +value);
}
System.out.println();
}
}
}
}
运行结果:
传智播客
就业班
王五 21
赵六 23
基础班
李四 22
张三 20
HashMap嵌套ArrayList
public class MapDemo2 {
public static void main(String[] args) {
//基础班
// 张三 20
// 李四 22
//就业班
// 王五 21
// 赵六 23
//上面这组数据我想存起来
//HashMap 嵌套HashMap
HashMap<String, Integer> jc = new HashMap<>();
jc.put("张三", 20);
jc.put("李四", 22);
HashMap<String, Integer> jy = new HashMap<>();
jy.put("王五", 21);
jy.put("赵六", 23);
//再创建一个map集合
HashMap<String, HashMap<String, Integer>> bigMap = new HashMap<>();
bigMap.put("基础班", jc);
bigMap.put("就业班", jy);
//遍历 键找值
Set<String> keys = bigMap.keySet();
for (String k : keys) {
System.out.println(k);
HashMap<String, Integer> value = bigMap.get(k);
Set<String> strings = value.keySet();
for (String s : strings) {
System.out.println("\t" + s + "==" + value.get(s));
}
System.out.println();
}
}
}
**5、斗地主**
//实现斗地主的发牌,洗牌,看牌,
//思路:1.生成一副牌,放在集合(牌盒)
//2.洗牌
//3.三个人斗地主,留三张底牌 发牌
//4.看牌 ,看谁拿了一副好牌
//排序版:创建索引结合,在创建一个map集合,map集合中存贮的是索引和牌盒子;发的是索引,根据索引在map中找相对应的值;
import java.util.*;
public class 斗地主排序版 {
public static void main(String[] args) {
//创建牌盒子
HashMap<Integer, String> map = new HashMap<>();
//创建索引集合
ArrayList<Integer> list = new ArrayList<>();
int index=0;
String[] colors = {"♥", "♠", "♣", "♦"};
String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
for (String num : nums) {
for (String color : colors) {
map.put(index,color.concat(num));
list.add(index);
index++;
}
}
//手动添加大小王
map.put(index, "");
list.add(index);
index++;
map.put(index, "☀");
list.add(index);
//洗牌,洗的是索引
Collections.shuffle(list);
Collections.shuffle(list);
Collections.shuffle(list);
//创建人物集合,因为要排序所以用的是treeset集合
TreeSet<Integer> 周星驰 = new TreeSet<>();
TreeSet<Integer> 刘德华 = new TreeSet<Integer>();
TreeSet<Integer> 周润发 = new TreeSet<Integer>();
TreeSet<Integer> 底牌 = new TreeSet<Integer>();
//发牌
for (int i = 0; i < list.size(); i++) {
if (i >= list.size() - 3) {
底牌.add(list.get(i));
} else if (i % 3 == 0) {
周星驰.add(list.get(i));
} else if (i % 3 == 1) {
刘德华.add(list.get(i));
} else if (i % 3 == 2) {
周润发.add(list.get(i));
}
}
//看牌
lookPoker("周星驰", 周星驰, map);
lookPoker("刘德华", 刘德华, map);
lookPoker("周润发", 周润发, map);
lookPoker("底牌", 底牌, map);
}
private static void lookPoker(String name, TreeSet<Integer> treeSet, HashMap<Integer, String> map) {
System.out.println(name);
for (Integer integer : treeSet) {
System.out.print(map.get(integer)+" ");
//根据发到的索引, 也就是map集合中键在map集合中找每个人相对应的值
}
System.out.println();
}
}