基本的IO操作

1 下面代码输出的结果是？

请看下列代码：

  1.     public void testAddAllAndContainsAll() {
  2.         Collection<String> c1 = new ArrayList<String>();
  3.         c1.add("terry");
  4.         c1.add("allen");
  5.         System.out.println(c1);
  6.         Collection<String> c2 = new HashSet<String>();
  7.         c2.addAll(c1);
  8.         System.out.println(c2);
  9.         Collection<String> c3 = new ArrayList<String>();
  10.         c3.add("terry");
  11.         System.out.println(c1.containsAll(c3));
  12.     }

运行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。

2 关于Iterator，说法正确的是？

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循环本质上是迭代器。

3 简述ArrayList和LinkedList的不同

参考答案

List接口的两个常见实现类为ArrayList和LinkedList，分别用动态数组和链表的方式实现了List接口。

可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。

4 下面代码输出的结果是？

请看下列代码：

 
  1.     public void testInsertAndRemove() {
  2.         List<String> list = new ArrayList<String>();
  3.         list.add("terry");
  4.         list.add("allen");
  5.         list.add("smith");
  6.         list.add(2, "marry");
  7.         System.out.println(list);
  8.         list.remove(1);
  9.         System.out.println(list);
  10.     }

运行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开始的。

5 下面代码输出的结果是？

请看下列代码：

 
  1.     public void testSubList() {
  2.         List<Integer> list = new ArrayList<Integer>();
  3.         for (int i = 0; i < 10; i++) {
  4.             list.add(i);
  5.         }
  6.         List<Integer> subList = list.subList(2, 5);
  7.         for (int i = 0; i < subList.size(); i++) {
  8.             subList.set(i, subList.get(i) * 10);
  9.         }
  10.         System.out.println(subList);
  11.         System.out.println(list);
  12.     }

运行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。该方法的声明如下：

  1. List<E> subList(int fromIndex, int toIndex);

上述方法声明中的fromIndex和toIndex是截取子List的首尾下标（前包括，后不包括）。

6 简述List和数组直接相互转化的方法

参考答案

1) 将List转化为数组。 List的toArray方法用于将集合转换为数组。但实际上该方法是在Collection中定义的，所以所有的Collection集合都具备这个功能。其有两个方法:

  1.         Object[] toArray()
  2.         <T>T[] toArray(T[] a)

其中第二个方法是比较常用的，我们可以传入一个指定类型的数组，该数组的元素类型应与集合的元素类型一致。返回值则是转换后的数组，该数组会保存集合中所有的元素。

2) 将数组转化为List。Arrays类中提供了一个静态方法asList，使用该方法我们可以将一个数组转换为对应的List集合。其方法定义为:

 
  1.         static <T>List<T> asList<T… a>

以上方法返回的List的集合元素类型由传入的数组的元素类型决定。并且要注意的是，返回的集合我们不能对其增删元素，否则会抛出异常。并且对集合的元素进行的修改会影响数组对应的元素。

7 使用Comparator接口实现排序

使用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方法的声明如下：

  1. public static <T> void sort(List<T> list,
  2. Comparator<? super T> c)

参考答案

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

首先，在TestEmpSort类中新建测试方法testComparator；然后，使用ArrayList构建集合对象emps，代码如下所示：

 
  1. package day04;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.List;
  7. import org.junit.Test;
  9. public class TestEmpSort {
  10.     @Test
  11.     public void testComparator() {
  12.         List<Emp> emps = new ArrayList<Emp>();
  13.     }
  14. }

步骤二：向集合emps中添加对象

分别构造name、age、gender以及salary为（"Terry", 25,'m',6000）、（"Allen", 21,'f',4000)、（"Smith", 23,'m',3000）的三个Emp类的对象，并将这三个对象加入到集合emps中，代码如下所示：

 
  1. package day04;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.List;
  7. import org.junit.Test;
  9. public class TestEmpSort {
  10.     @Test
  11.     public void testComparator() {
  12.         List<Emp> emps = new ArrayList<Emp>();
  13.         emps.add(new Emp("Terry", 25,'m',6000));
  14.         emps.add(new Emp("Allen", 21,'f',4000));
  15.         emps.add(new Emp("Smith", 23,'m',3000));
  16.     }
  17. }

步骤三：使用Comparator接口实现排序

使用Collections类提供的sort方法，按照Emp对象的salary属性值升序排列emps集合中的对象，代码如下所示：

 
  1. package day04;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.List;
  7. import org.junit.Test;
  9. public class TestEmpSort {
  10.     @Test
  11.     public void testComparator() {
  12.         List<Emp> emps = new ArrayList<Emp>();
  13.         emps.add(new Emp("Terry", 25,'m',6000));
  14.         emps.add(new Emp("Allen", 21,'f',4000));
  15.         emps.add(new Emp("Smith", 23,'m',3000));
  16.         Collections.sort(emps, new Comparator<Emp>() {
  17.             @Override
  18.             public int compare(Emp o1, Emp o2) {
  19.                 return o1.salary>o2.salary?1:(o1.salary==o2.salary?0:-1);
  20.             }
  21.         });
  22.         System.out.println(emps);
  23.     }
  24. }

步骤四：运行

运行testComparator方法，控制台输出结果如下所示：

 
  1. [Smith,23,m,3000.0, Allen,21,f,4000.0, Terry,25,m,6000.0]

从运行结果可以看出，已经按照Emp对象的salary属性值升序排列集合emps中的元素。

本案例中，类TestEmpSort的完整代码如下所示：

 
  1. package day04;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.List;
  7. import org.junit.Test;
  9. public class TestEmpSort {
  10.     @Test
  11.     public void testComparator() {
  12.         List<Emp> emps = new ArrayList<Emp>();
  13.         emps.add(new Emp("Terry", 25,'m',6000));
  14.         emps.add(new Emp("Allen", 21,'f',4000));
  15.         emps.add(new Emp("Smith", 23,'m',3000));
  16.         Collections.sort(emps, new Comparator<Emp>() {
  17.             @Override
  18.             public int compare(Emp o1, Emp o2) {
  19.                 return o1.salary>o2.salary?1:(o1.salary==o2.salary?0:-1);
  20.             }
  21.         });
  22.         System.out.println(emps);
  23.     }
  24. }
 

8 简述队列和栈的不同，以及在 Java语言中如何实现这两个数据结构

参考答案

队列与栈的不同点如下：

队列遵循先进先出（FIFO，First Input First Output ）的原则，而栈遵循先进后出（FILO，First Input Last Output ）的原则。

队列和栈在Java语言中的实现如下：

JDK中提供了Queue接口来实现队列这个数据结构，同时使得LinkedList实现了该接口；同时，JDK中还提供了Deque接口来实现栈这个数据结构，而 LinkedList也实现了该接口。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xyk1987/p/8330936.html