Top

JAVA SE01 Unit04

测试方法addAll、containsAll的用法
使用Iterator的hasNext方法、next方法遍历集合
使用Iterator的remove方法移除元素
使用增强型for循环遍历集合
测试List的get方法和set方法
测试向List中插入和删除元素
测试List的subList方法
将List转换为数组
将数组转换为List
使用Collections.sort方法实现排序
使用Comparator接口实现排序
测试Queue的用法
测试Deque的用法

1 测试方法addAll、containsAll的用法

1.1 问题

测试Collection接口中addAll方法、containsAll方法的用法，详细要求如下：

1）使用ArrayList构建集合c1，将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c1中，并输出集合c1。

2）使用HashSet构建集合c2，将集合c1中的元素添加到集合c2，并输出集合c2。

3）使用ArrayList构建集合c3，将字符串“java”、“cpp”放入集合c3中，并判断集合c1中是否包含集合c3。

1.2 方案

1）首先，使用ArrayList构建集合c1；然后，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c1中；最后，输出集合c1，代码如下所示：

		Collection<String> c1 = new ArrayList<String>();
		c1.add("java");
		c1.add("cpp");
		c1.add("php");
		c1.add("c#");
		c1.add("objective-c");

		System.out.println(c1); // [java, cpp, php, c#, objective-c]

2）首先，使用HashSet构建集合c2；然后，使用Collection接口提供的addAll方法将集合c1中的元素添加到集合c2中，代码如下所示：

Collection<String> c2 = new HashSet<String>();

	c2.addAll(c1);
	System.out.println(c2); // [cpp, php, c#, java, objective-c]

3）首先，使用ArrayList构建集合c3；然后，使用 Collection接口提供的add方法将字符串“java”、“cpp”放入集合c3中；最后，使用Collection接口提供的containsAll方法判断集合c1中是否包含集合c3中的元素，代码如下所示：

		Collection<String> c3 = new ArrayList<String>();
		c3.add("java");
		c3.add("cpp");
		System.out.println(c1.containsAll(c3)); // true

1.3 步骤

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

步骤一：新建类及测试方法

首先，在名为JavaSE的工程下的src下新建名为day04的包，然后，在该包下新建名为TestCollection 的类，并在类中新建测试方法testAddAllAndContainsAll，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
#cold_bold	/**
#cold_bold	 * 测试addAll方法和constainsAll方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testAddAllAndContainsAll() {
#cold_bold	}
}

步骤二：构建集合c1

首先，使用ArrayList构建集合c1；然后，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c1中；最后，输出集合c1，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试addAll方法和containsAll方法
	 */
	@Test
	public void testAddAllAndContainsAll() {
#cold_bold		Collection<String> c1 = new ArrayList<String>();
#cold_bold		c1.add("java");
#cold_bold		c1.add("cpp");
#cold_bold		c1.add("php");
#cold_bold		c1.add("c#");
#cold_bold		c1.add("objective-c");
#cold_bold
#cold_bold		System.out.println(c1); // [java, cpp, php, c#, objective-c]
	}
}

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

[java, cpp, php, c#, objective-c]

从输出结果可以看出，已经将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放到集合c1中。

步骤三：构建结合c2

首先，使用HashSet构建集合c2；然后，使用Collection接口提供的addAll方法将集合c1中的元素添加到集合c2中，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试addAll方法和containsAll方法
	 */
	@Test
	public void testAddAllAndContainsAll() {
		Collection<String> c1 = new ArrayList<String>();
		c1.add("java");
		c1.add("cpp");
		c1.add("php");
		c1.add("c#");
		c1.add("objective-c");

		System.out.println(c1); // [java, cpp, php, c#, objective-c]

#cold_bold		Collection<String> c2 = new HashSet<String>();
#cold_bold
#cold_bold		c2.addAll(c1);
#cold_bold		System.out.println(c2); // [cpp, php, c#, java, objective-c]
	}
}

步骤四：运行

运行testAddAllAndContainsAll方法，运行结果如下所示：

[java, cpp, php, c#, objective-c]
#cold_bold[cpp, php, c#, java, objective-c]

观察输出结果，已经将集合c1中的元素添加到c2中。

步骤五：构建集合c3，使用containsAll判断集合c1是否包含集合c3

首先，使用ArrayList构建集合c3；然后，使用 Collection接口提供的add方法将字符串“java”、“cpp”放入集合c3中；最后，使用Collection接口提供的containsAll方法判断集合c1中是否包含集合c3中的元素，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试addAll方法和containsAll方法
	 */
	@Test
	public void testAddAllAndContainsAll() {
		Collection<String> c1 = new ArrayList<String>();
		c1.add("java");
		c1.add("cpp");
		c1.add("php");
		c1.add("c#");
		c1.add("objective-c");

		System.out.println(c1); // [java, cpp, php, c#, objective-c]

		Collection<String> c2 = new HashSet<String>();

		c2.addAll(c1);
		System.out.println(c2); // [cpp, php, c#, java, objective-c]
#cold_bold		Collection<String> c3 = new ArrayList<String>();
#cold_bold		c3.add("java");
#cold_bold		c3.add("cpp");
#cold_bold		System.out.println(c1.containsAll(c3)); // true
	}
}

步骤六：运行

运行testAddAllAndContainsAll方法，运行结果如下所示：

