day18-20作业-韩明琰
容器作业
一、 填空题
- Java集合框架提供了一套性能优良、使用方便的接口和类，包括Collection和Map两大类，它们都位于 ____java.util__ 包中
- 队列和堆栈有些相似，不同之处在于 _队列可以先进先出也可以先进后后出,堆栈只能先进后出__。
- ___链表____ 结构是一种由多个节点组成的线性数据结构，并且每个节点包含有数据以及指向下一个节点的引用。
- ___LinkedList__是一种集合类，它 采用链表作为的存储结构，便于删除和添加元素，但是按照索引查询元素效率低下。
- ___TreeSet___ 是一种Collection类型的集合类，其中元素唯一，并采用二叉树作为存储结构，元素按照自然顺序排列。
- 如果希望将自定义类Student的多个对象放入集合TreeSet，实现所有元素按照某个属性的自然顺序排列，则需要Student类实现___Compara____接口。
- 在Java中 ____Map___ 集合的访问时间接近稳定，它是一种键值对映射的数据结构。这个数据结构是通过数组来实现的。
- 迭代器Iterator为集合而生，专门实现集合遍历，该接口有三个方法，分别是hasNext() 、____next()___、remove()。
二、 选择题
|
1. |
以下选项中关于Java集合的说法错误的是（ AC ）。（选择二项） |
|
|
|
|
|
|
|
A. |
List接口和Set接口是Collections接口有两个子接口 |
|
|
B. |
List接口中存放的元素具有有序，不唯一的特点 |
|
|
C. |
Set接口中存放的元素具有无序，不唯一的特点 |
|
|
D. |
Map接口存放的是映射信息，每个元素都是一个键值对 |
|
2. |
如下Java代码，输出的运行结果是（ A ）。（选择一项） |
|
|
|
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. |
编译时出现异常 |
|
3. |
以下Java代码的作用是首先将一个数组的内容存入集合，然后判断集合中是否有指定的元素存在，其中共有（C ）处错误。（选择一项） |
|
|
|
import java.util.List; public class Test { public int getIndexofArray(float[] f){ int rtn=-1; float objf=3.4;//1处 3.4f List list=null; //2处 for(int i=0;i<f.size( );i++){ list.add(f[i]); } for(int i=0;i<list.size( );i++){ float tmp=(float)list.get(i); if(objf==tmp){ rtn=i; } } return rtn; } } |
|
|
|
|
|
|
|
A |
0 |
|
|
B. |
1 |
|
|
C. |
2 |
|
|
D. |
3 |
|
4. |
分析如下Java 代码，编译运行后将输出（ D ）。（选择一项） |
|
|
|
public class Test { public Test() { } static void print(List<Integer> al) { al.add(2); al = new ArrayList<Integer>(); al.add(3); al.add(4); } public static void main(String[] args) { List<Integer> al = new ArrayList<Integer>(); al.add(1); print(al); System.out.println(al.get(1)); } } |
|
|
|
|
|
|
|
A |
1 |
|
|
B. |
2 |
|
|
C. |
3 |
|
|
D. |
4 |
|
5. |
在Java中,下列集合类型可以存储无序、不重复的数据的是（ D ）。（选择一项） |
|
|
|
|
|
|
|
A |
ArrayList |
|
|
B. |
LinkedList |
|
|
C. |
TreeSet |
|
|
D. |
HashSet |
|
6. |
以下代码的执行结果是（ C ）。（选择一项） |
|
|
|
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 |
|
7. |
给定如下Java代码，编译运行的结果是（ C ）。（选择一项） |
|
|
|
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 |
|
8. |
下面集合类中属于非线程安全，且结构采用了哈希表的是（ C）。（选择一项） |
||
|
|
|
|
|
|
|
A. |
Vector |
|
|
|
B. |
ArrayList |
|
|
|
C. |
HashMap |
|
|
|
D. |
Hashtable |
|
|
9. |
在Java中，LinkedList类与ArrayList类同属于集合框架类，下列（CD ）选项中是LinkedList类有而ArrayList类没有的方法。（选择两项） |
||
|
|
|
|
|
|
|
A |
add(Object o) |
|
|
|
B. |
add(int index,Object o) |
|
|
|
C. |
getFirst() |
|
|
|
D. |
removeLast() |
|
三、 判断题
- 数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型。( T )
- Java集合中的Set接口和List接口都是从Collection接口派生出来的。（ T）
- Collection 接口存储一组不唯一，有序的对象，它有两个子接口：List和Set。（ F ）
- Collection是Java集合顶级接口，其中的元素无序，唯一。Java平台不提供这个接口任何直接的实现。（ F ）
- List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引来访问List中的无素，这类似于Java的数组。（ T ）
- HashSet采用哈希表存储结构，特点是查询速度快，但是其中元素无序排列。（ T ）
- LinkedHashMap是一种有序的HashMap，查询速度快，便于添加删除操作。（ F ）
- 基本数据类型的值可以被直接存储在Vector对象中。（ F ）
- Dictionary建立了关键字和值的映射，只要提供一个关键字，Dictionary就会返回一个相应的值。（ T ）
- 泛型是JavaSE1.7的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Java语言引入泛型的好处是安全简单。（ F）
- Collection是专门操作集合的工具类，提供一系列静态方法实现对各种集合操作。（ F）
- Iterator接口可以遍历任何Collection接口的实现类，可以从一个Collection中使用iterator( )方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。（T）
四、 简答题 (首先熟练掌握笔记上 与集合相关的面试简答题)
- 熟练掌握Collection集合和Map集合的体系图
- 简述List、Set、Collection、Map的特点和区别及什么时候使用该集合。
List(存取有序,有索引,可以重复)
* ArrayList
* 底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
* LinkedList
* 底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢
* 如果查找和修改多,用ArrayList
* 如果增和删多,用LinkedList
* 如果都多,用ArrayList
Set(存取无序,无索引,不可以重复)
* HashSet
* 底层是哈希算法实现
* LinkedHashSet
* 底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样
* TreeSet
* 底层是二叉树算法实现
* 一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用 HashSet,HashSet的效率比较高
Map
* HashMap
* 底层是哈希算法,针对键
* LinkedHashMap
* 底层是链表,针对键
* TreeMap
* 底层是二叉树算法,针对键
* 开发中用HashMap比较多
- Vector和ArrayList的区别和联系。
Vector
底层是数组实现的,线程安全的,无论增删改查都慢
ArrayList
底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
- 请你简述HashMap和Hashtable的区别？
- Hashtable是JDK1.0版本出现的,是线程安全的,效率低; HashMap是JDK1.2版本出现的,是线程不安全的,效率高
- Hashtable不可以存储null键和null值; HashMap可以存储null键和null值(目的是为了让后续代码可以继续执行)
五、 编码题 (首先熟练掌握笔记上 与集合相关的需求小案例)
- 使用List和Map存放多个图书信息，遍历并输出。其中商品属性：编号，名称，单价，出版社；使用商品编号作为Map中的key。
package com.zuikc.homework;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Task1 {
public static void main(String[] args) {
/*1. 使用List和Map存放多个图书信息，遍历并输出。其中商品属性：
编号，名称，单价，出版社；使用商品编号作为Map中的key。*/
HashMap<Integer, Book> hm = new HashMap<>();
hm.put(1, new Book("javase",1000,"zuikc"));
hm.put(2, new Book("javaweb",2000,"zuikc"));
hm.put(3, new Book("javaee",3000,"zuikc"));
System.out.println(hm);
}
}
public class Book {
// 名称，单价，出版社
private String name;
private int price;
private String press;
public Book() {
super();
}
public Book(String name, int price, String press) {
super();
this.name = name;
this.price = price;
this.press = press;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getPress() {
return press;
}
@Override
public String toString() {
return "Book [name=" + name + ", price=" + price + ", press=" + press + "]";
}
public void setPress(String press) {
this.press = press;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((press == null) ? 0 : press.hashCode());
result = prime * result + price;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Book other = (Book) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (press == null) {
if (other.press != null)
return false;
} else if (!press.equals(other.press))
return false;
if (price != other.price)
return false;
return true;
}
}
- 使用HashSet和TreeSet存储多个商品信息，遍历并输出；其中商品属性：编号，名称，单价，出版社；要求向其中添加多个相同的商品，验证集合中元素的唯一性。
提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )
向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则
package com.zuikc.homework;
import java.util.HashSet;
import java.util.TreeSet;
public class Task2 {
public static void main(String[] args) {
/*2.使用HashSet和TreeSet存储多个商品信息，遍历并输出；其中商品属性：编号，名称，单价，出版社；
* 要求向其中添加多个相同的商品，验证集合中元素的唯一性。
提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )
向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则
*/
// demo1();
TreeSet<Goods> ts = new TreeSet<>();
ts.add(new Goods(1, "卫龙", 10, "食品厂"));
ts.add(new Goods(1, "卫龙", 10, "食品厂"));
ts.add(new Goods(2, "康师傅", 20, "面条厂"));
ts.add(new Goods(3, "六神", 16, "化工厂"));
ts.add(new Goods(2, "康师傅", 20, "面条厂"));
for(Goods Goods : ts ) {
System.out.println(Goods);
}
}
private static void demo1() {
HashSet<Goods> hs = new HashSet<>();
hs.add(new Goods(1, "卫龙", 10, "食品厂"));
hs.add(new Goods(1, "卫龙", 10, "食品厂"));
hs.add(new Goods(2, "康师傅", 20, "面条厂"));
hs.add(new Goods(3, "六神", 16, "化工厂"));
hs.add(new Goods(2, "康师傅", 20, "面条厂"));
for(Goods Goods : hs ) {
System.out.println(Goods);
}
}
}
package com.zuikc.homework;
public class Goods implements Comparable<Goods>{
private int id;
private String name;
private int price;
private String press;
public Goods() {
super();
}
public Goods(int id, String name, int price, String press) {
super();
this.id = id;
this.name = name;
this.price = price;
this.press = 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 int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getPress() {
return press;
}
public void setPress(String press) {
this.press = press;
}
@Override
public String toString() {
return "Goods [id=" + id + ", name=" + name + ", price=" + price + ", press=" + press + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((press == null) ? 0 : press.hashCode());
result = prime * result + price;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Goods other = (Goods) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (press == null) {
if (other.press != null)
return false;
} else if (!press.equals(other.press))
return false;
if (price != other.price)
return false;
return true;
}
@Override
public int compareTo(Goods g) {
return this.id - g.id;
}
}
- 实现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对象
package com.zuikc.homework;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.xml.crypto.dsig.spec.HMACParameterSpec;
public class Task3 {
public static void main(String[] args) {
ListToMap();
}
public static void ListToMap() {
List<Student> list = new ArrayList<>();
list.add(new Student(1, "张三", 23, "男"));
list.add(new Student(2, "李四", 24, "女"));
list.add(new Student(3, "王五", 25, "男"));
list.add(new Student(4, "赵六", 26, "女"));
for (Student Student : list) {
System.out.println(Student);
}
Map<Integer, Student> map = new HashMap<>();
map.put(1,new Student(1, "张三", 23, "男"));
map.put(2,new Student(2, "李四", 24, "女"));
map.put(3,new Student(3, "王五", 25, "男"));
map.put(4,new Student(4, "赵六", 26, "女"));
for (Integer key : map.keySet()) {
System.out.println(key + "=" + map.get(key));
}
}
}
package com.zuikc.homework;
public class Student {
private int id;
private String name;
private int age;
private String sex;
public Student() {
super();
}
public Student(int id, String name, int age, String sex) {
super();
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((sex == null) ? 0 : sex.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (sex == null) {
if (other.sex != null)
return false;
} else if (!sex.equals(other.sex))
return false;
return true;
}
}
