Java笔记028-集合章节练习
编程题
按要求实现：
封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题
只提供一个带参构造器，实例化对象时，只初始化标题，并且实例化两个对象：
新闻一：新冠确诊病例超过千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
新闻二：男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
将新闻对象添加到ArrayList集合中，并且进行倒叙遍历
在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“...”
在控制台打印遍历出经过处理的新闻标题
package com14.exercise;
import java.util.ArrayList;
/**
* @author 甲柒
* @version 1.0
* @title exercise01
* @package com14.exercise
* @time 2023/2/27 21:07
*/
@SuppressWarnings({"all"})
public class exercise01 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(new News("新冠确诊病例超过千万，数百万印度教信徒赴恒河“圣浴”引民众担忧"));
arrayList.add(new News("男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生"));
int size = arrayList.size();
for (int i = size - 1; i >= 0; i--) {
// System.out.println(arrayList.get(i));
News news = (News) arrayList.get(i);
System.out.println(processTitle(news.getTitle()));
}
}
//专门写一个方法，处理显示新闻标题 process处理
public static String processTitle(String title) {
if (title == null) {
return "";
}
if (title.length() > 15) {
return title.substring(0, 15) + "...";//[0, 15)
} else {
return title;
}
}
}
/**
* 按要求实现：
* 1. 封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题
* 2. 只提供一个带参构造器，实例化对象时，只初始化标题，并且实例化两个对象：
* 新闻一：新冠确诊病例超过千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
* 新闻二：男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
* 3. 将新闻对象添加到ArrayList集合中，并且进行倒叙遍历
* 4. 在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加“...”
* 5. 在控制台打印遍历出经过处理的新闻标题
*/
class News {
private String title;
private String content;
public News(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "News{" +
"title='" + title + '\'' +
'}';
}
}编程题
使用ArrayList完成对 对象Car{name, price}的各种操作
add：添加单个元素
remove：删除指定元素
contains：查找元素是否存在
size：获取元素个数
isEmpty：判断是否为null
clear：清空
addAll：添加多个元素
containsAll：查找多个元素是否都存在
removeAll：删除多个元素
使用增强for和迭代器来遍历所有的car，需要重写Car的toString方法
package com14.exercise;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author 甲柒
* @version 1.0
* @title Exercise02
* @package com14.exercise
* @time 2023/2/27 21:28
*/
@SuppressWarnings({"all"})
public class Exercise02 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
Car car = new Car("宝马", 400000);
Car car1 = new Car("宾利", 5000000);
// 使用ArrayList完成对 对象Car{name, price}的各种操作
// 1. add：添加单个元素
list.add(car);
list.add(car1);
System.out.println(list);
// 2. remove：删除指定元素
list.remove(car);
System.out.println(list);
// 3. contains：查找元素是否存在
System.out.println(list.contains(car));//false
// 4. size：获取元素个数
System.out.println(list.size());//1
// 5. isEmpty：判断是否为null
System.out.println(list.isEmpty());//false
// 6. clear：清空
// list.clear();
System.out.println(list);//null
// 7. addAll：添加多个元素
list.addAll(list);
System.out.println(list);//2个宾利
// 8. containsAll：查找多个元素是否都存在
System.out.println(list.containsAll(list));//true
// 9. removeAll：删除多个元素
// list.removeAll(list);//相当于清空
System.out.println(list);
// 使用增强for和迭代器来遍历所有的car，需要重写Car的toString方法
for (Object o : list) {
System.out.println(o);
}
//迭代器
System.out.println("+++++++迭代器++++++");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
/**
* 使用ArrayList完成对 对象Car{name, price}的各种操作
* 1. add：添加单个元素
* 2. remove：删除指定元素
* 3. contains：查找元素是否存在
* 4. size：获取元素个数
* 5. isEmpty：判断是否为null
* 6. clear：清空
* 7. addAll：添加多个元素
* 8. containsAll：查找多个元素是否都存在
* 9. removeAll：删除多个元素
* 使用增强for和迭代器来遍历所有的car，需要重写Car的toString方法
*/
class Car {
private String name;
private double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}编程题
按要求完成下列任务
使用HashMap类实例化一个Map类型的对象m，键(String)和值(int)分别用于存储员工的姓名和工资，存入数据如下：jack——650￥；tom——1200￥；smith——2900￥
将jack的工资更改为2600￥
为所有员工工资加薪100￥
遍历集合中所有的员工
遍历集合中所有的工资
package com14.exercise;
import java.util.*;
/**
* @author 甲柒
* @version 1.0
* @title Exercise03
* @package com14.exercise
* @time 2023/2/27 21:57
*/
@SuppressWarnings({"all"})
public class Exercise03 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("jack", 650);//int->Integer
map.put("tom", 1200);//int->Integer
map.put("smith", 2900);//int->Integer
System.out.println(map);
map.replace("jack", 2600);//替换
System.out.println(map);
// 为所有员工工资加薪100￥
Set keySet = map.keySet();
for (Object o : keySet) {
//更新
map.put(o, (Integer) map.get(o) + 100);
}
System.out.println(map);
//遍历集合中所有的员工
//entrySet
System.out.println("====遍历集合中所有的员工====");
Set entrySet = map.entrySet();
//迭代器
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry next = (Map.Entry) iterator.next();
System.out.println(next.getKey());
}
//遍历集合中所有的工资
System.out.println("=====遍历所有的工资=====");
Collection values = map.values();
for (Object o : values) {
System.out.println("工资=" + o);
}
}
}
/**
* 按要求完成下列任务
* 1. 使用HashMap类实例化一个Map类型的对象m，
* 键(String)和值(int)分别用于存储员工的姓名和工资，
* 存入数据如下：jack——650￥；tom——1200￥；smith——2900￥
* 2. 将jack的工资更改为2600￥
* 3. 为所有员工工资加薪100￥
* 4. 遍历集合中所有的员工
* 5. 遍历集合中所有的工资
*/简答题
试分析HashSet和TreeSet分别如何实现去重
HashSet的去重机制：hashCode() + equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals比较[遍历比较]，如果比较后，不相同，就加入，否则就不加入。
TreeSet的去重机制：如果你传入了一个数据Comparator匿名对象，就使用实现的compare去重，如果方法返回0，就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Comparable接口的compareTo去重。
package com14.exercise;
import java.util.TreeSet;
/**
* @author 甲柒
* @version 1.0
* @title Exercise04
* @package com14.exercise
* @time 2023/2/28 19:11
*/
public class Exercise04 {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add("甲柒");
treeSet.add("tom");
treeSet.add("king");
treeSet.add("甲柒");//加入不了
System.out.println(treeSet);
}
}代码分析题
下面代码会不会抛出异常，并从源码层面说明原因。[考察 读源码+接口编程+动态绑定]
package com14.exercise;
import java.util.TreeSet;
/**
* @author 甲柒
* @version 1.0
* @title Exercise05
* @package com14.exercise
* @time 2023/2/28 19:36
*/
@SuppressWarnings({"all"})
public class Exercise05 {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
//分析源码
//add方法，因为TreeSet()构造器没有传入Comparator接口的匿名内部类
//所以把底层Comparable<? super K> K = (Comparable<? super K>) key;
//即 把Person转成Comparable
treeSet.add(new Person());//ClassCastException
}
}
class Person {
}
//解决方法
//class Person implements Comparable {
//
// @Override
// public int compareTo(Object o) {
// return 0;
// }
//}
下面的代码输出什么
已知：Person类按照id和name重写了hashCode和equals方法，问下面代码输出什么
package com14.exercise;
import java.util.HashSet;
import java.util.Objects;
/**
* @author 甲柒
* @version 1.0
* @title Exercise06
* @package com14.exercise
* @time 2023/2/28 19:50
*/
@SuppressWarnings({"all"})
public class Exercise06 {
public static void main(String[] args) {
HashSet set = new HashSet();//ok
Person06 p1 = new Person06(1001, "AA");//ok
Person06 p2 = new Person06(1002, "BB");//ok
set.add(p1);//ok
set.add(p2);//ok
p1.name = "CC";
set.remove(p1);
System.out.println(set);
set.add(new Person06(1001, "CC"));
System.out.println(set);
set.add(new Person06(1001, "AA"));
System.out.println(set);
}
}
class Person06 {
public int id;
public String name;
public Person06(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person06 person06 = (Person06) o;
return id == person06.id && Objects.equals(name, person06.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public String toString() {
return "Person06{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
试写出Vector和ArrayList的比较
底层结构 |
版本 |
线程安全(同步)效率 |
扩容倍数 |
|
ArrayList |
可变数组 |
JDK1.2 |
不安全，效率高 |
如果使用有参构造器按照1.5倍扩容 使用无参构造器 第一次扩容10 从第二次开始扩容按照1.5倍 |
Vector |
可变数组Object[] |
JDK1.0 |
安全，效率不高 |
如果是无参，默认10，满后按照2倍扩容 如果是指定大小创建Vector，则每次按照2倍扩容 |