[java, cpp, php, c#, objective-c]
[cpp, php, c#, java, objective-c]
#cold_boldtrue

观察输出结果，可以看出集合c1是包含集合c3的。

1.4 完整代码

本案例的完整代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import org.junit.Test;

public class TestCollection {
	/**
	 * 测试addAll方法和containsAll方法
	 */
	@Test
	public void testAddAllAndContainsAll() {
		Collection<String> c1 = new ArrayList<String>();
		c1.add("java");
		c1.add("cpp");
		c1.add("php");
		c1.add("c#");
		c1.add("objective-c");

		System.out.println(c1); // [java, cpp, php, c#, objective-c]

		Collection<String> c2 = new HashSet<String>();

		c2.addAll(c1);
		System.out.println(c2); // [cpp, php, c#, java, objective-c]

		Collection<String> c3 = new ArrayList<String>();
		c3.add("java");
		c3.add("cpp");
		System.out.println(c1.containsAll(c3)); // true
	}
}

2 使用Iterator的hasNext方法、next方法遍历集合

2.1 问题

使用Iterator的hasNext方法、next方法遍历集合，详细要求如下：

1）使用HashSet构建集合c，将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中。

2）遍历集合中的每一个元素，并输出。

2.2 方案

1）首先，使用HashSet构建集合c；然后，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中，代码如下所示：

		Collection<String> c = new ArrayList<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

2）使用Collection接口的iterator方法，获取迭代器接口Iterator，代码如下所示：

Iterator<String> it = c.iterator();

3）首先，使用Iterator接口提供的hasNext方法，循环判断集合中是否还有未迭代的元素；然后，在循环中，使用Iterator接口提供的next方法返回当前指针位置的元素，并将指针后移，代码如下所示：

		Iterator<String> it = c.iterator();
		while (it.hasNext()) {
			String str = it.next();
			System.out.println(str);
		}

2.3 步骤

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

步骤一：构建测试方法及构建集合对象c

首先，新建类TestIterator，在该类中新建测试方法testHasNextAndNext；然后，使用HashSet构建集合c；最后，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中，代码如下所示：

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	/**
	 * 测试Iterator的hasNext方法和next方法
	 */
	@Test
	public void testHasNextAndNext() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");
	}
}

步骤二：循环遍历集合c中的元素

首先，使用Iterator接口提供的hasNext方法，循环判断集合中是否还有未迭代的元素；然后，在循环中，使用Iterator接口提供的next方法返回当前指针位置的元素，并将指针后移，代码如下所示：

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	/**
	 * 测试Iterator的hasNext方法和next方法
	 */
	@Test
	public void testHasNextAndNext() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

#cold_bold		Iterator<String> it = c.iterator();
#cold_bold		while (it.hasNext()) {
#cold_bold			String str = it.next();
#cold_bold			System.out.println(str);
#cold_bold		}
	}
}

步骤三：运行

运行testHasNextAndNext方法，控制台输出结果如下：

cpp
php
c#
java
objective-c

查看输出结果，可以看出输出了集合中的每一个元素。

2.4 完整代码

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

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	/**
	 * 测试Iterator的hasNext方法和next方法
	 */
	@Test
	public void testHasNextAndNext() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

		Iterator<String> it = c.iterator();
		while (it.hasNext()) {
			String str = it.next();
			System.out.println(str);
		}
	}
}

3 使用Iterator的remove方法移除元素

3.1 问题

使用Iterator的remove方法移除集合中的元素，详细要求如下：

1）使用HashSet构建集合c，将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中。

2）删除集合c中包含字符“c”的字符串元素。

3.2 方案

		Collection<String> c = new HashSet<String>();
		c.add("java")
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

2）使用Collection接口的iterator方法，获取迭代器接口Iterator，代码如下所示：

Iterator<String> it = c.iterator();

3）首先，使用Iterator接口提供的hasNext方法和next方法遍历到集合c中的每一个元素；然后，在循环中，使用String类的indexOf方法判断遍历到的字符串元素是否包含字符“c”，当indexOf方法返回非-1的其它值时，说明该字符串中包含字符“c”；

最后，使用Iterator接口提供的remove方法将该字符串元素移除，代码如下所示：

		Iterator<String> it = c.iterator();
		while (it.hasNext()) {
			String str = it.next();
			if (str.indexOf('c') != -1) {
				it.remove();
			}
		}

3.3 步骤

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

步骤一：创建测试方法

首先，在 TestIterator类中新建测试方法testRemove；然后，使用HashSet构建集合c；最后，使用 Collection接口提供add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中，代码如下所示：

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
#cold_bold	/**
#cold_bold	 * 测试Iterator的remove方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testRemove() {
#cold_bold		Collection<String> c = new HashSet<String>();
#cold_bold		c.add("java");
#cold_bold		c.add("cpp");
#cold_bold		c.add("php");
#cold_bold		c.add("c#");
#cold_bold		c.add("objective-c");
#cold_bold
#cold_bold		System.out.println(c); // [cpp, php, c#, java, objective-c]
#cold_bold	}
}

步骤二：运行

运行testRemove方法，此时输出集合c中的元素如下：

[cpp, php, c#, java, objective-c]

步骤三：使用Iterator的remove方法移除集合中的元素

首先，使用Iterator接口提供的hasNext方法和next方法遍历到集合c中的每一个元素；然后，在循环中，使用String类的indexOf方法判断遍历到的字符串元素是否包含字符“c”，当indexOf方法返回非-1的其它值时，说明该字符串中包含字符“c”；最后，使用Iterator接口提供的remove方法将该字符串元素移除，代码如下所示：

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	/**
	 * 测试Iterator的remove方法
	 */
	@Test
	public void testRemove() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

		System.out.println(c); // [cpp, php, c#, java, objective-c]

#cold_bold		Iterator<String> it = c.iterator();
#cold_bold		while (it.hasNext()) {
#cold_bold			String str = it.next();
#cold_bold			if (str.indexOf('c') != -1) {
#cold_bold				it.remove();
#cold_bold			}
#cold_bold		}
#cold_bold		System.out.println(c); // [php, java]
	}
}

上述代码中使用了Iterator的remove 方法，该方法使用时，每次next方法调用完之后只能调用一次该方法，该方法删除刚刚next方法返回的元素。在迭代的过程中不能调用集合的remove等方法删除元素，否则会抛出异常ConcurrentModificationException。

步骤四：运行

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

[cpp, php, c#, java, objective-c]
[php, java]

从输出结果可以看出，第二次输出集合c时，集合c中包含字符“c”的元素已经都删除掉。

3.4 完整代码

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

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	//...（之前案例的代码，略）

	/**
	 * 测试Iterator的remove方法
	 */
	@Test
	public void testRemove() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

		System.out.println(c); // [cpp, php, c#, java, objective-c]

		Iterator<String> it = c.iterator();
		while (it.hasNext()) {
			String str = it.next();
			if (str.indexOf('c') != -1) {
				it.remove();
			}
		}
		System.out.println(c); // [php, java]
	}
}

4 使用增强型for循环遍历集合

4.1 问题

使用foreach循环遍历集合中的元素，详细要求如下：

1）使用HashSet构建集合c，将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中。

2）使用foreach循环遍历集合中的每一个元素，并将每一个字符串元素转化为大写形式。

4.2 方案

1）首先，使用HashSet构建集合c；然后，使用 Collection接口提供add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中，代码如下所示：

		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");

