Java300集-第九章容器练习题及答案
一、 选择题
1. 以下选项中关于Java集合的说法错误的是( )。(选择二项)
A.List接口和Set接口是Collections接口有两个子接口
B.List接口中存放的元素具有有序，不唯一的特点
C.Set接口中存放的元素具有无序，不唯一的特点
D.Map接口存放的是映射信息，每个元素都是一个键值对
A C.
2. 如下Java代码，输出的运行结果是( )。(选择一项)
public class Test {
public static void main(String[ ] args) {
List<String> list=new ArrayList<String>();
list.add("str1");
list.add(2, "str2");
String s=list.get(1);
System.out.println(s);
}
}
A.运行时出现异常
B.正确运行，输出str1
C.正确运行，输出str2
D.编译时出现异常
A.
3. 在Java中,下列集合类型可以存储无序、不重复的数据的是( )。(选择一项)
A.ArrayList
B.LinkedList
C.TreeSet
D.HashSet
D.
4. 以下代码的执行结果是( )。(选择一项)
Set<String> s=new HashSet<String>();
s.add("abc");
s.add("abc");
s.add("abcd");
s.add("ABC");
System.out.println(s.size());
A.1
B.2
C.3
D.4
C.HashSet是一个没有重复元素的集合
5. 给定如下Java代码，编译运行的结果是( )。(选择一项)
public class Test {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
String s = "code";
map.put(s, "1");
map.put(s, "2");
System.out.println(map.size());
}
}
A.编译时发生错误
B.运行时引发异常
C.正确运行，输出：1
D.正确运行，输出：2
C.HashMap如果键值发生重复，新的值会替换旧的值
二、 简答题
1. 集合和数组的比较。
存储类型方面，集合存储引用数据类型（或者基本数据类型的包装类），数组既可以存储基本数据类型也可以存储引用数据类型。
容量方面，集合可以动态的改变容量，可以知道实际存在元素多少，而数组容量一旦确定无法改变，无法知道实际的元素多少。
底层方面，集合采用了顺序表，树，散列表多种方式。而数组仅仅采用了顺序表的方式。
数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。
2. 简述List、Set、Collection、Map的区别和联系。
List和Set是Collection接口的两个子接口
Collection接口存储一组无序、不唯一的对象
List接口存储有序、不唯一的对象
Set接口存储无序、唯一的对象
Map接口存储键值对对象，其中key唯一，最多可以有一个null值; value不唯一，可以有多个null值
3. ArrayList和LinkedList的区别和联系。它们的底层分别是用什么实现的?
ArrayList的查询效率不高，删改程度低，线程不安全；LinkList的查询效率高，删改程度高，线程不安全。 ArrayList和LinkedList都是List接口的实现类。ArrayList的底层是由数组来实现，LinkList是由双链表进行实现。
4. HashSet采用了哈希表作为存储结构，请说明哈希表的特点和实现原理。
提示：结合Object类的hashCode()和equals()说明其原理。
5. 使用泛型有什么好处?
使用泛型遍历集合中，不需要进行数据类型的强制转换。提高了代码的可读性和安全性。
三、 编码题
1. 使用List和Map存放多个图书信息，遍历并输出。其中商品属性：编号，名称，单价，出版社;使用商品编号作为Map中的key。
Books类：
public class Books {
private int id; //编号
private String name; //名称
private double price; //价格
private String press; //出版社
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
public String getPress() {
return press;
}
public void setPress(String press) {
this.press = press;
}
public Books(int id, String name, double price, String press) {
this.id = id;
this.name = name;
this.price = price;
this.press = press;
}
public Books() {
}
@Override
public String toString() {
return "Books{" +
"id=" + id +
", name=《" + name +
"》, price=" + price +
", press='" + press + '\'' +
'}';
}
}
BooksTest类
import java.util.*;
public class BooksTest {
public static void main(String[] args) {
Books b1 = new Books(101,"Java核心技术",96.9,"机械工业出版社");
Books b2 = new Books(102,"Java从入门到精通",63,"清华大学出版社");
Books b3 = new Books(103,"Java编程思想",70.2,"机械工业出版社");
System.out.println("==========使用List存放==========");
List<Books> list = new ArrayList<>();
list.add(b1);
list.add(b2);
list.add(b3);
for (Books books:list) {
System.out.println(books);
}
System.out.println("==========使用Map存放==========");
Map<Integer,Books> map = new HashMap<>();
map.put(b1.getId(), b1);
map.put(b2.getId(), b2);
map.put(b3.getId(), b3);
Set<Integer> keys = map.keySet();
for (Map.Entry<Integer,Books> booksMap:map.entrySet()) {
System.out.println(booksMap.getKey()+"---"+booksMap.getValue());
}
}
}
运行结果：
2. 使用HashSet和TreeSet存储多个商品信息，遍历并输出;其中商品属性：编号，名称，单价，出版社;要求向其中添加多个相同的商品，验证集合中元素的唯一性。
提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )。
向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则。
Books类：
import java.awt.print.Book;
import java.util.Objects;
public class Books implements Comparable<Books>{
private int id;
private String name;
private double price;
private String press;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
public String getPress() {
return press;
}
public void setPress(String press) {
this.press = press;
}
public Books(int id, String name, double price, String press) {
this.id = id;
this.name = name;
this.price = price;
this.press = press;
}
public Books() {
}
@Override
public String toString() {
return "Books{" +
"id=" + id +
", name=《" + name +
"》, price=" + price +
", press='" + press + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Books books = (Books) o;
return id == books.id && Double.compare(books.price, price) == 0 && Objects.equals(name, books.name) && Objects.equals(press, books.press);
}
@Override
public int hashCode() {
return Objects.hash(id, name, price, press);
}
@Override
public int compareTo(Books o) {
if(this.id>o.id){
return 1;
}
if(this.id == o.id){
return this.name.compareTo(o.getName());
}
return -1;
}
}
HashSetTest类：
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class HashSetTest {
public static void main(String[] args) {
Books b1 = new Books(101,"Java核心技术",96.9,"机械工业出版社");
Books b2 = new Books(102,"Java从入门到精通",63,"清华大学出版社");
Books b3 = new Books(103,"Java编程思想",70.2,"机械工业出版社");
Books b4 = new Books(101,"Java核心技术",96.9,"机械工业出版社");
Books b5 = new Books(102,"C++从入门到精通",63,"清华大学出版社");
System.out.println("==========HashSet存储=============");
Set<Books> books1 = new HashSet<>();
books1.add(b1);
books1.add(b2);
books1.add(b3);
books1.add(b4);
books1.add(b5);
for (Books set1:books1) {
System.out.println(set1);
}
System.out.println("==========TreeSet存储=============");
Set<Books> books2 = new TreeSet<>();
books2.add(b1);
books2.add(b2);
books2.add(b3);
books2.add(b4);
books2.add(b5);
for (Books set2:books2) {
System.out.println(set2);
}
}
}
运行结果：
3. 实现List和Map数据的转换。具体要求如下：
功能1：定义方法public void listToMap( ){ }将List中Student元素封装到Map中
1) 使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息并加入List;
2) 遍历List，输出每个Student信息;
3) 将List中数据放入Map，使用Student的id属性作为key，使用Student对象信息作为value;
4) 遍历Map，输出每个Entry的key和value。
功能2：定义方法public void mapToList( ){ }将Map中Student映射信息封装到List
1) 创建实体类StudentEntry，可以存储Map中每个Entry的信息;
2) 使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息，并使用Student的id属性作为key，存入Map;
3) 创建List对象，每个元素类型是StudentEntry;
4) 将Map中每个Entry信息放入List对象。
功能3：说明Comparable接口的作用，并通过分数来对学生进行排序。
Student类：
package com.exam9.test3;
import java.util.Objects;
public class Student {
private int id;
private String name;
private int age;
private String sex;
private double score;
public Student(int id, String name, int age, String sex, double score) {
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id && age == student.age && Double.compare(student.score, score) == 0 && Objects.equals(name, student.name) && Objects.equals(sex, student.sex);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age, sex, score);
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", score=" + score +
'}';
}
}
Util类：
import java.util.*;
public class Util {
private Util() {
}
public static void listToMap(){
System.out.println("List转Map：");
List<Student> list = new ArrayList<>();
list.add(new Student(101,"张三",18,"女",90));
list.add(new Student(102,"张四",17,"男",100));
list.add(new Student(103,"张五",19,"男",80));
list.add(new Student(104,"张六",20,"女",90));
Map<Integer,Student> map = new HashMap<>();
System.out.println("list集合输出：");
for (Student stu:list) {
System.out.println(stu);
map.put(stu.getId(), stu);
}
System.out.println("Map集合输出：");
for (Map.Entry<Integer,Student> stu: map.entrySet()) {
System.out.println(stu.getKey()+" "+stu.getValue());
}
}
public static void mapToList(){
System.out.println("Map转List：");
Map<Integer,Student> map = new HashMap<>();
Student s1 = new Student(101,"张三",18,"女",90);
Student s2 = new Student(102,"张四",17,"男",100);
Student s3 = new Student(103,"张五",19,"男",80);
Student s4 = new Student(104,"张六",20,"女",90);
map.put(s1.getId(), s1);
map.put(s2.getId(), s2);
map.put(s3.getId(), s3);
map.put(s4.getId(), s4);
List<Student> list = new ArrayList<>();
System.out.println("Map集合输出：");
for (Map.Entry<Integer,Student> stu: map.entrySet()) {
System.out.println(stu.getKey()+" "+stu.getValue());
list.add(stu.getValue());
}
System.out.println("List集合输出：");
for (Student stu:list) {
System.out.println(stu);
}
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
if (o1.getScore() > o2.getScore()){
return 1;
}
if (o1.getScore() == o2.getScore()){
return Integer.valueOf(o1.getId()).compareTo(o2.getId());
}
return -1;
}
});
System.out.println("排序后输出：");
for (Student stu:list) {
System.out.println(stu);
}
}
}
Test类：
public class Test {
public static void main(String[] args) {
Util.listToMap();
Util.mapToList();
}
}
运行结果：
