请看下列代码：
public void testAddAllAndContainsAll() {
Collection<String> c1 = new ArrayList<String>();
c1.add("terry");
c1.add("allen");
System.out.println(c1);
Collection<String> c2 = new HashSet<String>();
c2.addAll(c1);
System.out.println(c2);
Collection<String> c3 = new ArrayList<String>();
c3.add("terry");
System.out.println(c1.containsAll(c3));
}
运行testAddAllAndContainsAll方法，程序的输出结果是：（）。
A．[terry, allen]
[allen, terry]
false
B．[terry, allen]
[allen, terry]
true
C．[terry, allen]
[]
True
D．[terry, allen]
[]
false
参考答案
本题的正确答案为B。
本题中涉及到Collection接口的addAll和containsAll方法的应用。其中，addAll方法需要我们传入一个集合，并将该集合中的所有元素添加到当前集合中；containsAll方法用于判断当前集合是否包含给定集合中的所有元素，若包含则返回true。
A．Iterator用于遍历集合元素。获取Iterator可以使用Collection定义的iterator方法。
B．Iterator提供了统一的遍历集合元素的方式，其提供了用于遍历集合的两个方法，hasNext用于返回迭代的下一个元素，next方法用于判断集合是否还有元素可以遍历。
C．在使用Iterator遍历集合时，不能通过集合的remove方法删除集合元素，否则会抛出异常。我们可以通过迭代器自身提供的remove()方法来删除通过next()迭代出的元素。
D．Java5.0之后推出了一个新的特性，增强for循环,也称为新循环。该循环只用于遍历集合或数组。在遍历集合时，该循环是与Iterator完全不同的迭代方式。
参考答案
本题正确答案为AC。
B选项错在两个方法的作用上。Iterator的next方法用于返回迭代的下一个元素，hasNext方法用于判断集合是否还有元素可以遍历。
D选项错在增强for循环的实质上。增强for循环并非新的语法，而是在编译过程中，编译器会将新循环转换为迭代器模式，所以增强for循环本质上是迭代器。
参考答案
List接口的两个常见实现类为ArrayList和LinkedList，分别用动态数组和链表的方式实现了List接口。
可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。
请看下列代码：
public void testInsertAndRemove() {
List<String> list = new ArrayList<String>();
list.add("terry");
list.add("allen");
list.add("smith");
list.add(2, "marry");
System.out.println(list);
list.remove(1);
System.out.println(list);
}
运行testInsertAndRemove方法，程序的输出结果是：（）。
A．[terry, marry, allen, smith]
[terry, marry, smith]
B．[terry, marry, allen, smith]
[allen, marry, smith]
C．[terry, allen, marry, smith]
[allen, marry, smith]
D．[terry, allen, marry, smith]
[terry, marry, smith]
参考答案
本题正确答案为D。
本题涉及到List接口的add(int index,E element)方法以及remove方法的应用。其中，add方法将给定的元素插入到指定索引位置，原位置及后续元素都顺序向后移动；remove方法用于删除给定索引位置的元素，并将被删除的元素返回。这里的索引位置都是从0开始的。
请看下列代码：
public void testSubList() {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
List<Integer> subList = list.subList(2, 5);
for (int i = 0; i < subList.size(); i++) {
subList.set(i, subList.get(i) * 10);
}
System.out.println(subList);
System.out.println(list);
}
运行testSubList方法，程序的输出结果是：（）。
A．[20, 30, 40,50]
[0, 1, 20, 30, 40, 50, 6, 7, 8, 9]
B．[20, 30, 40,50]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
C．[20, 30, 40]
[0, 1, 20, 30, 40, 5, 6, 7, 8, 9]
D．[20, 30, 40]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
参考答案
本题正确答案为C。
本题涉及到List接口的subList方法的应用。List的subList方法用于获取子List。需要注意的是，subList获取的List与原List占有相同的存储空间，对子List的操作会影响到原List。该方法的声明如下：
List<E> subList(int fromIndex, int toIndex);
上述方法声明中的fromIndex和toIndex是截取子List的首尾下标（前包括，后不包括）。
参考答案
1) 将List转化为数组。 List的toArray方法用于将集合转换为数组。但实际上该方法是在Collection中定义的，所以所有的Collection集合都具备这个功能。其有两个方法:
Object[] toArray() <T>T[] toArray(T[] a)
其中第二个方法是比较常用的，我们可以传入一个指定类型的数组，该数组的元素类型应与集合的元素类型一致。返回值则是转换后的数组，该数组会保存集合中所有的元素。
2) 将数组转化为List。Arrays类中提供了一个静态方法asList，使用该方法我们可以将一个数组转换为对应的List集合。其方法定义为:
static <T>List<T> asList<T… a>
以上方法返回的List的集合元素类型由传入的数组的元素类型决定。并且要注意的是，返回的集合我们不能对其增删元素，否则会抛出异常。并且对集合的元素进行的修改会影响数组对应的元素。
使用Comparator接口实现对集合中的元素排序，详细要求如下：
1） 使用ArrayList构建集合对象emps，要求该集合中存储Emp类型的数据。
2） 分别构造name、age、gender以及salary为（"Terry", 25,'m',6000）、（"Allen", 21,'f',4000)、（"Smith", 23,'m',3000）的三个Emp类的对象，并将这三个对象加入到集合emps中。
3） 使用Collections类提供的sort方法，按照Emp对象的salary属性的值升序排列集合emps，sort方法的声明如下：
public static <T> void sort(List<T> list,
Comparator<? super T> c)
参考答案
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
首先，在TestEmpSort类中新建测试方法testComparator；然后，使用ArrayList构建集合对象emps，代码如下所示：
package day04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
public class TestEmpSort {
@Test
public void testComparator() {
List<Emp> emps = new ArrayList<Emp>();
}
}
步骤二：向集合emps中添加对象
分别构造name、age、gender以及salary为（"Terry", 25,'m',6000）、（"Allen", 21,'f',4000)、（"Smith", 23,'m',3000）的三个Emp类的对象，并将这三个对象加入到集合emps中，代码如下所示：
package day04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
public class TestEmpSort {
@Test
public void testComparator() {
List<Emp> emps = new ArrayList<Emp>();
#cold_bold emps.add(new Emp("Terry", 25,'m',6000));
#cold_bold emps.add(new Emp("Allen", 21,'f',4000));
#cold_bold emps.add(new Emp("Smith", 23,'m',3000));
}
}
步骤三：使用Comparator接口实现排序
使用Collections类提供的sort方法，按照Emp对象的salary属性值升序排列emps集合中的对象，代码如下所示：
package day04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
public class TestEmpSort {
@Test
public void testComparator() {
List<Emp> emps = new ArrayList<Emp>();
emps.add(new Emp("Terry", 25,'m',6000));
emps.add(new Emp("Allen", 21,'f',4000));
emps.add(new Emp("Smith", 23,'m',3000));
#cold_bold Collections.sort(emps, new Comparator<Emp>() {
#cold_bold @Override
#cold_bold public int compare(Emp o1, Emp o2) {
#cold_bold return o1.salary>o2.salary?1:(o1.salary==o2.salary?0:-1);
#cold_bold }
#cold_bold });
#cold_bold System.out.println(emps);
}
}
步骤四：运行
运行testComparator方法，控制台输出结果如下所示：
[Smith,23,m,3000.0, Allen,21,f,4000.0, Terry,25,m,6000.0]
从运行结果可以看出，已经按照Emp对象的salary属性值升序排列集合emps中的元素。
本案例中，类TestEmpSort的完整代码如下所示：
package day04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
public class TestEmpSort {
@Test
public void testComparator() {
List<Emp> emps = new ArrayList<Emp>();
emps.add(new Emp("Terry", 25,'m',6000));
emps.add(new Emp("Allen", 21,'f',4000));
emps.add(new Emp("Smith", 23,'m',3000));
Collections.sort(emps, new Comparator<Emp>() {
@Override
public int compare(Emp o1, Emp o2) {
return o1.salary>o2.salary?1:(o1.salary==o2.salary?0:-1);
}
});
System.out.println(emps);
}
}
参考答案
队列与栈的不同点如下：
队列遵循先进先出（FIFO，First Input First Output ）的原则，而栈遵循先进后出（FILO，First Input Last Output ）的原则。
队列和栈在Java语言中的实现如下：
JDK中提供了Queue接口来实现队列这个数据结构，同时使得LinkedList实现了该接口；同时，JDK中还提供了Deque接口来实现栈这个数据结构，而 LinkedList也实现了该接口。