2）然后，使用foreach循环遍历集合中的每一个元素，并调用String类的toUpperCase方法将遍历到的字符串元素转化为大写形式，代码如下所示：

for (String str : c) {
			System.out.print(str.toUpperCase() + " ");
		}

以上代码可以理解为每次从集合c中取出一个String对象，然后赋值给循环变量str。事实上，Java编译器在编译前会将其转换为迭代器的形式（因此不能在循环体中对集合进行删除操作）。

4.3 步骤

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

步骤一：添加测试方法

首先，在类TestIterator中新建测试方法testForeach；然后，使用HashSet构建集合c；最后，使用 Collection接口提供的add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c中，代码如下所示：

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
#cold_bold	/**
#cold_bold	 * 测试foreach循环
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testForeach() {
#cold_bold		Collection<String> c = new HashSet<String>();
#cold_bold		c.add("java");
#cold_bold		c.add("cpp");
#cold_bold		c.add("php");
#cold_bold		c.add("c#");
#cold_bold		c.add("objective-c");
#cold_bold	}
}

步骤二：使用foreach循环遍历集合中的元素

使用foreach循环遍历集合中的每一个元素，并调用String类的toUpperCase方法将遍历到的字符串元素转化为大写后输出，代码如下所示：

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	/**
	 * 测试foreach循环
	 */
	@Test
	public void testForeach() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");
#cold_bold		for (String str : c) {
#cold_bold			System.out.print(str.toUpperCase() + " ");
#cold_bold		}
#cold_bold		// CPP PHP C# JAVA OBJECTIVE-C
	}
}

步骤三：运行

运行testForeach方法，控制台输出结果为：

CPP PHP C# JAVA OBJECTIVE-C

从输出结果可以看出已经遍历到了集合中的每一个元素，并将每一个元素转换为大写形式。

4.4 完整代码

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

package day04;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import org.junit.Test;

public class TestIterator {
	//...（之前案例的代码，略）

	/**
	 * 测试foreach循环
	 */
	@Test
	public void testForeach() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("cpp");
		c.add("php");
		c.add("c#");
		c.add("objective-c");
		for (String str : c) {
			System.out.print(str.toUpperCase() + " ");
		}
		// CPP PHP C# JAVA OBJECTIVE-C
	}
}

5 测试List的get方法和set方法

5.1 问题

使用List的set方法和get方法设置和获取集合中的元素，详细要求如下：

1）创建List接口的引用list，使该引用指向ArrayList的实例。

2）将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合list中。

3）使用List接口提供的get方法和size方法遍历集合list，并将每一个字符串元素转换成大写。

4）将索引位置为1的元素替换为c++，并输出被替换掉的元素以及集合list。

5）交换集合list中索引位置为1和索引位置为3的元素。

5.2 方案

1）首先，创建List接口的引用list，使该引用指向ArrayList的实例，并使用add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合list中，代码如下所示：

List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("objective-c");

2）然后，使用List接口提供的get方法、size方法配合循环来遍历集合list，代码如下所示：

for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toUpperCase());
		}

上述代码中使用了get方法，该方法将根据参数索引位置返回对应的对象元素。

3）使用List接口提供的set方法将索引位置为1的元素替换为c++，并输出被替换掉的元素以及集合list，代码如下所示：

String value = list.set(1, "c++");
		System.out.println(value); // cpp
		System.out.println(list); // [java, c++, php, c#, objective-c]

上述代码中使用到set方法，该方法将指定索引位置设置为指定的元素，其返回值为未设置前此位置的元素。

4）使用List接口提供的set方法交换集合list中索引位置为1和索引位置为3的元素，代码如下所示：

list.set(1, list.set(3, list.get(1)));
		System.out.println(list); // [java, c#, php, c++, objective-c]

set方法将指定索引位置设置为指定的元素，其返回值为未设置前此位置的元素。鉴于set方法这样的设计，可以使用此语句实现将list中第i个和第j个元素交换的功能：

list.set(i, list.set(j, list.get(i)));

5.3 步骤

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

步骤一：创建测试方法并构建集合list

首先，新建类TestList，在该类中新建测试方法testGetAndSet；然后，创建List接口的引用list，使该引用指向ArrayList的实例，并使用add方法将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合list中，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试set方法和get方法
	 */
	@Test
	public void testGetAndSet() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("objective-c");
	}
}

步骤二：使用get方法遍历集合list

使用List接口提供的get方法、size方法配合循环来遍历集合list，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试set方法和get方法
	 */
	@Test
	public void testGetAndSet() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("objective-c");

#cold_bold		// get方法遍历List
#cold_bold		for (int i = 0; i < list.size(); i++) {
#cold_bold			System.out.println(list.get(i).toUpperCase());
#cold_bold		}
	}
}

步骤三：运行

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

JAVA
CPP
PHP
C#
OBJECTIVE-C

从输出结果可以看出，遍历到了每一个元素，并转换为大写。

步骤四：使用set方法设置集合元素

使用List接口提供的set方法将索引位置为1的元素替换为c++，并输出被替换掉的元素以及集合list，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试set方法和get方法
	 */
	@Test
	public void testGetAndSet() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("objective-c");

		// get方法遍历List
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toUpperCase());
		}
#cold_bold
#cold_bold		String value = list.set(1, "c++");
#cold_bold		System.out.println(value); // cpp
#cold_bold		System.out.println(list); // [java, c++, php, c#, objective-c]
	}
}

步骤五：运行

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

JAVA
CPP
PHP
C#
OBJECTIVE-C
#cold_boldcpp
#cold_bold[java, c++, php, c#, objective-c]

从输出结果可以看出，将索引位置为1的元素替换为c++，并返回了设置前索引位置为1的元素cpp。

步骤六：使用set方法交换list结合中的两个元素

使用List接口提供的set方法交换集合list中索引位置为1和索引位置为3的元素，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试set方法和get方法
	 */
	@Test
	public void testGetAndSet() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("objective-c");

		// get方法遍历List
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toUpperCase());
		}

		String value = list.set(1, "c++");
		System.out.println(value); // cpp
		System.out.println(list); // [java, c++, php, c#, objective-c]

#cold_bold		// 交换位置1和3上的元素
#cold_bold		list.set(1, list.set(3, list.get(1)));
#cold_bold		System.out.println(list); // [java, c#, php, c++, objective-c]
	}
}

步骤七：运行

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

