Java容器题库
一、 填空题
- Java集合框架提供了一套性能优良、使用方便的接口和类，包括Collection和Map两大类，它们都位于 java.util 包中
- 队列和堆栈有些相似，不同之处在于栈是先进后出，队列是先进先出 。
- 链表 结构是一种由多个节点组成的线性数据结构，并且每个节点包含有数据以及指向下一个节点的引用。
- ___LinkedList__是一种集合类，它 采用链表作为的存储结构，便于删除和添加元素，但是按照索引查询元素效率低下。
- TreeSet 是一种Collection类型的集合类，其中元素唯一，并采用二叉树作为存储结构，元素按照自然顺序排列。
- 如果希望将自定义类Student的多个对象放入集合TreeSet，实现所有元素按照某个属性的自然顺序排列，则需要Student类实现__Comparable__接口。
- 在Java中 HashMap 集合的访问时间接近稳定，它是一种键值对映射的数据结构。这个数据结构是通过数组来实现的。
- 迭代器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代码的作用是首先将一个数组的内容存入集合，然后判断集合中是否有指定的元素存在，其中共有（ D ）处错误。（选择一项） |
|
|
|
import java.util.List; public class Test { public int getIndexofArray(float[] f){ int rtn=-1; float objf=3.4; List list=null; 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 代码，编译运行后将输出（ B ）。（选择一项） |
|
|
|
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() |
||
三、 判断题
- 数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型。( F )
- Java集合中的Set接口和List接口都是从Collection接口派生出来的。（ T ）
- Collection 接口存储一组不唯一，有序的对象，它有两个子接口：List和Set。（ F ）
- Collection是Java集合顶级接口，其中的元素无序，唯一。Java平台不提供这个接口任何直接的实现。（ F ）
- List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引来访问List中的无素，这类似于Java的数组。（ T ）
- HashSet采用哈希表存储结构，特点是查询速度快，但是其中元素无序排列。（ T ）
- LinkedHashMap是一种有序的HashMap，查询速度快，便于添加删除操作。（ T ）
- 基本数据类型的值可以被直接存储在Vector对象中。（ F ）
- Dictionary建立了关键字和值的映射，只要提供一个关键字，Dictionary就会返回一个相应的值。（ T ）
- 泛型是JavaSE1.7的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Java语言引入泛型的好处是安全简单。（ F ）
- Collection是专门操作集合的工具类，提供一系列静态方法实现对各种集合操作。（ F ）
- Iterator接口可以遍历任何Collection接口的实现类，可以从一个Collection中使用iterator( )方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。（ T ）
四、 简答题
- 集合和数组的比较
- 简述List、Set、Collection、Map的区别和联系。
- ArrayList和LinkedList的区别和联系。
- HashSet采用了哈希表作为存储结构，请说明哈希表的特点
- Vector和ArrayList的区别和联系。
- 请你简述HashMap和Hashtable的区别？
五、 编码题
1.使用List和Map存放多个图书信息，遍历并输出。其中商品属性：编号，名称，单价，出版社；使用商品编号作为Map中的key。
public class Book
{
public int id;
public String name;
public double price;
public String press;
public Book()
{
super();
}
public Book(int id, String name, double 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 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;
}
@Override
public String toString()
{
return "Book [id=" + id + ", name=" + name + ", press=" + press
+ ", price=" + price + "]";
}
}
public class TestListMap
{
public static void main(String[] args)
{
Book b1 = new Book(1000, "b1", 30.5, "bjsxt");
Book b1_1 = new Book(1000, "b1", 30, "bjsxt");
Book b2 = new Book(1000, "b2", 50, "bjsxt");
Book b3 = new Book(1001, "b3", 30.5, "bjsxt");
Book b4 = new Book(1002, "b4", 30.5, "bjsxt");
Book b5 = new Book(1003, "b5", 50, "bjsxt1");
//使用HashSet存储图书并遍历
List<Book> bookList = new ArrayList<Book>();
bookList.add(b1);
bookList.add(b1);
bookList.add(b2);
bookList.add(b3);
bookList.add(b4);
bookList.add(b5);
bookList.add(b1_1);
System.out.println("遍历输出hashset");
System.out.println(bookList.size());
for (Book book : bookList)
{
System.out.println(book.toString());
}
//使用TreeSet存储图书并遍历
Map<Integer, Book> bookMap = new HashMap<Integer, Book>();
bookMap.put(b1.getId(), b1);
bookMap.put(b1.getId(), b1);
bookMap.put(b2.getId(), b2);
bookMap.put(b3.getId(), b3);
bookMap.put(b4.getId(), b4);
bookMap.put(b5.getId(), b5);
bookMap.put(b1_1.getId(), b1_1);
System.out.println("遍历输出treeset");
for (Entry<Integer, Book> entry : bookMap.entrySet())
{
System.out.println(entry.getKey() + "----------->" + entry.getValue());
}
}
}
2.使用HashSet和TreeSet存储多个商品信息，遍历并输出；其中商品属性：编号，名称，单价，出版社；要求向其中添加多个相同的商品，验证集合中元素的唯一性。
提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )
向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则
public class Book implements Comparable<Book>
{
public int id;
public String name;
public double price;
public String press;
public Book()
{
super();
}
public Book(int id, String name, double price, String press)
{
super();
this.id = id;
this.name = name;
this.price = price;
this.press = press;
}
public int compareTo(Book o)
{
return this.id - o.id;
}
@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());
long temp;
temp = Double.doubleToLongBits(price);
result = prime * result + (int) (temp ^ (temp >>> 32));
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 (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 (Double.doubleToLongBits(price) != Double
.doubleToLongBits(other.price))
{
return false;
}
return true;
}
@Override
public String toString()
{
return "Book [id=" + id + ", name=" + name + ", press=" + press
+ ", price=" + price + "]";
}
}
public class TestSet
{
public static void main(String[] args)
{
Book b1 = new Book(1000, "b1", 30.5, "bjsxt");
Book b1_1 = new Book(1000, "b1", 30, "bjsxt");
Book b2 = new Book(1000, "b2", 50, "bjsxt");
Book b3 = new Book(1001, "b3", 30.5, "bjsxt");
Book b4 = new Book(1002, "b4", 30.5, "bjsxt");
Book b5 = new Book(1003, "b5", 50, "bjsxt1");
//使用HashSet存储图书并遍历
Set<Book> hashSet = new HashSet<Book>();
hashSet.add(b1);
hashSet.add(b1);
hashSet.add(b2);
hashSet.add(b3);
hashSet.add(b4);
hashSet.add(b5);
hashSet.add(b1_1);
System.out.println("遍历输出hashset");
System.out.println(hashSet.size());
for (Book book : hashSet)
{
System.out.println(book.toString());
}
//使用TreeSet存储图书并遍历
Set<Book> treeSet = new TreeSet<Book>();
treeSet.add(b1);
treeSet.add(b1);
treeSet.add(b2);
treeSet.add(b3);
treeSet.add(b4);
treeSet.add(b5);
treeSet.add(b1_1);
System.out.println("遍历输出treeset");
for (Book book : treeSet)
{
System.out.println(book.toString());
}
}
}
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对象
public class TestListToMap
{
public void listToMap()
{
//1.创建多个学生信息
Student stu1 = new Student(110, "小明", 23, 98.0);
Student stu2 = new Student(111, "大刚", 21, 80.5);
Student stu3 = new Student(112, "小白", 12, 93.0);
//2.加入List
List<Student> list = new ArrayList<Student>();
list.add(stu1);
list.add(stu2);
list.add(stu3);
//3.遍历List，输出每个Student信息
for (Student stu : list)
{
System.out.println(stu);
}
//4.将List中数据放入Map，使用Student的id属性作为key Map<Integer, Student> map = new HashMap<Integer, Student>();
Iterator<Student> it = list.iterator();
while (it.hasNext())
{
Student stu = it.next();
map.put(stu.getId(), stu);
}
//5.遍历Map，输出每个Entry的key和value
Set<Entry<Integer, Student>> entrySet = map.entrySet();
for (Entry<Integer, Student> entry : entrySet)
{
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
}
}
public class StudentEntry
{
private int key;//关键字
private Student stu;//学生
public int getKey()
{
return key;
}
public void setKey(int key)
{
this.key = key;
}
public Student getStu()
{
return stu;
}
public void setStu(Student stu)
{
this.stu = stu;
}
}
public class TestMapToList
{
public void mapToList()
{
//1.创建多个学生信息
Student stu1 = new Student(110, "小明", 23, 98.0);
Student stu2 = new Student(111, "大刚", 21, 80.5);
Student stu3 = new Student(112, "小白", 12, 93.0);
//2.使用Student的id属性作为key，存入Map
Map<Integer, Student> map = new HashMap<Integer, Student>();
map.put(stu1.getId(), stu1);
map.put(stu2.getId(), stu2);
map.put(stu2.getId(), stu3);
//3.创建List对象，每个元素类型是StudentEntry
List<StudentEntry> list = new ArrayList<StudentEntry>();
//4.将Map对象转化为List集合
for (Entry<Integer, Student> entry : map.entrySet())
{
StudentEntry studentEntry = new StudentEntry();
// 将map中的一个映射关系，封装为一个studentEntry对象
studentEntry.setKey(entry.getKey());
studentEntry.setStu(entry.getValue());
// 将studentEntry对象List集合
list.add(studentEntry);
}
//5.遍历Map
for (StudentEntry se : list)
{
System.out.println(se.getKey() + "\t" + se.getStu());
}
}
}
六、 可选题
1.假如有以下email数据“aa@sohu.com,bb@163.com,cc@sina.com,..”现需要把email中的用户部分和邮件地址部分分离，分离后以键值对应的方式放入HashMap？
public class EmailSplit
{
public static void main(String[] args)
{
String str = "aa@sohu.com,bb@163.com,cc@sina.com";
//得到每一个email
String strs[] = str.split(",");
//存放分离后email的信息
Map<String, String> emailMap = new HashMap<String, String>();
for (String email : strs)
{
String temp[] = email.split("@");
//分割email存入map
emailMap.put(temp[0], temp[1]);
}
System.out.println(emailMap.toString());
}
}
2.由控制台按照固定格式输入学生信息，包括学号，姓名，年龄信息，当输入的内容为exit退出；将输入的学生信息分别封装到一个Student对象中，再将每个Student对象加入到一个集合中，要求集合中的元素按照年龄大小正序排序；最后遍历集合，将集合中学生信息写入到记事本，每个学生数据占单独一行。
推荐步骤：
a) 创建Student类，并指定按照年龄正序排列
b) 通过控制台输入多个不同Student信息。格式规定为：编号#姓名#年龄
c) 取出字符串中相应信息放入Student对象，并将Student加入到集合中
d) 遍历集合的过程中将学生的信息输入到记事本
难点：
e) 如何指定学生按照年龄正序排列
f) 如果从字符串“编号#姓名#年龄”中提取学生信息
g) 放入哪种集合后可以保证学生按照年龄大小正序排列
h) 如何将集合中学生信息写入记事本，每个学生数据占单独一行
public class Student implements Comparable<Student>
{
private Integer num;
private String name;
private Integer age;
//省略getter和setter方法
//省略构造方法
public int compareTo(Student stu)
{
return this.age - stu.age;
}
public String toString()
{
return "Student [age=" + age + ", name=" + name
+ ", num=" + num + "]";
}
}
public class Test
{
public static void main(String[] args)
{
//保存输入信息到set中
Set<Student> stuSet = saveStudentInfo();
//遍历set
Iterator<Student> it = stuSet.iterator();
while (it.hasNext())
{
String info = it.next().toString();
System.out.println(info);
}
}
private static Set<Student> saveStudentInfo()
{
Scanner input = new Scanner(System.in);
// 保存学生信息的TreeSet集合对象
Set<Student> stuSet = new TreeSet<Student>();
while (true)
{
// 输入提示
System.out.println("请输入学生信息:(学号#姓名#年龄)");
String inputData = input.nextLine();
// 判断是否退出 inputData.equals("exit")
if ("exit".equals(inputData))
{
break;
}
// 将用户输入的学生信息分割为String[]
String[] info = inputData.split("#");
// 将输入信息封装到Student对象中
Student stu
= new Student(Integer.parseInt(info[0]), info[1],
Integer.parseInt(info[2]));
// 将学生对象加入集合
stuSet.add(stu);
}
return stuSet;
}
}
Java容器题库的更多相关文章
- Java异常题库
一.填空题 __异常处理__机制是一种非常有用的辅助性程序设计方法.采用这种方法可以使得在程序设计时将程序的正常流程与错误处理分开,有利于代码的编写和维护. 在Java异常处理中可以使用多个catch ...
- Java多线程题库
一. 填空题 处于运行状态的线程在某些情况下,如执行了sleep(睡眠)方法,或等待I/O设备等资源,将让出CPU并暂时停止自己的运行,进入____阻塞_____状态. 处于新建状态的线程被启动 ...
- java程序设计题库
选择题 答题要求:单选题,每题只有一个正确答案,选择正确给分,不正确不给分. 1. 下面( A )数据类型可用于main()方法中传递的参数 A.String B.Integer C ...
- 基于java开发的在线题库系统tamguo
简介 探果网(简称tamguo)是基于java开发的在线题库系统,包括 在线访问 后台运营 会员中心 书籍中心 管理员账号:system 密码:123456 因为线上数据和测试数据没有做到隔离,作者已 ...
- 使用Java线程并发库实现两个线程交替打印的线程题
背景:是这样的今天在地铁上浏览了以下网页,看到网上一朋友问了一个多线程的问题.晚上闲着没事就决定把它实现出来. 题目: 1.开启两个线程,一个线程打印A-Z,两一个线程打印1-52的数据. 2.实现交 ...
- Hibernate考试试题（部分题库）含答案
Hibernate考试试题 (题库) 1. 在Hibernate中,下列说法正确的有( ABC ).[选三项] A．Hibernate是一个开放源代码的对象关系映射框架 B．Hibernate对JD ...
- Java容器--2021面试题系列教程（附答案解析）--大白话解读--JavaPub版本
Java容器--2021面试题系列教程(附答案解析)--大白话解读--JavaPub版本 前言 序言 再高大上的框架,也需要扎实的基础才能玩转,高频面试问题更是基础中的高频实战要点. 适合阅读人群 J ...
- 【Java心得总结五】Java容器上——容器初探
在数学中我们有集合的概念,所谓的一个集合,就是将数个对象归类而分成为一个或数个形态各异的大小整体. 一般来讲,集合是具有某种特性的事物的整体,或是一些确认对象的汇集.构成集合的事物或对象称作元素或是成 ...
- 50道经典的JAVA编程题（汇总）
这是一次不可思议的编程历程.从2013年的最后一天开始做这份题,中间连续好几天的考试,包括java考试(今天考试的JAVA编程题),直到今天完成了.挺有成就感的...废话不多说了,来电实质性的吧. 全 ...
随机推荐
- tc 147 2 PeopleCircle(再见约瑟夫环)
SRM 147 2 600PeopleCircle Problem Statement There are numMales males and numFemales females arranged ...
- 决策树-预测隐形眼镜类型 （ID3算法，C4.5算法，CART算法，GINI指数,剪枝，随机森林）
1. 1.问题的引入 2.一个实例 3.基本概念 4.ID3 5.C4.5 6.CART 7.随机森林 2. 我们应该设计什么的算法,使得计算机对贷款申请人员的申请信息自动进行分类,以决定能否贷款? ...
- 【C语言入门教程】3.4 循环控制语句
循环结构又称重复结构,是程序的 种基本结构之一.它反复执行循环体内的代码,解决需要大量重复处理的问题.循环结构由循环控制语句实现,其中内建有条件控制语句,用来判读是否继续执行循环操作.C 语言提供了 ...
- Mac Pro 安装 Sublime Text 2.0.2，个性化设置，主题 和 插件 收藏
1.到官网下载安装包 http://www.sublimetext.com/2 2.附注册码一枚 ----- BEGIN LICENSE ----- Andrew Weber Single User ...
- CSS Image Sprite--网页图片应用处理方式
CSS Sprites简介 CSSSprites在国内很多人叫css精 灵,是一种网页图片应用处理方式.它允许你将一个页面涉及到的所有零星图片都包含到一张大图中去,这样一来,当访问该页面时,载入的图片 ...
- Java(Android)线程池
1.new Thread的弊端执行一个异步任务你还只是如下new Thread吗? new Thread(new Runnable() { @Override public void run() ...
- Android开源项目(二)
第二部分 工具库 主要包括那些不错的开发库,包括依赖注入框架.图片缓存.网络相关.数据库ORM建模.Android公共库.Android 高版本向低版本兼容.多媒体相关及其他. 一.依赖注入DI 通过 ...
- Hibernate get和load区别
1.从返回结果上对比:load方式检索不到的话会抛出org.hibernate.ObjectNotFoundException异常get方法检索不到的话会返回null 2.从检索执行机制上对比: ...
- 淘宝(阿里百川)手机客户端开发日记第十篇 阿里百川服务器环境介绍之API文档的快速链接(四)
个人感觉比较重要的快速链接: http://open.taobao.com/doc/detail.htm?id=102513 http://open.taobao.com/doc/detail.htm ...
- delay（) .split（）
delay(500) 延时多少秒后执行,结合animate()使用 delay(500).animate({},时间) .split() stringObject.split(separator,ho ...