目录
1.双列集合特点
Map遍历三种方式
2.HashMap
3.LinkedHashMap
4.TreeMap
5.源码解析
6.可变参数(形参个数可变)
7.Collections
8.综合练习
1.双列集合特点
①双列集合一次需要存一对数据，分别为键和值
②键不能重复，值可以重复
③键和值是一—对应的，每一个键只能找到自己对应的值
④键+值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”
Map是接口，不能直接创建对象，要创建它实现类的对象。
Map遍历三种方式
Map遍历方式：
1.键找值2.键值对
3.Lambda表达式
练习：用键找值的方式遍历map集合，要求：用装着键的单列集合，使用增强for的形式遍历。
用键找值的方式遍历map集合，要求：用装着键的单列集合，使用迭代器的形式遍历。
用键找值的方式遍历map集合，要求：用装着键的单列集合，使用Lambda的形式遍历。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("bk","pp");
map.put("文总","包包");
map.put("桃桃","福福");
//获取所有的键，将键放到单列集合中
Set<String> keys=map.keySet();
//增强for遍历
for (String key : keys) {
String value=map.get(key);
System.out.println(key+"="+value);
}
//迭代器
Iterator<String> it=keys.iterator();
while (it.hasNext()){
String keys1=it.next();
String value1=map.get(keys1);
System.out.println(keys1+"="+value1);
}
//lambda
keys.forEach(s-> {
String value2=map.get(s);
System.out.println(s+"="+value2);
});
}
}
练习：用键找值的方式遍历map集合，要求：用装着键值对的单列集合，使用增强for的形式遍历。
用键找值的方式遍历map集合，要求：用装着键值对的单列集合，使用迭代器的形式遍历。
用键找值的方式遍历map集合，要求：用装着键值对的单列集合，使用Lambda的形式遍历。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("bk","pp");
map.put("文总","包包");
map.put("桃桃","福福");
//获取键值对，将键放到单列集合中
Set<Map.Entry<String,String>> entries=map.entrySet();
//增强for遍历
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
//迭代器
Iterator<Map.Entry<String, String>> it=entries.iterator();
while (it.hasNext()){
Map.Entry e=it.next();
System.out.println(e.getKey()+"="+e.getValue());
}
//lambda
entries.forEach(new Consumer<Map.Entry<String, String>>() {
@Override
public void accept(Map.Entry<String, String> stringStringEntry) {
System.out.println(stringStringEntry.getKey()+"="+stringStringEntry.getValue());
}
});
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("bk","pp");
map.put("文总","包包");
map.put("桃桃","福福");
//使用Lambda方式遍历
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String keys, String values) {
System.out.println(keys+"="+values);
}
});
//简化Lambda
map.forEach((keys,values)-> System.out.println(keys+"="+values));
}
}2.HashMap
import java.util.HashMap;
public class Test {
public static void main(String[] args){
HashMap<Student,String> hm=new HashMap<>();
Student s1=new Student("zhangsan",18);
Student s2=new Student("lisi",19);
Student s3=new Student("zhangsan",18);
hm.put(s1,"sichuang");
hm.put(s2,"beijing");
hm.put(s3,"sichuang");
//lambda
hm.forEach((student, s)-> System.out.println(student+","+s));
}
}package study.api;
import java.util.Objects;
public class Student{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", 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);
}
}
import java.util.*;
public class Test {
public static void main(String[] args){
String[]arr={"A","B","C","D"};
ArrayList<String> list=new ArrayList<>();
Random r=new Random();
for (int i = 0; i < 80; i++) {
int index=r.nextInt(arr.length);
list.add(arr[index]);
}
HashMap<String,Integer> hm=new HashMap<>();
for (String name : list) {
if (hm.containsKey(name)){
int count=hm.get(name);
count++;
hm.put(name,count);
}
else {
hm.put(name,1);
}
}
//求最大值max
int max=0;
Set<Map.Entry<String, Integer>> entries = hm.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
System.out.println(entry.getKey()+","+entry.getValue());
}
for (Map.Entry<String, Integer> entry : entries) {
int num=entry.getValue();
if(num>max){
max=num;
}
}
System.out.println(max);
//求最多人想去的地点
for (Map.Entry<String, Integer> entry : entries) {
if (entry.getValue()==max){
System.out.println(entry.getKey());
}
}
}
}
3.LinkedHashMap
4.TreeMap
5.源码解析
向上箭头，表示重写了Map里的compute方法。（表示重写过的）
向右箭头，表示compute方法来自于Map。（表示来自哪个类或接口）
f（field），表示HashMap的属性，可能是成员变量，或者常量
6.可变参数(形参个数可变)
格式：属性类型...名字
例：int...args
练习：可变参数的练习
假如需要定义一个方法求和，该方法需要满足以下要求：
计算2个数据的和，计算3个数据的和，计算4个数据的和，计算n个数据的和
7.Collections
集合工具类Collections
8.综合练习
练习1：随机点名器
班级中有n个学生，随机点名
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<>();
Collections.addAll(al,"bk","pp","win","perm","boun","peat","fort");
Collections.shuffle(al);
System.out.println(al.get(0));
//第二种
Random r=new Random();
int index=r.nextInt(al.size());
System.out.println(al.get(index));
}
}练习2：随机点名器
班级里有n个学生，要求：70%的概率随机到男生，30%的概率随机到女生
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class ArrayListTest {
public static void main(String[] args) {
//在一个集合中存入七个1（70%），三个0（30%），打乱随机抽取
// 抽到1就在男生集合中随机抽人，抽到0就在女生集合抽人
ArrayList<Integer> num=new ArrayList<>();
ArrayList<String> boy=new ArrayList<>();
ArrayList<String> girl=new ArrayList<>();
Collections.addAll(num,1,1,1,1,1,1,1,0,0,0);
Collections.addAll(boy,"张三","李四","范闲","bk","pp","win");
Collections.addAll(girl,"杨颖","白鹿","迪丽","欣欣","三三");
//打乱1，0，抽取1，0
Collections.shuffle(num);
int flag=num.get(0);
Random r=new Random();
if(flag==1){
int index=r.nextInt(boy.size());
System.out.println(boy.get(index));
}else {
int index=r.nextInt(girl.size());
System.out.println(girl.get(index));
}
}
}
练习3：随机点名器
班级里有n个学生，要求：被点到的学生不会再被点到，但是如果班级中的所有学生都点完了，需要重新开启第二轮点名。
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListTest {
public static void main(String[] args) {
//将集合中的人抽取出来，存入另外的集合，再删掉被抽取出来的人（当前集合）
ArrayList<String> list1=new ArrayList<>();
Collections.addAll(list1,"bk","pp","win","perm","boun","peat","fort");
//创建一个集合2，将name存进去
ArrayList<String> list2=new ArrayList<>();
//记录集合list1的长度
int count=list1.size();
//点名10轮
for (int j=0;j<10;j++) {
System.out.println("===========第"+(j+1)+"轮点名============");
for (int i = 0; i < count; i++) {
//打乱，抽取
Collections.shuffle(list1);
String name=list1.get(0);
list2.add(name);
System.out.println(name);
//在当前集合删除，抽取出来的name
list1.remove(name);
}
//重开，将list2的数据，复制到list1中，然后清除list2的内容
list1.addAll(list2);
list2.clear();
}
}
}