JAVA
CPP
PHP
C#
OBJECTIVE-C
cpp
[java, c++, php, c#, objective-c]
#cold_bold[java, c#, php, c++, objective-c]

对比两次集合中的输出结果，可以看出已经交换了集合list中索引位置为1和索引位置为3的元素。

5.4 完整代码

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

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试set方法和get方法
	 */
	@Test
	public void testGetAndSet() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("objective-c");

		// get方法遍历List
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toUpperCase());
		}

		String value = list.set(1, "c++");
		System.out.println(value); // cpp
		System.out.println(list); // [java, c++, php, c#, objective-c]

		// 交换位置1和3上的元素
		list.set(1, list.set(3, list.get(1)));
		System.out.println(list); // [java, c#, php, c++, objective-c]
	}
}

6 测试向List中插入和删除元素

6.1 问题

向List集合的指定索引位置插入元素以及移除指定索引位置的元素，详细要求如下：

1）创建List接口的引用list，使该引用指向ArrayList的实例；将字符串“java”、 “c#”放入集合list中。

2）在索引位置为1处，插入字符串元素“cpp”。

3）移除索引位置为2的元素。

6.2 方案

首先，创建List接口的引用list，使该引用指向ArrayList的实例，并使用add方法将字符串“java”、“c#”放入集合list中，代码如下所示：

List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("c#");
System.out.println(list); // [java, c#]

然后，使用List接口的带有索引位置参数的add方法，在索引位置为1处，插入字符串元素“cpp”，代码如下所示：

list.add(1, "cpp");
		System.out.println(list); // [java, cpp, c#]

List重载了带有索引位置参数的add方法，该方法将对象插入集合的指定索引位置（相当于前插，可以理解为对象插入集合后其索引为指定的参数）。

最后，使用List重载的带有索引位置参数的remove方法，移除list集合中索引位置为2的元素，代码如下所示：

list.remove(2);
		System.out.println(list); // [java, cpp]

List也重载了索引位置为参数的remove方法，该方法可以删掉指定索引位置的对象元素，其返回值为刚刚删掉的对象引用。

6.3 步骤

步骤一：构建测试方法

首先，在TestList中新建测试方法testInsertAndRemove；然后，创建List接口的引用list，使该引用指向ArrayList的实例，并使用add方法将字符串“java”、“c#”放入集合list中，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
#cold_bold	/**
#cold_bold	 * 测试插入和移除元素
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testInsertAndRemove() {
#cold_bold		List<String> list = new ArrayList<String>();
#cold_bold		list.add("java");
#cold_bold		list.add("c#");
#cold_bold		System.out.println(list); // [java, c#]
#cold_bold	}
}

步骤二：使用List重载的add方法向集合中插入元素

使用List重载的带有索引位置参数的add方法，在索引位置为1处，插入字符串元素“cpp”，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试插入和移除元素
	 */
	@Test
	public void testInsertAndRemove() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("c#");
		System.out.println(list); // [java, c#]

#cold_bold		list.add(1, "cpp");
#cold_bold		System.out.println(list); // [java, cpp, c#]
	}
}

步骤三：运行

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

[java, c#]
[java, cpp, c#]

从输出结果可以看出，已经将“cpp”插入到集合list中索引位置为1处。

步骤四：使用List重载的remove方法从集合中删除元素

使用List重载的带有索引位置参数的remove方法，移除list集合中索引位置为2的元素，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试插入和移除元素
	 */
	@Test
	public void testInsertAndRemove() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("c#");
		System.out.println(list); // [java, c#]

		list.add(1, "cpp");
		System.out.println(list); // [java, cpp, c#]

#cold_bold		list.remove(2);
#cold_bold		System.out.println(list); // [java, cpp]
	}
}

步骤五：运行

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

[java, c#]
[java, cpp, c#]
#cold_bold[java, cpp]

从输出结果可以看出，已经将索引位置为2的元素“c#”移除掉。

6.4 完整代码

本案例的完整代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	//...（之前案例的代码，略）

	/**
	 * 测试插入和移除元素
	 */
	@Test
	public void testInsertAndRemove() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("c#");
		System.out.println(list); // [java, c#]

		list.add(1, "cpp");
		System.out.println(list); // [java, cpp, c#]

		list.remove(2);
		System.out.println(list); // [java, cpp]
	}
}

7 测试List的subList方法

7.1 问题

使用List接口提供的subList方法获取子List，详细要求如下：

1）创建List接口的引用list，使该引用指向ArrayList的实例；将0~9十个数字作为十个元素放入到集合list中，并输出集合list。

2）获取list集合的子集合subList，subList子集合的元素为[3, 4, 5, 6, 7]并输出子集合subList。

3）将subList集合中的每一个元素扩大10倍，输出list集合和subList集合，验证subList获得的List集合和源List集合占用相同的数据空间。

4）清除list集合中索引位置为3～7（包含3和7）的元素，并输出list。

7.2 方案

1）创建List接口的引用list，使该引用指向ArrayList的实例；将0~9十个数字作为十个元素放入到集合list中，并输出集合list，代码如下所示：

List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}

2）使用List接口的subList方法，获取list集合的子集合subList，subList集合的元素为[3, 4, 5, 6, 7]并输出集合subList，代码如下所示：

		List<Integer> subList = list.subList(3, 8);
		System.out.println(subList); // [3, 4, 5, 6, 7]

subList方法的声明如下：

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

该方法用于获取子List；该方法中fromIndex和toIndex是截取子List的首尾下标（前包括，后不包括）。

3）将subList集合中的每一个元素扩大10倍，输出list集合和subList结合，验证subList获得的List和源List占有相同的数据空间，代码如下所示：

		// subList获得的List和源List占有相同的数据空间
		for (int i = 0; i < subList.size(); i++) {
			subList.set(i, subList.get(i) * 10);
		}
		System.out.println(subList); // [30, 40, 50, 60, 70]
		System.out.println(list); // [0, 1, 2, 30, 40, 50, 60, 70, 8, 9]

List接口提供的subList方法用于获取子List。需要注意的是，subList获取的子List与源List占有相同的存储空间，对子List的操作会影响到源List。

4）使用List接口提供的clear方法清除list集合中索引位置为3～7（包含3和7）的元素，并输出list，代码如下所示：

		// 可以用于删除连续元素
		list.subList(3, 8).clear();
		System.out.println(list);

7.3 步骤

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

步骤一：构建测试方法

