JAVA集合试题库.docx
《JAVA集合试题库.docx》由会员分享，可在线阅读，更多相关《JAVA集合试题库.docx（38页珍藏版）》请在冰豆网上搜索。
JAVA集合试题库
集合
一、第一模块：
知识点讲解
图解集合
IteratorCollectionMap
ListIteratorListSetHashMapTreeMap
LinkedHashMap
ArrayListLinkListHashSetTreeSet
LinkedHashSet
Comparablecomparator
1、集合的由来：
我们学的语言是面向对象的语言，为了方便对多个对象进行操作，我们就必须把对象存储。
而要存储多个对象，就不能是一个基本变量，而应该是一个容器类型的变量。
这样就引入了集合。
*以前接触过得容器：
数组、StringBuffer等
由于StringBuffer的结果是一串字符，不一定能满足我们的要求，所以我们只能选择数组，这就是对象数组。
而对象数组不能适应变化的需求，因为数组的长度是固定。
2、数组和集合的区别
1长度区别
集合的长度可变
数组长度不可变
2内容区别
集合可以存储不同类型的元素
数组存储的是同一种类型的元素
3元素的数据类型问题
数组可以存储基本数据类型也可以存储引用数据类型
集合只能存储引用类型
针对不同的需求，Java提供了不同的集合类，这多个集合的数据结构不同
*数据结构:
数据的存储方式
Java提供的多种集合类，他们的数据结构不同,但是，他们肯定有共性的内容（存储、获取、判断等）。
通过不断的向上提取，我们就能够得到一个集合的继承体系结构图。
把上面这段话转化为图形的形式：
collection
ListSet
ArrayListVectorLinkedListHashSet
TreeSet
通过这个图可以清楚的理解集合
现在我们从最低层开始学习
一、Collection（接口Java.util）
1、功能：
①：
添加
booleanadd（Objectobj）添加一个元素
booleanaddAll（Collectionc）添加一个集合的元素
②：
删除
voidclear（）移除所有元素
booleanremove（Objectobj）移除一个元素
booleanremoveAll（Collectionc）移除一个集合的元素
③：
判断
booleancotains（Objecto）判断集合中是否包含指定元素
booleancontainsAll（Collectionc）判断集合中是否包含指定集合
Collectionc1=newArrayList（）;
c1.add（"hello"）;
c1.add（"java"）;
c1.add（"world"）;
Collectionc2=newArrayList（）;
c2.add（"a"）;
c2.add（"c"）;
c2.add（"world"）;
System.out.println（"containsAll:
"+c1.containsAll（c2））;
System.out.println（c1）;
System.out.println（c2）;
打印结果：
containsAll:
false
c1[hello,java,world]
c2[a,c,world]
booleanisEmpty（）判断是否是空
④获取
Iteratoriterator（）
⑤长度
intsize（）
⑥交集功能（了解）
booleanretainAll（Collectionc）交集
两个集合中都有的元素，返回值的意思？
假设有两个集合A,B。
A对B做交集，最终存在A中，B不变，返回值表示的是A是否发生过改变。
Collectionc1=newArrayList（）;
c1.add（"hello"）;
c1.add（"java"）;
c1.add（"world"）;
Collectionc2=newArrayList（）;
c2.add（"a"）;
c2.add（"c"）;
c2.add（"world"）;
System.out.println（"retainAll:
"+c1.retainAll（c2））;
System.out.println（"c1:
"+c1）;
System.out.println（"c2:
"+c2）;
打印结果：
retainAll:
true
c1:
[world]
c2:
[a,c,world]
⑦把集合转成数组
Object[]toArray（）
注意：
*通过测试得出的一些结论
removeAll（）:
只要有一个被移除就叫移除
containsAll（）:
只有包含所有的元素才叫包含
retainsAll（）:
谁调用谁变，没有交集元素，那个集合就变为空。
返回值的含义就是有集合变了就返回true，否则返回false。
2、创建Collection对象
Collectionc=newArrayList（）;//因为Collection是接口，并且它没有直接实现类，而ArrayList是其子接口，通过测试，可以看出它重写了toString（）方法，直接输出打印的是[],ArrayList集合里面的元素可以重复
3、集合的遍历
①把集合转成数组，可以实现集合的遍历
//创建对象
Collectionc=newArrayList（）;
c.add（“hello”）;
c.add（“world”）;
c.add（“java”）;
//遍历（toArray（））
Object[]objs=c.toArray（）;
for（intx=0;xSystem.out.println（objs[x]）;
}
//但是要想得到个字符串的长度，则需要向下转型
Strings=（String）objs[x];
System.out.println（s.length（））;
②Iterator迭代器
//创建对象
Collectionc=newArrayList（）;
c.add（“hello”）;
c.add（“world”）;
c.add（“java”）;
//遍历
Iteratorit=c.iterator（）;
while（it.hasNext（））{
Strings=（String）it.next（）;//next（）的返回值是
System.out.println（s）;
}
另一种方式改进，for循环改进
for（Iteratorit=c.iterator（）;it.hasNext（）;）{
Strings=（String）it.next（）;
System.Out.println（s）;
}
4、迭代器
是遍历集合的一种方式。
迭代器依赖于集合而存在。
迭代器的方法next（）,hasNext（）
5、集合的使用步骤
①创建集合对象
②创建元素对象
③把元素添加到集合
④遍历集合
<1>通过集合对象获取迭代器对象
<2>通过迭代器对象的hasNext（）方法判断是否还有下一个元素
<3>通过迭代器对象的next（）方法获取元素,并移动到下一个位置
*迭代器为什么不定义成一个类，而是一个接口
假设迭代器是一个类，这样我们就可以创建该类的对象，调用该类的方法来实现集合的遍历。
但是Java中提供了很多的集合类，这些集合类的数据结构是不同的，所以，存储方式和遍历方式不同，最终，就没有定义迭代器类
而无论是哪种集合，你都应该具备获取元素的操作，并且，最好具有判断功能，这样，在获取前，先判断就不容易出错，也就是说，判断功能和获取功能是一个集合所具备的，而每种集合的方式又不太一样，所以我们把这两个功能给取出来并不提供具体实现类，这种方式就是接口。
那么真正的具体实现类在哪呢？
在真正的具体的子类中，以内部类的方式体现。
二、List集合（Collection的子类）
1、List集合的特有功能
①添加功能
voidadd（intindex,Objectelment）;在指定位置添加元素
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
list.add（4,"javaee"）;
System.out.print（"list:
"+list）;
报错：
IndexOutOfBoundsException
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
list.add（3,"javaee"）;
System.out.print（"list:
"+list）;
打印结果：
list:
[hello,world,java,javaee]
②获取功能
Objectget（intindex）;获取指定位置的元素
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
System.out.print（"list:
"+list.get（3））;
报错：
IndexOutOfBoundsException
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
System.out.print（"get（）:
"+list.get
（2））;
打印结果:
get（）:
java
③列表迭代器
ListIteratorlistIterator（）;List集合中特有的迭代器
④删除功能
Objectremove（intindex）;根据索引删除元素
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
System.out.print（"remove（）:
"+list.get
（2））;
打印结果：
remove（）:
java
⑤修改功能
Objectset（intindex,Objectelement）;根据索引修改元素，返回被修复的元素
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
System.out.println（"set（）:
"+list.set（2,"javaee"））;
System.out.print（list）;
打印结果：
set（）:
java
[hello,world,javaee]
2、List集合的遍历
//创建对象
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
//遍历
for（intx=0;xStrings=（String）list.get（x）;
System.out.println（s）;
}
3、listIterator（）的使用（只能创建list对象，一般不用）
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
ListIteratorlit=list.listIterator（）;
while（lit.hasNext（））{
Strings=（String）lit.next（）;
System.out.println（s）;
//可以从后面开始打印，逆向遍历
}
System.out.println（"--------------"）;
while（lit.hasPrevious（））{
Strings=（String）lit.previous（）;
System.out.println（s）;
}
//这段代码只有在正向遍历之后才有效，所以一般无意义，不使用
打印结果：
hello
world
java
--------------
java
world
hello
4、List的子类特点
ArrayList：
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
Vector：
底层数据结构是数组，查询快，增删慢
线程安全，效率低
LinkedList：
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
5、并发修改的异常（ConcurrentModificationException）
①出现的现象
迭代器遍历集合，集合修改集合
代码演示：
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
Iteratorit=list.iterator（）;
while（it.hasNext（））{
Strings=（String）it.next（）;
if（"world".equals（s））{
list.add（"javaee"）;
}
}
System.out.println（"list:
"+list）;
②原因
迭代器是依赖于集合，而集合的改变迭代器不知道
③解决方案
<1>迭代器遍历，迭代器修改（ListIterator）
元素添加在刚才迭代的位置
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
ListIteratorlit=list.listIterator（）;
while（lit.hasNext（））{
Strings=（String）lit.next（）;
if（（"world"）.equals（s））{
lit.add（"javaee"）;
}
}
System.out.print（"list:
"+list）;
打印结果：
list:
[hello,world,javaee,java]
<2>集合遍历，集合修改（size（）,get（））
元素添加在集合的末尾
Listlist=newArrayList（）;
list.add（"hello"）;
list.add（"world"）;
list.add（"java"）;
for（inti=0;iStrings=（String）list.get（i）;
if（"world".equals（s））{
list.add（"javaee"）;
}
}
System.out.print（"list"+list）;
打印结果：
list[hello,world,java,javaee]
三、1、ArrayList集合（List的子类）
由于ArrayList是list的子类，所以多种方法都是从基类上继承下来的。
下面看ArrayList是如何遍历的
//创建对象
ArrayListarray=newArrayList（）;
//创建元素对象，并添加元素
array.add（"hello"）;
array.add（"world"）;
array.add（"java"）;
//第一种遍历
Iteratorit=array.iterator（）;
while（it.hasNext（））{
Strings=（String）it.next（）;
System.out.println（s）;
}
//第二种遍历
for（intx=0;xStrings=（String）array.get（x）;
System.out.println（s）;
}
*例题：
ArrayList去除集合中字符串的重复值（字符串的内容相同）
分析：
*A:
创建集合对象
*B:
添加多个字符串元素（包含内容相同的）
*C:
创建新集合
*D:
遍历旧集合,获取得到每一个元素
*E:
拿这个元素到新集合去找，看有没有
*有：
不搭理它
*没有：
就添加到新集合
*F:
遍历新集合
publicclassArrayListDemo{
publicstaticvoidmain（String[]args）{
ArrayListarray=newArrayList（）;
//添加多个字符串元素（包含内容相同的）
array.add（"hello"）;
array.add（"world"）;
array.add（"java"）;
array.add（"world"）;
array.add（"java"）;
array.add（"world"）;
array.add（"world"）;
array.add（"world"）;
array.add（"world"）;
array.add（"java"）;
array.add（"world"）;
//创建新集合
ArrayListnewArray=newArrayList（）;
//遍历旧集合,获取得到每一个元素
Iteratorit=array.iterator（）;
while（it.hasNext（））{
Strings=（String）it.next（）;
//拿这个元素到新集合去找，看有没有
if（!
newArray.contains（s））{
newArray.add（s）;
}
}
//遍历新集合
for（intx=0;xStrings=（String）newArray.get（x）;
System.out.println（s）;
}
}
}
2、案例：
例一：
基因牛的繁殖
张教授采用基因干预技术成功培养出一头母牛，三年后，这头母牛每年会生出1头母牛，
生出来的母牛三年后，又可以每年生出一头母牛。
如此循环下去，请问张教授n年后有多少头母牛?
/**
*张教授采用基因干预技术成功培养出一头母牛，
*三年后，这头母牛每年会生出1头母牛，
*生出来的母牛三年后，又可以每年生出一头母牛。
*如此循环下去，请问张教授n年后有多少头母牛?
*
*这个题的理解
*刚开始造了一头牛，循环三次后，第二头牛造了出来，循环第四次时，第一头牛又造了一头牛，第二头牛循环三次后又造了一头牛。
。
。
。
。
依次类推
*
*思路：
首先定义一个牛类，这个类里面有一个成员变量age,这个age的作用是用来记牛的年龄的
*其次在这个类里有一个方法，是来判断这个牛的age是否符合生小牛的条件的。
*假设每调用一次该方法age就加1
*另一个方法是一个静态方法，带一个参数n,这个n指的是传过来的年数
*这个方法是用来造牛的
*/
importjava.util.ArrayList;
importjava.util.List;
//定义一个Cow类
classCow{
intage;//变量
//方法：
作用：
到了第三年就创建一个牛
publicCowafterYear（）{
age++;
returnage>2?
newCow（）:
null;//填空
}
//方法:
作用：
此方法带一个参数n,是用来传递年数的。
publicstaticvoidshowTotalCowNum（intn）{//显示13年后全部牛的数量
//这个地方用到了List集合，但由于List是接口，所以找到了它的直接实现类ArrayList
//创建一个集合对象，这个集合的类型为Cow
Listlist=newArrayList（）;
//创建了一个牛，把它加到了集合中
list.add（newCow（））;
//n为年数
for（inti=0;iintcowCount=list.size（）;//集合的长度即牛的个数
for（intj=0;jCowcow=list.get（j）.afterYear（）;//三年后，母牛就会每年生一只小牛，
//如果cow对象不为空时
if（cow!
=null）{
cow.afterYear（）;//这个对象调用afterYear填空
list.add（cow）;
}
}
}
System.out.println（n+"yearafter,sum:
"+list.size（））;
}
}
publicclassMain{
publicstaticvoidmain（String[]args）{
Cow.showTotalCowNum（13）;
}
}
四、Vector集合（List的子类）
1、Vector的特有功能：
A、添加功能
publicvoidaddElement（Objectobj）;
B、获取功能
publicObjectelementAt（intindex）;
publicEnumerationelements（）;
boolean
升级会员 