尚学堂-第九章答案

最新推荐文章于 2021-10-29 19:35:20 发布

Kurt_xcy

最新推荐文章于 2021-10-29 19:35:20 发布

阅读量2.1k

点赞数 1

分类专栏：尚学堂答案文章标签： java

本文链接：https://blog.csdn.net/weixin_44001681/article/details/104163132

版权

尚学堂答案专栏收录该内容

9 篇文章 4 订阅

订阅专栏

一、选择题

以下选项中关于Java集合的说法错误的是( )。(选择二项)

A.List接口和Set接口是Collections接口有两个子接口

B.List接口中存放的元素具有有序，不唯一的特点

C.Set接口中存放的元素具有无序，不唯一的特点

D.Map接口存放的是映射信息，每个元素都是一个键值对

如下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.编译时出现异常

在Java中,下列集合类型可以存储无序、不重复的数据的是( )。(选择一项)

A.ArrayList

B.LinkedList

C.TreeSet

D.HashSet

以下代码的执行结果是( )。(选择一项)

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

给定如下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

二、简答题

集合和数组的比较。
存储类型方面，集合存储引用数据类型（或者基本数据类型的包装类），数组既可以存储基本数据类型也可以存储引用数据类型。
容量方面，集合可以动态的改变容量，可以知道实际存在元素多少，而数组容量一旦确定无法改变，无法知道实际的元素多少。
底层方面，集合采用了顺序表，树，散列表多种方式。而数组仅仅采用了顺序表的方式。
简述List、Set、Collection、Map的区别和联系。
List和Set是Collection接口的两个子接口
Collection接口存储一组无序、不唯一的对象
List接口存储有序、不唯一的对象
Set接口存储无序、唯一的对象
Map接口存储键值对对象，其中key唯一，最多可以有一个null值，value不唯一，可以有多个null值。
ArrayList和LinkedList的区别和联系。它们的底层分别是用什么实现的?
ArrayList底层是用数组实现的，LinkedList是用双向链表实现的。
HashSet采用了哈希表作为存储结构，请说明哈希表的特点和实现原理。
提示：结合Object类的hashCode()和equals()说明其原理。
系统类已经覆盖了hashCode方法，自定义类如果要放入hash类集合，一般会重写hashCode方法和equals方法，如果不重写，调用的是Object类的hashCode方法和equals方法，而Object类的hashCode方法返回的是对象的地址，equals方法会默认调用==判断对象的地址是否相同。

向哈希表中添加数据的原理：当向集合中增加对象时，首先集合会计算要增加对象的哈希码，并根据该哈希码得到一个位置存放当前对象，如果该位置没有对象存在的话，那么集合认为该对象在集合中不存在，直接放入，如果该位置有对象存在的话，会调用equals方法比较两个对象是否相等，如果相等，则集合认为集合中已经存在该对象，就不会再放入该对象，如果不相等，则集合就会再进行一次散列，并将该对象放到散列后计算出的新地址中。

使用泛型有什么好处?
消除强制转化，增强代码重用性。

三、编码题

使用List和Map存放多个图书信息，遍历并输出。其中商品属性：编号，名称，单价，出版社;使用商品编号作为Map中的key。

public class Ninth1 {
	public static void main(String[] args) {
		HashMap<String, List<String>> books = new HashMap<>();
		List<String> property= new ArrayList<>();
		
		books.put("001", add("人性的弱点", "58", "a出版社"));
		books.put("002", add("人性的弱点2", "48", "b出版社"));
		books.put("003", add("人性的弱点3", "68", "c出版社"));
		System.out.println(books.get("001"));
		
	}
	
	public static List<String> add(String name,String price,String publisher) {
		List<String> property= new ArrayList<>();
		property.add(name);
		property.add(price);
		property.add(publisher);
		return property;
	}
}

（以下待更新）
2. 使用HashSet和TreeSet存储多个商品信息，遍历并输出;其中商品属性：编号，名称，单价，出版社;要求向其中添加多个相同的商品，验证集合中元素的唯一性。

提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )。

向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则。

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

class Book implements Comparable<Book>{
	int id;
	String name;
	double price;
	String publisher;
	
	public Book(int id,String name,int price,String publisher) {
		this.id = id;
		this.name = name;
		this.price = price;
		this.publisher = publisher;
	}
	
	
	
	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 getPublisher() {
		return publisher;
	}



	public void setPublisher(String publisher) {
		this.publisher = publisher;
	}


	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("[id:"+id+",name:"+name+",price:"+price+",publisher:"+publisher);
		return sb.toString();
		
	}
	@Override
	public int hashCode() {
		int result = 1;
		final int prime = 31;
		result = prime*result+id;
		result = prime*result+(name==null?0:name.hashCode());
		result = prime*result+(publisher==null?0:publisher.hashCode());
		long temp = Double.doubleToLongBits(price);
		result = prime*result+(int)(temp^(temp>>>32));
		return result;
	}
	
	@Override
	public int compareTo(Book b) {
		 int i = id - b.getId();

	        if (i == 0) {
	            return name.compareTo(b.getName());
	        } else {
	            return i;
	        }
	}
	
}