首先，在TestList中新建测试方法testSubList；然后，创建List接口的引用list，使该引用指向ArrayList的实例；将0~9十个数字作为十个元素放入到集合list中，并输出集合list，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
#cold_bold	/**
#cold_bold	 * 测试subList方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testSubList() {
#cold_bold		List<Integer> list = new ArrayList<Integer>();
#cold_bold		for (int i = 0; i < 10; i++) {
#cold_bold			list.add(i);
#cold_bold		}
#cold_bold		System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#cold_bold	}
}

步骤二：使用List的subList方法获取子List

使用List接口的subList方法，获取list集合的子集合subList，subList子集合的元素为[3, 4, 5, 6, 7]，并输出集合subList，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试subList方法
	 */
	@Test
	public void testSubList() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}
		System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#cold_bold		List<Integer> subList = list.subList(3, 8);
#cold_bold		System.out.println(subList); // [3, 4, 5, 6, 7]
	}

}

步骤三：运行

运行testSubList方法，控制台输出结果如下：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7]

可以看出获取到了子List，其元素为[3, 4, 5, 6, 7]。

步骤四：验证subList获得的子List和源List占有相同的数据空间

将subList集合中的每一个元素扩大10倍，输出list集合和subList结合，验证subList获得的List和源List占有相同的数据空间，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试subList方法
	 */
	@Test
	public void testSubList() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}
		System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

		List<Integer> subList = list.subList(3, 8);
		System.out.println(subList); // [3, 4, 5, 6, 7]

#cold_bold		// subList获得的List和源List占有相同的数据空间
#cold_bold		for (int i = 0; i < subList.size(); i++) {
#cold_bold			subList.set(i, subList.get(i) * 10);
#cold_bold		}
#cold_bold		System.out.println(subList); // [30, 40, 50, 60, 70]
#cold_bold		System.out.println(list); // [0, 1, 2, 30, 40, 50, 60, 70, 8, 9]
	}
}

步骤五：运行

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

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7]
#cold_bold[30, 40, 50, 60, 70]
#cold_bold[0, 1, 2, 30, 40, 50, 60, 70, 8, 9]

从运行结果可以看出，subList中每一个元素扩大了10倍，list中的索引位置3～7处的元素也扩大了10倍，因此，subList获取的子List与源List占有相同的存储空间，对子List的操作会影响到源List。

步骤六：使用List的clear方法清除List中的某一段元素

使用List接口提供的clear方法清除list集合中索引位置为3～7（包含3和7）的元素，并输出list，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试subList方法
	 */
	@Test
	public void testSubList() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}
		System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

		List<Integer> subList = list.subList(3, 8);
		System.out.println(subList); // [3, 4, 5, 6, 7]

		// subList获得的List和源List占有相同的数据空间
		for (int i = 0; i < subList.size(); i++) {
			subList.set(i, subList.get(i) * 10);
		}
		System.out.println(subList); // [30, 40, 50, 60, 70]
		System.out.println(list); // [0, 1, 2, 30, 40, 50, 60, 70, 8, 9]

#cold_bold		// 可以用于删除连续元素
#cold_bold		list.subList(3, 8).clear();
#cold_bold		System.out.println(list);
	}
}

步骤七：运行

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

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7]
[30, 40, 50, 60, 70]
[0, 1, 2, 30, 40, 50, 60, 70, 8, 9]
#cold_bold[0, 1, 2, 8, 9]

从运行结果可以看出，已经将list集合中索引位置为3～7的元素清除掉。

7.4 完整代码

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

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	//...（之前案例的代码，略）

	/**
	 * 测试subList方法
	 */
	@Test
	public void testSubList() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}
		System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

		List<Integer> subList = list.subList(3, 8);
		System.out.println(subList); // [3, 4, 5, 6, 7]

		// subList获得的List和源List占有相同的数据空间
		for (int i = 0; i < subList.size(); i++) {
			subList.set(i, subList.get(i) * 10);
		}
		System.out.println(subList); // [30, 40, 50, 60, 70]
		System.out.println(list); // [0, 1, 2, 30, 40, 50, 60, 70, 8, 9]

		// 可以用于删除连续元素
		list.subList(3, 8).clear();
		System.out.println(list);
	}
}

8 将List转换为数组

8.1 问题

将集合List转换为数组，详细要求如下所示：

1）创建List接口的引用list，使该引用指向ArrayList的实例；将字符串“a”、“b”、“c”放入集合list中。

2）将集合list转换为数组，并输出数组中的元素。

8.2 方案

首先，创建List接口的引用list，使该引用指向ArrayList的实例；将字符串“a”、“b”、“c”放入集合list中，代码如下所示：

		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");

然后，使用List接口提供的toArray方法将集合list转换为数组，代码如下所示：

String[] strArr = list.toArray(new String[] {});
		System.out.println(Arrays.toString(strArr)); // [a, b, c]

8.3 步骤

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

步骤一：构建测试方法

首先，在TestList中新建测试方法testListToArray；然后，创建List接口的引用list，使该引用指向ArrayList的实例；将字符串“a”、“b”、“c”放入集合list中，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
#cold_bold	/**
#cold_bold	 * 测试toArray方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testListToArray() {
#cold_bold		List<String> list = new ArrayList<String>();
#cold_bold		list.add("a");
#cold_bold		list.add("b");
#cold_bold		list.add("c");
#cold_bold	}
}

步骤二：使用toArray方法将list集合转换为数组

使用List接口提供的toArray方法将集合list转换为数组，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试toArray方法
	 */
	@Test
	public void testListToArray() {
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
#cold_bold		String[] strArr = list.toArray(new String[] {});
#cold_bold		System.out.println(Arrays.toString(strArr)); // [a, b, c]
	}
}

步骤三：运行

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

[a, b, c]

从运行结果看，已经将list转换为数组了，输出的结果为数组中的三个元素。

8.4 完整代码

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

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	//...（之前案例的代码，略）

	/**
	 * 测试toArray方法
	 */
	@Test
	public void testListToArray() {
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");

		String[] strArr = list.toArray(new String[] {});
		System.out.println(Arrays.toString(strArr)); // [a, b, c]
	}
}

9 将数组转换为List

9.1 问题

将数组转换为List集合，详细要求如下所示：

1）构建字符串数组strArr，数组元素为“a”、“b”、“c”。

2）将数组strArr转换为List集合变量list，并输出集合list；然后向list集合中添加元素“d”，运行后查看输出结果。

