Table of Contents

Java Collections Class

介紹一些常見的方法，像是： sort 、 max 、 min 等，提供了許多靜態方法運用， Collections Class 是集合框架中的工具類之一，本篇增加了範例，並透過單元測試來驗證產出結果。

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- java_147
       |               +- collection
       |                   +- CollectionsClassTest.java

單元測試

Java Collections 提供檢查排序、最大值、最小值等，操作集合中的元素。

sort

建立一個 ArrayList ，內有三個元素，排序元素。

	@Test
	public void sort() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
		assertThat(list).containsExactly("Mango", "Orange", "Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, -1, 3);
		System.out.println(intList);
		Collections.sort(intList);
		System.out.println(intList);
		assertThat(intList).containsExactly(-1, 3, Integer.MAX_VALUE);
	}

[Orange, Mango, Peach]
[Mango, Orange, Peach]
[2147483647, -1, 3]
[-1, 3, 2147483647]

sortWithComparator

Java Collections 建立一個 ArrayList ，內有三個元素，使用 Comparator 自定義規則，排序元素。

	protected static Comparator<String> nameComparator = new Comparator<String>() {
		@Override
		public int compare(String o1, String o2) {
			return o1.compareTo(o2);
		}
	};

	protected static Comparator<Integer> valueComparator = new Comparator<Integer>() {
		@Override
		public int compare(Integer i1, Integer i2) {
			return Integer.compare(i1, i2);
		}
	};

	@Test
	public void sortWithComparator() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		System.out.println(list);
		Collections.sort(list, nameComparator);
		System.out.println(list);
		assertThat(list).containsExactly("Mango", "Orange", "Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, 3, -1);
		System.out.println(intList);
		Collections.sort(intList, valueComparator);
		System.out.println(intList);
		assertThat(intList).containsExactly(-1, 3, Integer.MAX_VALUE);
	}

[Orange, Mango, Peach]
[Mango, Orange, Peach]
[2147483647, 3, -1]
[-1, 3, 2147483647]

sortWithLambda

Java Collections 建立一個 ArrayList ，內有三個元素，使用 Lambda 自定義規則，排序元素。

	@Test
	public void sortWithLambda() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		System.out.println(list);
		Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
		System.out.println(list);
		assertThat(list).containsExactly("Mango", "Orange", "Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, -1, 3);
		System.out.println(intList);
		Collections.sort(intList, (i1, i2) -> Integer.compare(i1, i2));
		System.out.println(intList);
		assertThat(intList).containsExactly(-1, 3, Integer.MAX_VALUE);
	}

[Orange, Mango, Peach]
[Mango, Orange, Peach]
[2147483647, -1, 3]
[-1, 3, 2147483647]

max

Collections in Java 建立一個 ArrayList ，內有三個元素，取最大元素。

	@Test
	public void max() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		String result = Collections.max(list);
		System.out.println(result);
		assertThat(result).isEqualTo("Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, 3, -1);
		int intResult = Collections.max(intList);
		System.out.println(intResult);
		assertThat(intResult).isEqualTo(Integer.MAX_VALUE);
	}

Peach
2147483647

min

Collections in Java 建立一個 ArrayList ，內有三個元素，取最小元素。

	@Test
	public void min() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		String result = Collections.min(list);
		System.out.println(result);
		assertThat(result).isEqualTo("Mango");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, 3, -1);
		int intResult = Collections.min(intList);
		System.out.println(intResult);
		assertThat(intResult).isEqualTo(-1);
	}

Mango
-1

singletonList

Collections in Java 建立只有一個元素的集合，操作新增、刪除等方法，會拋出例外。

	@Test
	public void singletonList() {
		List<String> list = Collections.singletonList("Orange");
		System.out.println(list);
		assertThat(list).hasSize(1);
		assertThatCode(() -> list.add("Mango")).isInstanceOf(UnsupportedOperationException.class);

		List<Integer> intList = Collections.singletonList(Integer.MAX_VALUE);
		System.out.println(intList);
		assertThat(intList).hasSize(1);
		assertThatCode(() -> intList.add(3)).isInstanceOf(UnsupportedOperationException.class);
	}