public class Ninth2 {
	public static void main(String[] args) {
        Book book1 = new Book(1, "Java从入门到精通", 20, "清华大学出版社");
        Book book2 = new Book(2, "Java编程思想", 80, "清华大学出版社");
        Book book3 = new Book(3, "Java设计模式", 50, "清华大学出版社");
        Book book4 = new Book(1, "Java从入门到精通", 10, "清华大学出版社");
        Book book5 = new Book(2, "Java编程思想", 80, "清华大学出版社");
        Book book6 = new Book(3, "Java设计模式", 50, "清华大学出版社");
        Set<Book> bookSet = new HashSet<Book>();
        bookSet.add(book1);
        bookSet.add(book2);
        bookSet.add(book3);
        bookSet.add(book4);
        bookSet.add(book5);
        bookSet.add(book6);

        for (Book book : bookSet) {
            System.out.println(book);
        }
        
        System.out.println("-----------------------------------------------------");

        TreeSet<Book> bookTreeSet = new TreeSet<Book>();
        bookTreeSet.add(book1);
        bookTreeSet.add(book2);
        bookTreeSet.add(book3);
        bookTreeSet.add(book4);
        bookTreeSet.add(book5);
        bookTreeSet.add(book6);

        for (Book book : bookTreeSet) {
            System.out.println(book);
        }
    }
	
}

以上程序中：HashSet比较的是hashcode是否相同，如果要避免地址不同、内容相同的对象重复添加进HashSet就要在重写hashcode的基础上重写equals方法，重写hashcode是保证内容相同的对象的hashcode相同，之后会调用equals方法，当不重写equals方法就会默认比较对象地址，这样就会把地址不同内容相同的对象重复添加，重写equals方法保证内容不相同返回false 内容相同返回true，这样就可以保证不重复添加了。
而TreeSet在比较是否重复对象默认调用compareto。
3. 实现List和Map数据的转换。具体要求如下：

功能1：定义方法public void listToMap( ){ }将List中Student元素封装到Map中

使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息并加入List;
遍历List，输出每个Student信息;
将List中数据放入Map，使用Student的id属性作为key，使用Student对象信息作为value;
遍历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接口的作用，并通过分数来对学生进行排序。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

class Student2{
	int id;
	String name;
	int age;
	String sex;
	
	public Student2(int id,String name,int age,String sex) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("["+"id:"+id+",name:"+name+",age:"+age+",sex:"+sex+"]");
		return sb.toString();
	}

	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;
	}
	
	
}

class StudentsListToMap{  
	HashMap<Integer, Student2> studentsMap;
	List<Student2> studentsList;
	
	
	
	public HashMap<Integer, Student2> getStudentsMap() {
		return studentsMap;
	}

	public void setStudentsMap(HashMap<Integer, Student2> studentsMap) {
		this.studentsMap = studentsMap;
	}

	public List<Student2> getStudentsList() {
		return studentsList;
	}

	public void setStudentsList(List<Student2> studentsList) {
		this.studentsList = studentsList;
	}

	public StudentsListToMap(List<Student2> studentsList) {
		this.studentsMap = new HashMap<>();
		
		this.studentsList = studentsList;
	}
	
	public void listToMap(List<Student2> students) {
		for(int i=0;i<students.size();i++) {
			this.studentsMap.put(students.get(i).getId(), students.get(i));
		}
	}
	
	
	public void showMap() {
		for(int i=0;i<studentsMap.size();i++) {
			System.out.println(studentsMap.get(studentsList.get(i).getId()));
		}
	}
	
	
}

class StudentsMapToList{
	HashMap<Integer, Student2> studentsMap;
	List<Student2> studentsList;
	
	public HashMap<Integer, Student2> getStudentsMap() {
		return studentsMap;
	}

	public void setStudentsMap(HashMap<Integer, Student2> studentsMap) {
		this.studentsMap = studentsMap;
	}

	public List<Student2> getStudentsList() {
		return studentsList;
	}

	public void setStudentsList(List<Student2> studentsList) {
		this.studentsList = studentsList;
	}

	public StudentsMapToList(HashMap<Integer, Student2> studentMap) {
		this.studentsMap = studentMap;
		this.studentsList = new ArrayList<Student2>();
	}
	
	public void mapToList(List<Student2> studentList) {
		for(int i=0;i<studentList.size();i++) {
			this.studentsList.add(studentsMap.get(studentList.get(i).getId()));
		}
	}
	
	public void showList() {
		for(int i=0;i<studentsList.size();i++) {
			System.out.println(studentsList.get(i));
		}
	}
	
}




public class Ninth3 {
	public static void main(String[] args) {
		Student2 s1 = new Student2(1, "aaa", 18, "男");
		Student2 s2 = new Student2(2, "bbb", 19, "女");
		Student2 s3 = new Student2(3, "ccc", 20, "男");
		
		List<Student2> studentList = new ArrayList<Student2>();
		studentList.add(s1);
		studentList.add(s2);
		studentList.add(s3);
		StudentsListToMap slm2 = new StudentsListToMap(studentList);
		slm2.listToMap(studentList);
		slm2.showMap(); 
		System.out.println("---------------------------------------");
		StudentsMapToList sml2 = new StudentsMapToList(slm2.getStudentsMap());
		sml2.mapToList(studentList);
		sml2.showList();
	}
}