3）获取变量list所属的类型的名称。

4）构建集合list1，使用List的addAll方法将数组转换来的集合添加到list1中。

9.2 方案

1）首先，构建字符串数组strArr，数组元素为“a”、“b”、“c”；然后，使用工具类Arrays提供的方法asList将数组strArr转换为List集合变量list，并输出集合list,代码如下所示：

String[] strArr = { "a", "b", "c" };
List<String> list = Arrays.asList(strArr);
		System.out.println(list); // [a, b, c]

2）向list集合中添加元素“d”；运行后，将该代码注释，然后获取变量list所属的类型的名称并输出，代码如下所示：

// list.add("d"); // 会抛出UnsupportedOperationException
	   System.out.println(list.getClass().getName()); // java.util.Arrays$ArrayList

3）构建集合list1，使用List的addAll方法将数组转换来的集合添加到list1中，代码如下所示：

List<String> list1 = new ArrayList<String>();
	list1.addAll(Arrays.asList(strArr));

9.3 步骤

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

步骤一：构建测试方法

首先，在类TestList中新建测试方法testArrayToList；然后构建字符串数组strArr，数组元素为“a”、“b”、“c”，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
#cold_bold	/**
#cold_bold	 * 测试asList方法
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testArrayToList() {
#cold_bold		String[] strArr = { "a", "b", "c" };
#cold_bold	}
}

步骤二：使用Arrays的asList方法将数组转换为list

使用Arrays提供的方法asList将数组strArr转换为List集合变量list，并输出集合list，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试asList方法
	 */
	@Test
	public void testArrayToList() {
		String[] strArr = { "a", "b", "c" };

#cold_bold		List<String> list = Arrays.asList(strArr);
#cold_bold		System.out.println(list); // [a, b, c]
	}
}

步骤三：运行

运行testArrayToList方法，控制台输出的结果为：

[a, b, c]

从运行输出的结果可以看出，已经将数组strArr转换为list集合，集合的元素和数组的元素相同，都为[a, b, c]。

步骤四：向集合中添加元素“d”

向list集合中添加元素“d”，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试asList方法
	 */
	@Test
	public void testArrayToList() {
		String[] strArr = { "a", "b", "c" };

		List<String> list = Arrays.asList(strArr);
		System.out.println(list); // [a, b, c]
#cold_bold		list.add("d"); // 会抛出UnsupportedOperationException
	}
}

步骤五：运行

运行testArrayToList方法，会提示发生异常UnsupportedOperationException，如图－1所示。

图- 1

从运行效果上看，说明不支持添加操作。如果list的实际类型是ArrayList，那么应该允许添加操作，因此，要查看一下当前集合list的实际类型。

步骤六：输出list集合的实际类型名称

首先，注释掉向集合list中插入元素“d”的代码；然后，获取集合list的实际类型名称，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试asList方法
	 */
	@Test
	public void testArrayToList() {
		String[] strArr = { "a", "b", "c" };

		List<String> list = Arrays.asList(strArr);
		System.out.println(list); // [a, b, c]
#cold_bold		// list.add("d"); // 会抛出UnsupportedOperationException
#cold_bold		System.out.println(list.getClass().getName()); // java.util.Arrays$ArrayList
	}
}

步骤七：运行

运行testArrayToList方法，控制台输出结果如下：

java.util.Arrays$ArrayList

从输出结果可以看出，当前集合list的实际类型为java.util.Arrays$ArrayList，即为Arrays类的内部类ArrayList，而不是我们之前提到的List接口的实现类java.util.ArrayList。那么，如何正确使用数组转换而来的集合呢。

步骤八：数组转换而来的集合的正确使用方式

数组转换而来的集合的正确使用方式，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	/**
	 * 测试asList方法
	 */
	@Test
	public void testArrayToList() {
		String[] strArr = { "a", "b", "c" };

		List<String> list = Arrays.asList(strArr);
		System.out.println(list); // [a, b, c]
		// list.add("d"); // 会抛出UnsupportedOperationException
		System.out.println(list.getClass().getName()); // java.util.Arrays$ArrayList
#cold_bold
#cold_bold		List<String> list1 = new ArrayList<String>();
#cold_bold		list1.addAll(Arrays.asList(strArr));
	}
}

按照上述的方式，当你向list1中添加元素时，将不再会发生异常。

9.4 完整代码

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

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;

public class TestList {
	//...（之前案例的代码，略）

	/**
	 * 测试asList方法
	 */
	@Test
	public void testArrayToList() {
		String[] strArr = { "a", "b", "c" };

		List<String> list = Arrays.asList(strArr);
		System.out.println(list); // [a, b, c]
		// list.add("d"); // 会抛出UnsupportedOperationException
//java.util.Arrays$ArrayList
		System.out.println(list.getClass().getName());

		List<String> list1 = new ArrayList<String>();
		list1.addAll(Arrays.asList(strArr));
	}
}

10 使用Collections.sort方法实现排序

10.1 问题

使用工具类Collections提供的sort方法实现排序，详细要求如下：

1）创建List接口的引用list，使该引用指向ArrayList的实例；使用1作为随机数生成器的种子，生成10个0~100之间的随机数（包含0不包含100）；将这10个随机数放入list集合中并输出集合元素。

2）按照自然顺序对list集合中的元素进行升序排列并输出排序后的list集合。

10.2 方案

1）首先，创建List接口的引用list，使该引用指向ArrayList的实例；然后，使用java.util包下的Random类来生成随机数，在生成随机数时，使用1作为随机数生成器的种子（保证每次生成的随机数相同），生成10个0~100之间的随机数（包含0不包含100），并将这10个随机数放入list集合中输出，代码如下所示：

List<Integer> list = new ArrayList<Integer>();
		Random r = new Random(1);
		for (int i = 0; i < 10; i++) {
			list.add(r.nextInt(100));
		}
		System.out.println(list); // [85, 88, 47, 13, 54, 4, 34, 6, 78, 48]

2）使用Collections的sort方法，按照自然顺序对list集合中的元素进行升序排列并输出排序后的list集合，代码如下所示：

Collections.sort(list);
		System.out.println(list); // [4, 6, 13, 34, 47, 48, 54, 78, 85, 88]

10.3 步骤

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

步骤一：构建测试方法

首先新建类TestSort，在该类中新建测试方法testSort，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	/**
	 * 测试sort方法
	 */
	@Test
	public void testSort() {
		
	}
}