[Orange]
[2147483647]

emptyList

Collections in Java 建立空集合，操作新增、刪除等方法，會拋出例外。

	@Test
	public void emptyList() {
		List<String> list = Collections.emptyList();
		System.out.println(list);
		assertThat(list).hasSize(0);
		assertThatCode(() -> list.add("Mango")).isInstanceOf(UnsupportedOperationException.class);

		List<Integer> intList = Collections.emptyList();
		System.out.println(intList);
		assertThat(intList).hasSize(0);
		assertThatCode(() -> intList.add(3)).isInstanceOf(UnsupportedOperationException.class);
	}

[]
[]

CollectionsClassTest.java

Collections in Java 新增單元測試，驗證是否符合預期。

package org.ruoxue.java_147.collection;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

public class CollectionsClassTest {

	@Test
	public void sort() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
		assertThat(list).containsExactly("Mango", "Orange", "Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, -1, 3);
		System.out.println(intList);
		Collections.sort(intList);
		System.out.println(intList);
		assertThat(intList).containsExactly(-1, 3, Integer.MAX_VALUE);
	}

	protected static Comparator<String> nameComparator = new Comparator<String>() {
		@Override
		public int compare(String o1, String o2) {
			return o1.compareTo(o2);
		}
	};

	protected static Comparator<Integer> valueComparator = new Comparator<Integer>() {
		@Override
		public int compare(Integer i1, Integer i2) {
			return Integer.compare(i1, i2);
		}
	};

	@Test
	public void sortWithComparator() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		System.out.println(list);
		Collections.sort(list, nameComparator);
		System.out.println(list);
		assertThat(list).containsExactly("Mango", "Orange", "Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, 3, -1);
		System.out.println(intList);
		Collections.sort(intList, valueComparator);
		System.out.println(intList);
		assertThat(intList).containsExactly(-1, 3, Integer.MAX_VALUE);
	}

	@Test
	public void sortWithLambda() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		System.out.println(list);
		Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
		System.out.println(list);
		assertThat(list).containsExactly("Mango", "Orange", "Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, -1, 3);
		System.out.println(intList);
		Collections.sort(intList, (i1, i2) -> Integer.compare(i1, i2));
		System.out.println(intList);
		assertThat(intList).containsExactly(-1, 3, Integer.MAX_VALUE);
	}

	@Test
	public void max() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		String result = Collections.max(list);
		System.out.println(result);
		assertThat(result).isEqualTo("Peach");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, 3, -1);
		int intResult = Collections.max(intList);
		System.out.println(intResult);
		assertThat(intResult).isEqualTo(Integer.MAX_VALUE);
	}

	@Test
	public void min() {
		List<String> list = Arrays.asList("Orange", "Mango", "Peach");
		String result = Collections.min(list);
		System.out.println(result);
		assertThat(result).isEqualTo("Mango");

		List<Integer> intList = Arrays.asList(Integer.MAX_VALUE, 3, -1);
		int intResult = Collections.min(intList);
		System.out.println(intResult);
		assertThat(intResult).isEqualTo(-1);
	}

	@Test
	public void singletonList() {
		List<String> list = Collections.singletonList("Orange");
		System.out.println(list);
		assertThat(list).hasSize(1);
		assertThatCode(() -> list.add("Mango")).isInstanceOf(UnsupportedOperationException.class);

		List<Integer> intList = Collections.singletonList(Integer.MAX_VALUE);
		System.out.println(intList);
		assertThat(intList).hasSize(1);
		assertThatCode(() -> intList.add(3)).isInstanceOf(UnsupportedOperationException.class);
	}

	@Test
	public void emptyList() {
		List<String> list = Collections.emptyList();
		System.out.println(list);
		assertThat(list).hasSize(0);
		assertThatCode(() -> list.add("Mango")).isInstanceOf(UnsupportedOperationException.class);

		List<Integer> intList = Collections.emptyList();
		System.out.println(intList);
		assertThat(intList).hasSize(0);
		assertThatCode(() -> intList.add(3)).isInstanceOf(UnsupportedOperationException.class);
	}
}