1. 目前你所知道的集合容器有哪些？分别有什么特点？
Collection单列集合容器：
List:有序，允许重复元素
ArrayList：有序，允许重复元素，查询快，增删慢；
LinkedList：有序，允许重复元素，查询慢，增删快；
Set：无序，不允许重复元素
HashSet：无序，不允许重复元素，存储和输出顺序不保证
HashSe->LinkedHasSet：无序，不允许重复元素，输入什么顺序，输出什么顺序，并不是存储顺序得到保证；
TreeHashSet：无序，不允许重复元素，默认自然排序，可使用自然排序和比较器排序改变排序规则，并不是存储顺序得到保证；
Map双列集合容器：将键映射到值对象，一个映射不能包含重复的键，一个键只能映射一个值，无序，不允许重复元素。
hashMap：双列，通过键获取值，无序
TreeMap：默认升序，可通过自然排序和比较排序将元素排序
2.定义一个Map接口类型的变量，引用一个实现类，添加键值对，判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作。通过两种方法遍历上题中的map集合
package com.itheima05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @Date 2022/5/17 19:22
* @Author PAMELA
* @Description 定义一个Map接口类型的变量，引用一个实现类，添加键值对，
* 判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，
* 把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作。
* 通过两种方法遍历上题中的map集合
*/
public class Work7_Map_1_2 {
public static void main(String[] args) {
// 定义一个Map接口类型的变量，引用一个实现类
HashMap<String,String> hashMap = new HashMap<String,String>();
//添加键值对
hashMap.put("Stark","Pamela");
hashMap.put("大乔","小乔");
hashMap.put("Lisa","Rose");
//判断集合中是否包含某一key值
System.out.println(hashMap.containsKey("大乔"));//ture
//通过某一key值得到value值
System.out.println(hashMap.get("Stark"));//Pamela
//通过某一key删除键值对
hashMap.remove("大乔");
System.out.println(hashMap); //{Stark=Pamela, Lisa=Rose}
//把另一个map集合添加到此map集合
HashMap<String,String> hashMap1 = new HashMap<String,String>();
hashMap1.putAll(hashMap);
//判断是否为空
System.out.println(hashMap.isEmpty());//false
//清除集合
hashMap.clear();
//返回集合里元素的个数
System.out.println(hashMap.size()); //0
//通过两种方法遍历上题中的map集合
//方式一
Set<String> keySet = hashMap1.keySet();
for (String key : keySet){
String value = hashMap1.get(key);
System.out.println("key:" + " , "+"value:" + value);
}
System.out.println("-------------------------");
//方式二
Set<Map.Entry<String, String>> entrySet = hashMap1.entrySet();
for (Map.Entry<String, String> me : entrySet){
String key = me.getKey();
String value = me.getValue();
System.out.println("key:" + " , "+"value:" + value);
}
}
}
输出结果：
true
Pamela
{Stark=Pamela, Lisa=Rose}
false
0
key: , value:Pamela
key: , value:Rose
key: , value:Pamela
key: , value:Rose
3. 使用Map接口的实现类完成员工工资(姓名–工资)的摸拟：
1)添加几条信息
2)列出所有的员工姓名
3列出所有员工姓名及其工资
4)删除名叫“Tom”的员工信息
5)输出Jack的工资，并将其工资加1000元(通过取值实现)
6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
public class Work7_Map_1_3 {
public static void main(String[] args) {
HashMap<String,Integer> hashMap = new HashMap<String,Integer>();
//1)添加几条信息
hashMap.put("Pamela",5000);
hashMap.put("Jack",4800);
hashMap.put("Tom",6100);
hashMap.put("Lee",800);
hashMap.put("Lara",500);
//2)列出所有的员工姓名
Set<String> keySet = hashMap.keySet();
System.out.println("员工姓名："+keySet);
//3)列出所有员工姓名及其工资
for (String key : keySet){
//5)输出Jack的工资，并将其工资加1000元(通过取值实现)
if (hashMap.get(key).equals("Jack")){
int value = hashMap.get(key) + 1000;
hashMap.put("Jack",value);
}
//6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
if (hashMap.get(key) < 1000){
double value = (hashMap.get(key) + (hashMap.get(key)*0.2));
hashMap.put(key,(int)value);
}
int value = hashMap.get(key);
System.out.println("姓名：" + key + " , " + "工资：" + value);
}
//4)删除名叫“Tom”的员工信息
hashMap.remove("Tome");
}
}
输出结果：
员工姓名：[Lara, Pamela, Tom, Jack, Lee]
姓名：Lara , 工资：600
姓名：Pamela , 工资：5000
姓名：Tom , 工资：6100
姓名：Jack , 工资：4800
姓名：Lee , 工资：960
4. 使用HashMap类实例化一个Map类型的对象m1，键（String类型）和值（int型）分别用于存储员工的姓名和工资，存入数据如下：
张三——800元；李四——1500元；王五——3000元；
1）将张三的工资更改为2600元
2）为所有员工工资加薪100元；
3）遍历集合中所有的员工
4）遍历集合中所有的工资
public class Work7_Map_1_4 {
public static void main(String[] args) {
//使用HashMap类实例化一个Map类型的对象m1,键（String类型）和值（int型）分别用于存储员工的姓名和工资
HashMap<String,Integer> m1 = new HashMap<String,Integer>();
//存入数据如下: 张三——800元；李四——1500元；王五——3000元；
m1.put("张三",800);
m1.put("李四",1500);
m1.put("王五",3000);
//1）将张三的工资更改为2600元
m1.put("张三",2600);
//2）为所有员工工资加薪100元；
Set<String> keySet = m1.keySet();
for (String key : keySet){
int value = m1.get(key) + 100;
//3）遍历集合中所有的员工
System.out.print("员工：" + key);
//4）遍历集合中所有的工资
System.out.println(" ，工资：" + value);
}
}
}
输出结果：
员工：李四 ，工资：1600
员工：张三 ，工资：2700
员工：王五 ，工资：3100
5. 按要求完成如下操作
1 ）封装一个汽车类，包含String name、int speed属性，在测试类中实例化三个对象：c1，c2，c3，分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
2 ）使用Map集合对象m1将这三个汽车类对象保存成key，然后将int型的汽车价钱作为值保存在m1的value中，上述三款汽车分别对应的价钱是10000,500000,2000000
3 ）遍历m1的键，打印name属性
4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
public class Work7_Map_1_5 {
public static void main(String[] args) {
//在测试类中实例化三个对象：c1，c2，c3，
//分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
Car c1 = new Car("奥拓", 100);
Car c2 = new Car("宝马", 200);
Car c3 = new Car("奔驰", 300);
//2 ）使用Map集合对象m1将这三个汽车类对象保存成key
HashMap<Car, Integer> hashMap = new HashMap<>();
//然后将int型的汽车价钱作为值保存在m1的value中,上述三款汽车分别对应的价钱是10000,500000,2000000
hashMap.put(c1, 10000);
hashMap.put(c2, 500000);
hashMap.put(c3, 2000000);
//3 ）遍历m1的键，打印name属性
Set<Car> keySet = hashMap.keySet();
int i = 1;
for (Car car : keySet) {
System.out.print("car" + i++ + "name:" + car.getName() + " ");
}
for (Car car : keySet) {
//4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
if (car.getName().equals("宝马")) {
int price = hashMap.get(car);
System.out.println("\n宝马价格为：" + price);
}
//5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
double price1 = hashMap.get(car) - (hashMap.get(car) * 0.2);
hashMap.put(car, (int) price1);
}
//请打印降价后“宝马”的价格
for (Car car : keySet) {
if (car.getName().equals("宝马")) {
int price = hashMap.get(car);
System.out.println("宝马价格为：" + price);
}
}
}
}
输出结果：
car1name:奔驰 car2name:宝马 car3name:奥拓
宝马价格为：500000
宝马价格为：400000
6.按要求完成如下操作
1 ） 要求集合对象c1中，只能添加字符串形式的单个元素，元素可以重复，在测试类中为c1集合添加字符串“这是一个可以重复的集合”三遍，然后遍历打印结果。
2 ）要求集合对象c2中只能添加整型数值，并且不可重复，按自然顺序排序。要求遍历集合对象，打印添加进1,2,3,4,5五个数字的c2集合
3 ）要求创建一个合适的Map集合对象m1，它的键和值都只能是字符串，并且值可以是null，像map集合中添加三组字符串，其中一个只有键，值是空，遍历这个集合对象的键，并打印键。
4）想办法将m1中所有值为null都替换成一个字符串”这里是空值”
5）遍历m1的所有值。
public class Work7_Map_1_6 {
public static void main(String[] args) {
//1 ） 要求集合对象c1中，只能添加字符串形式的单个元素，元素可以重复，
ArrayList<String> c1 = new ArrayList<>();
//在测试类中为c1集合添加字符串“这是一个可以重复的集合”三遍,然后遍历打印结果。
c1.add("这是一个可以重复的集合");
c1.add("这是一个可以重复的集合");
c1.add("这是一个可以重复的集合");
for (String s : c1) {
System.out.print(s + " "); //这是一个可以重复的集合 这是一个可以重复的集合 这是一个可以重复的集合
}
System.out.println();
//2 ）要求集合对象c2中只能添加整型数值，并且不可重复，按自然顺序排序。
TreeSet<Integer> c2 = new TreeSet<>();
//要求遍历集合对象，打印添加进1,2,3,4,5五个数字的c2集合
c2.add(1);
c2.add(5);
c2.add(3);
c2.add(4);
c2.add(2);
for (Integer i : c2) {
System.out.print( i + " "); //1 2 3 4 5
}
System.out.println();
//3 ）要求创建一个合适的Map集合对象m1，它的键和值都只能是字符串，
Map<String, String> m1 = new HashMap<>();
// * 并且值可以是null，像map集合中添加三组字符串，其中一个只有键，值是空，
m1.put("001", "Pamela");
m1.put("002", "Lara");
m1.put("003", null);
// * 遍历这个集合对象的键，并打印键。
Set<String> keySet = m1.keySet();
for (String key : keySet) {
System.out.print("key:" + key + " "); //key:001 key:002 key:003
//4）想办法将m1中所有值为null都替换成一个字符串”这里是空值”
if (m1.get(key) == null){
m1.put(key,"这里是空值");
}
}
System.out.println();
//5）遍历m1的所有值。
for (String key : keySet) {
String value = m1.get(key);
System.out.println("key:" + key + " , " + "value:" + value);
}
}
}
输出结果：
1 2 3 4 5
key:001 key:002 key:003
key:001 , value:Pamela
key:002 , value:Lara
key:003 , value:这里是空值
7.【1】将以下车站对应关系的数据存储到map集合中，
key：表示站编号，value：表示站名，
并遍历打印(可以不按顺序打印)：
站编号和站名对应关系如下：
1 朱辛庄
2 育知路
3 平西府
4 回龙观东大街
5 霍营
6 育新
7 西小口
8 永泰庄
9 林萃桥
10 森林公园南门
11 奥林匹克公园
12 奥体中心
13 北土城
14 安华桥
15 安德里北街
16 鼓楼大街
17 什刹海
18 南锣鼓巷
19 中国美术馆
【2】计算地铁票价规则：
总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶；
需要对键盘录入的上车站
和到达站进行判断，如果没有该站，
提示重新输入，直到站名存在为止
每站需要2分钟
示范如下：
请输入上车站：
流沙河
您输入的上车站：流沙河站不存在，请重新输入上车站：
骑龙
您输入的上车站：骑龙站不存在，请重新输入上车站：
朱辛庄
您以确定在朱辛庄上站！
请输入到达站：
沙河
您输入的到达站：沙河站不存在，请重新输入到达站：
西二旗
您输入的到达站：西二旗站不存在，请重新输入到达站：
西小口
您以确定在朱辛庄下站！
从朱辛庄到西小口共经过6站收费6元，大约需要12分钟
public class Work7_Set_1_7 {
public static void main(String[] args) {
//创建Map集合
Map<Integer, String> map = new HashMap<>();
//key：表示站编号，value：表示站名
map.put(1, "朱辛庄");
map.put(2, "育知路");
map.put(3, "平西府");
map.put(4, "回龙观东大街");
map.put(5, "霍营");
map.put(6, "育新");
map.put(7, "西小口");
map.put(8, "永泰庄");
map.put(9, "林萃桥");
map.put(10, "森林公园南门");
map.put(11, "奥林匹克公园");
map.put(12, "奥体中心");
map.put(13, "北土城");
map.put(14, "安华桥");
map.put(15, "安德里北街");
map.put(16, "鼓楼大街");
map.put(17, "什刹海");
map.put(18, "南锣鼓巷");
map.put(19, "中国美术馆");
//并遍历打印(可以不按顺序打印)：
Set<Integer> keySet = map.keySet();
for (Integer key : keySet) {
String value = map.get(key);
System.out.println(key + " : " + value);
}
//【2】计算地铁票价规则：
Scanner scanner = new Scanner(System.in);
String upStation = "";
String getStation = "";
int upNum = 0;
int getNum = 0;
System.out.println("请输入上车站:");
Set<Integer> keySet1 = map.keySet();
boolean flag = true;
while (flag) {
try {
//输入上车站
upStation = scanner.next();
//map中不包含此站抛异常
if (!map.containsValue(upStation)) {
throw new Exception(upStation + "站不存在，请重新输入上车站：");
} else {
//遍历集合找到对应站
for (Integer key : keySet) {
String station = map.get(key);
//相匹配的站
if (station.equals(upStation)) {
//将站编号保留 到站同理
upNum = key;
}
}
System.out.println("您以确定在" + upStation + "上站！");
}
System.out.println("请输入您的到达站：");
while (true) {
getStation = scanner.next();
try {
if (!map.containsValue(getStation)) {
throw new Exception(getStation + "站不存在，请重新输入到达站：");
} else {
for (Integer key : keySet) {
String station = map.get(key);
if (station.equals(getStation)) {
getNum = key;
}
}
System.out.println("您已确定在" + getStation + "下站！");
flag = false;
break;
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
//【2】计算地铁票价规则：
int n = (getNum - upNum);
int money = 0;
//3站内（包含3站）收费3元，
if (n <= 3) {
money = 3;
}
if (n > 3 && n <= 5) { //3站以上但不超过5站（包含5站）的收费4元
money = 4;
}
if (n > 5) { //5站以上的，在4元的基础上，每多1站增加2元
money = 4 + (n - 5) * 2;
if (money >= 10) {//10元封顶
money = 10;
}
}
System.out.println("从" + upStation + "到" + getStation +
"共经过" + n + "站" + "收费" + money +
"元，大约需要" + n * 2 + "分钟");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
输出结果：
请输入上车站:
朱辛庄
您以确定在朱辛庄上站！
请输入您的到达站：
南锣鼓巷
您已确定在南锣鼓巷下站！
从朱辛庄到南锣鼓巷共经过17站收费10元，大约需要34分钟