步骤二：生成10个随机数并加入到集合中

首先，创建List接口的引用list，使该引用指向ArrayList的实例；然后，使用java.util包下的Random类来生成随机数，在生成随机数时，使用1作为随机数生成器的种子（保证每次生成的随机数相同），生成10个0~100之间的随机数（包含0不包含100），并将这10个随机数放入list集合中输出，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	/**
	 * 测试sort方法
	 */
	@Test
	public void testSort() {
#cold_bold		List<Integer> list = new ArrayList<Integer>();
#cold_bold		Random r = new Random(1);
#cold_bold		for (int i = 0; i < 10; i++) {
#cold_bold			list.add(r.nextInt(100));
#cold_bold		}
#cold_bold		System.out.println(list); // [85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
	}
}

步骤三：使用Collections的sort方法对list集合排序

使用Collections的sort方法，按照自然顺序对list集合中的元素进行升序排列并输出排序后的list集合，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	/**
	 * 测试sort方法
	 */
	@Test
	public void testSort() {
		List<Integer> list = new ArrayList<Integer>();
		Random r = new Random(1);
		for (int i = 0; i < 10; i++) {
			list.add(r.nextInt(100));
		}
		System.out.println(list); // [85, 88, 47, 13, 54, 4, 34, 6, 78, 48]

#cold_bold		Collections.sort(list);
#cold_bold		System.out.println(list); // [4, 6, 13, 34, 47, 48, 54, 78, 85, 88]
	}
}

步骤四：运行

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

[85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
[4, 6, 13, 34, 47, 48, 54, 78, 85, 88]

从运行结果可以看出，实现了对list集合中的元素从小到大的排序。

10.4 完整代码

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

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	/**
	 * 测试sort方法
	 */
	@Test
	public void testSort() {
		List<Integer> list = new ArrayList<Integer>();
		Random r = new Random(1);
		for (int i = 0; i < 10; i++) {
			list.add(r.nextInt(100));
		}
		System.out.println(list); // [85, 88, 47, 13, 54, 4, 34, 6, 78, 48]

		Collections.sort(list);
		System.out.println(list); // [4, 6, 13, 34, 47, 48, 54, 78, 85, 88]
	}
}

11 使用Comparator接口实现排序

11.1 问题

使用Comparator接口实现对集合中的元素排序，详细要求如下：

1）使用ArrayList构建集合对象cells，该集合中要求存储Cell类型的数据。

2）分别构造行和列为（2，3）、（5，1）、（3，2）的Cell类对象，并将这三个对象加入到集合cells中。

3）使用Collections类提供的sort方法，按照Cell对象的col值的大小升序排列cells集合中的对象，sort方法的声明如下：

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

11.2 方案

首先，使用ArrayList构建集合对象cells，该集合中要求存储Cell类型的数据。

然后，分别构造行和列为（2，3）、（5，1）、（3，2）的Cell类对象，并将这三个对象加入到集合cells中，代码如下：

		List<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(2, 3));
		cells.add(new Cell(5, 1));
		cells.add(new Cell(3, 2));

最后，使用Collections类提供的sort方法，按照Cell对象的col值的大小升序排列cells集合中的对象。在使用sort方法时，该方法的第二个参数为Comparator接口类型，Comparator接口是比较器接口，实现该接口中的compare方法，给出对象的比较逻辑。下列代码中，给出了Cell对象的比较逻辑：

		Collections.sort(cells, new Comparator<Cell>() {
			@Override
			public int compare(Cell o1, Cell o2) {
				return o1.col - o2.col;
			}
		});

以上代码表示的比较逻辑为按照Cell对象的col值大小比较集合cells中的元素的大小。

11.3 步骤

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

步骤一：构建测试方法

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

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
#cold_bold	/**
#cold_bold	 * 测试Comparator接口
#cold_bold	 */
#cold_bold	@Test
#cold_bold	public void testComparator() {
#cold_bold		List<Cell> cells = new ArrayList<Cell>();
#cold_bold	}
}

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

分别构造行和列为（2，3）、（5，1）、（3，2）的Cell类对象，并将这三个对象加入到集合cells中，代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	/**
	 * 测试Comparator接口
	 */
	@Test
	public void testComparator() {
		List<Cell> cells = new ArrayList<Cell>();
#cold_bold		cells.add(new Cell(2, 3));
#cold_bold		cells.add(new Cell(5, 1));
#cold_bold		cells.add(new Cell(3, 2));
	}
}

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

使用Collections类提供的sort方法，按照Cell对象的col值的大小升序排列cells集合中的对象。代码如下所示：

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	/**
	 * 测试Comparator接口
	 */
	@Test
	public void testComparator() {
		List<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(2, 3));
		cells.add(new Cell(5, 1));
		cells.add(new Cell(3, 2));

#cold_bold		// 按照col值的大小排序
#cold_bold		Collections.sort(cells, new Comparator<Cell>() {
#cold_bold			@Override
#cold_bold			public int compare(Cell o1, Cell o2) {
#cold_bold				return o1.col - o2.col;
#cold_bold			}
#cold_bold		});
#cold_bold		System.out.println(cells); // [(5,1), (3,2), (2,3)]
	}
}

步骤四：运行

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

[(5,1), (3,2), (2,3)]

从运行结果可以看出，已经对集合中的Cell对象按照col升序排列。

11.4 完整代码

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

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import org.junit.Test;

public class TestSort {
	//...（之前案例的代码，略）

	/**
	 * 测试Comparator接口
	 */
	@Test
	public void testComparator() {
		List<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(2, 3));
		cells.add(new Cell(5, 1));
		cells.add(new Cell(3, 2));

		// 按照col值的大小排序
		Collections.sort(cells, new Comparator<Cell>() {
			@Override
			public int compare(Cell o1, Cell o2) {
				return o1.col - o2.col;
			}
		});
		System.out.println(cells); // [(5,1), (3,2), (2,3)]
	}
}

12 测试Queue的用法

12.1 问题

队列（Queue）是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。队列遵循先进先出（FIFO First Input First Output ）的原则。

JDK中提供了Queue接口，同时使得LinkedList实现了该接口（选择LinkedList实现Queue的原因在于Queue经常要进行插入和删除的操作，而LinkedList在这方面效率较高）。

本案例要求测试Queue的用法，详细要求如下：

1）使用LinkedList构建队列，将字符串“a”、“b”、“c”放入队列中。

2）获取队列中队首元素。

3）从队首开始删除元素，直到队列中没有元素为止，并在删除的同时输出删除的队首元素。

12.2 步骤

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

步骤一：构建队列

首先新建类TestQueueAndDeque；然后，在该类中新建测试方法testQueue；最后，使用LinkedList构建队列queue，代码如下所示：

package day04;

import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Queue的用法
	 */
	@Test
	public void testQueue() {
		Queue<String> queue = new LinkedList<String>();
	}
}

步骤二：向队列中添加元素

使用Queue接口提供的offer方法，将字符串“a”、“b”、“c”添加到队列中并输出队列的元素，代码如下所示：

package day04;

import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Queue的用法
	 */
	@Test
	public void testQueue() {
		Queue<String> queue = new LinkedList<String>();
#cold_bold		queue.offer("a");
#cold_bold		queue.offer("b");
#cold_bold		queue.offer("c");
#cold_bold		System.out.println(queue); // [a, b, c]
	}
}

运行testQueue方法,控制台输出结果如下：

[a, b, c]

从输出结果可以看出，已经将字符串“a”、“b”、“c”添加到队列中。

步骤三：查看队首元素

使用Queue接口提供的peek方法，查看队列queue的队首元素并输出队首元素，代码如下所示：

package day04;

import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Queue的用法
	 */
	@Test
	public void testQueue() {
		Queue<String> queue = new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");
		System.out.println(queue); // [a, b, c]

#cold_bold		String str = queue.peek();
#cold_bold		System.out.println(str); // a
	}
}

运行testQueue方法，控制台输出结果为：

从输出结果可以看出，队首元素为a。

步骤四：循环删除队首元素

使用循环。在循环中，从队首开始删除元素，直到队列中没有元素为止，并在删除的同时输出删除的队首元素，代码如下所示：

package day04;

import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Queue的用法
	 */
	@Test
	public void testQueue() {
		Queue<String> queue = new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");
		System.out.println(queue); // [a, b, c]

		String str = queue.peek();
		System.out.println(str); // a

		while (queue.size() > 0) {
			str = queue.poll();
			System.out.print(str + " "); // a b c
		}
	}
}

另外，从上述代码中可以看到使用了Queue接口提供的poll方法删除队首元素。

运行testQueue方法，控制台输出结果为：

a b c

上述输出结果为被删除的队首元素。

12.3 完整代码

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

package day04;

import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Queue的用法
	 */
	@Test
	public void testQueue() {
		Queue<String> queue = new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");
		System.out.println(queue); // [a, b, c]

		String str = queue.peek();
		System.out.println(str); // a

		while (queue.size() > 0) {
			str = queue.poll();
			System.out.print(str + " "); // a b c
		}
	}
}

13 测试Deque的用法

13.1 问题

Deque是Queue的子接口，定义了所谓“双端队列”即从队列的两端分别可以入队（offer）和出队（poll），LinkedList实现了该接口。如果将Deque限制为只能从一端入队和出队，则可实现“栈”（Stack）的数据结构，对于栈而言，入栈称之为push，出栈称之为pop。栈遵循先进后出（FILO First Input Last Output ）的原则。

本案例要求测试Deque的用法，详细要求如下：

1）使用LinkedList构建栈，将字符串“a”、“b”、“c”放入栈中。

2）获取栈中栈顶元素。

3）从栈顶开始删除元素，直到栈中没有元素为止，并在删除的同时输出删除的栈顶元素。

13.2 步骤

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

步骤一：构建队列

首先，在类TestQueueAndDeque中新建测试方法testStack；然后，使用LinkedList构建栈stack，代码如下所示：

package day04;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Stack的用法
	 */
#cold_bold	@Test
#cold_bold	public void testStack() {
#cold_bold		Deque<String> stack = new LinkedList<String>();
#cold_bold	}
}

步骤二：向栈中添加元素

使用Deque接口提供的push方法，将字符串“a”、“b”、“c”添加到栈中并输出栈的元素，代码如下所示：

package day04;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Stack的用法
	 */
	@Test
	public void testStack() {
		Deque<String> stack = new LinkedList<String>();
#cold_bold		stack.push("a");
#cold_bold		stack.push("b");
#cold_bold		stack.push("c");
#cold_bold		System.out.println(stack); // [c, b, a]
	}
}

运行testStack方法,控制台输出结果如下：

[c, b, a]

从输出结果可以看出，已经将字符串“a”、“b”、“c”添加到栈中。

步骤三：查看栈顶元素

使用Deque接口提供的peek方法，查看栈stack的栈顶元素并输出栈顶元素，代码如下所示：

package day04;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Stack的用法
	 */
	@Test
	public void testStack() {
		Deque<String> stack = new LinkedList<String>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		System.out.println(stack); // [c, b, a]

#cold_bold		String str = stack.peek();
#cold_bold		System.out.println(str); // c
	}
}

运行testStack方法，控制台输出结果为：

从输出结果可以看出，栈顶元素为c。

步骤四：循环删除栈顶元素

使用循环。在循环中，从栈顶开始删除元素，直到栈中没有元素为止，并在删除的同时输出删除的栈顶元素，代码如下所示：

package day04;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	/**
	 * 测试Stack的用法
	 */
	@Test
	public void testStack() {
		Deque<String> stack = new LinkedList<String>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		System.out.println(stack); // [c, b, a]

		String str = stack.peek();
		System.out.println(str); // c
#cold_bold
#cold_bold		while (stack.size() > 0) {
#cold_bold			str = stack.pop();
#cold_bold			System.out.print(str + " "); // c b a
#cold_bold		}
	}
}

另外，从上述代码中可以看到使用了Deque接口提供的pop方法使栈顶元素出栈。

运行testStack方法，控制台输出结果为：

c b a

上述输出结果，可以看出栈的特点为先进后出。

13.3 完整代码

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

package day04;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import org.junit.Test;

public class TestQueueAndDeque {
	//...（之前案例的代码，略）

	/**
	 * 测试Stack的用法
	 */
	@Test
	public void testStack() {
		Deque<String> stack = new LinkedList<String>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		System.out.println(stack); // [c, b, a]

		String str = stack.peek();
		System.out.println(str); // c

		while (stack.size() > 0) {
			str = stack.pop();
			System.out.print(str + " "); // c b a
		}

	}
}