第五章 泛型&集合

5.1、泛型

概述：泛型是是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型类：

// 格式：修饰符 class 类名<类型> { }
class Generic<T> {
	private T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}
}

public class Main {
	public static void main(String[] args) {
		Generic<String> g1 = new Generic<String>();
		g1.setT("String");
		System.out.println(g1.getT());
		Generic<Integer> g2 = new Generic<Integer>();
		g2.setT(100);
		System.out.println(g2.getT());
		Generic<Boolean> g3 = new Generic<Boolean>();
		g3.setT(true);
		System.out.println(g3.getT());
	}
}

泛型方法：

// 格式：修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
class Generic {
	public <T> void show(T t) {
		System.out.println(t);
	}
}

public class Main {
	public static void main(String[] args) {
		Generic g = new Generic();
		g.show("String");
		g.show(100);
		g.show(true);
	}
}

泛型接口：

// 修饰符 interface 接口名<类型> { }
interface Generic<T> {
	void show(T t);
}

class GenericImpl<T> implements Generic<T> {
	@Override
	public void show(T t) {
		System.out.println(t);
	}
}

public class Main {
	public static void main(String[] args) {
		Generic<String> g1 = new GenericImpl<String>();
		g1.show("String");
		Generic<Integer> g2 = new GenericImpl<Integer>();
		g2.show(30);
		Generic<Boolean> g3 = new GenericImpl<Boolean>();
		g3.show(true);
	}
}

类型通配符：

类型通配符：<?>
    List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型

类型通配符上限：<? extends 类型>
    List<? extends Number>：它表示的类型是Number或者其子类型

类型通配符下限：<? super 类型>
    List<? super Number>：它表示的类型是Number或者其父类型

可变参数：

public class Main {
	public static void main(String[] args) {
		System.out.println(sum(10));
		System.out.println(sum(10, 20));
		System.out.println(sum(10, 20, 30));
		System.out.println(sum(10, 20, 30, 40));
		System.out.println(sum(10, 20, 30, 40, 50));
		System.out.println(sum(10, 20, 30, 40, 50, 60));
		System.out.println(sum(10, 20, 30, 40, 50, 60, 70));
		System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80));
		System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80, 90));
		System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80, 90, 100));
	}

	// 格式：修饰符 返回值类型 方法名(数据类型… 变量名) { }
	public static int sum(int... a) {
		int sum = 0;
		for (int i : a) {
			sum += i;
		}
		return sum;
	}
}

5.2、集合

概述：提供一种可变的存储模型，存储的数据容量可以随时发生改变

体系：

5.2.1、Collection接口

子接口特点：

1. List接口：按照顺序存取，元素可以重复，有索引，可使用迭代器、增强for循环、普通for循环遍历
2. Set接口：不按照顺序存取，元素不可以重复，没有索引，可使用迭代器、增强for循环遍历

通用方法：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Main {
	public static void main(String[] args) {
		// 创建集合
		Collection<String> collection = new ArrayList<String>();

		// 添加元素
		collection.add("张三");
		collection.add("张三");
		collection.add("李四");
		collection.add("李四");
		collection.add("王五");
		collection.add("王五");
		System.out.println(collection.toString());

		// 移除元素
		collection.remove("张三");
		System.out.println(collection.toString());

		// 判断元素
		boolean isContains = collection.contains("李四");
		System.out.println(isContains);

		// 判断集合是否为空
		boolean isEmpty = collection.isEmpty();
		System.out.println(isEmpty);

		// 获取集合元素个数
		int size = collection.size();
		System.out.println(size);

		// 用迭代器遍历集合
		Iterator<String> iterator = collection.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}

		// 用增强for循环遍历
		for (String s : collection) {
			System.out.println(s);
		}

		// 添加另外集合元素
		Collection<String> c = new ArrayList<String>();
		c.add("小可爱");
		c.add("大可爱");
		collection.addAll(c);
		System.out.println(collection.toString());

		// 清空集合所有元素
		collection.clear();
		System.out.println(collection.toString());
	}
}

5.2.2、List接口

子类特点：

1. ArrayList集合：底层是数组结构实现，查询快、增删慢
2. LinkedList集合：底层是链表结构实现，查询慢、增删快

通用方法：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Main {
	public static void main(String[] args) {
		// 创建集合
		List<String> list = new ArrayList<String>();

		// 添加元素
		list.add("张三");
		list.add("张三");
		list.add("李四");
		list.add("李四");
		list.add("王五");
		list.add("王五");
		System.out.println(list.toString());

		// List独有方法：E get(int index)
		String s = list.get(0);
		System.out.println(s);

		// List独有方法：E set(int index, E element)
		list.set(2, "xiaoqi");
		System.out.println(list.toString());

		// List独有方法：ListIterator<E> listIterator()
		ListIterator<String> listIterator = list.listIterator();
		// 使用列表迭代器：从前向后迭代
		while (listIterator.hasNext()) {
			System.out.println(listIterator.next());
		}
		// 使用列表迭代器：从后向前迭代
		while (listIterator.hasPrevious()) {
			System.out.println(listIterator.previous());
		}

		// List独有遍历：普通for循环遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

注意事项：

LinkedList集合的特有方法：

方法	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	在该列表末尾追加指定的元素
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

5.2.3、Set接口

子类特点：

1. HashSet集合：底层由哈希表支撑，元素存取无序，对象添加需要重写hashCode和equals方法
2. TreeSet集合：底层由二叉树支撑，元素顺序存取，对象排序需要继承Comparable接口重写compareTo方法、或者使用Comparator初始化

HashSet演示：

import java.util.Collection;
import java.util.HashSet;

class Student {
	private String name;
	private Integer age;

	public Student() {
		super();
	}

	public Student(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

public class Main {
	public static void main(String[] args) {
		// 创建集合
		Collection<Student> collection = new HashSet<Student>();

		// 添加元素
		collection.add(new Student("张三", 20));
		collection.add(new Student("张三", 20));
		collection.add(new Student("李四", 21));
		collection.add(new Student("李四", 21));
		collection.add(new Student("王五", 22));
		collection.add(new Student("王五", 22));
		System.out.println(collection.toString());
	}
}

TreeSet演示：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

import java.util.Collection;
import java.util.Comparator;
import java.util.TreeSet;

class Student {
	private String name;
	private Integer age;

	public Student() {
		super();
	}

	public Student(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

public class Main {
	public static void main(String[] args) {
		// 创建集合
		Collection<Student> collection = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				// 主要条件
				int sort1 = s1.getAge() - s2.getAge();
				// 次要条件
				int sort2 = sort1 == 0 ? s1.getName().compareTo(s2.getName()) : sort1;
				return sort2;
			}
		});

		// 添加元素
		collection.add(new Student("王五", 22));
		collection.add(new Student("王五", 22));
		collection.add(new Student("张三1", 20));
		collection.add(new Student("张三0", 20));
		collection.add(new Student("李四0", 18));
		collection.add(new Student("李四1", 18));
		System.out.println(collection.toString());
	}
}

5.2.4、Map接口

接口特点：

1. 键值对映射关系
2. 一个键对应一个值，键不可以重复，值可以重复
3. 凡是对象作为HashMap的键时，对象添加需要重写hashCode和equals方法

通用方法：

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Main {
	public static void main(String[] args) {
		// 创建集合
		Map<String, String> map = new HashMap<String, String>();

		// 添加元素
		map.put("吕布", "貂蝉");
		map.put("项羽", "虞姬");
		map.put("郭靖", "黄蓉");
		map.put("后裔", "嫦娥");
		System.out.println(map.toString());

		// 删除元素
		map.remove("郭靖");
		System.out.println(map.toString());

		// 判断集合是否包含指定键
		boolean containsKey = map.containsKey("吕布");
		System.out.println(containsKey);

		// 判断集合是否包含指定值
		boolean containsValue = map.containsValue("貂蝉");
		System.out.println(containsValue);

		// 判断集合是否为空
		boolean isEmpty = map.isEmpty();
		System.out.println(isEmpty);

		// 获取集合元素个数
		int size = map.size();
		System.out.println(size);

		// 清空集合所有元素
		map.clear();
		System.out.println(map.toString());

		// 添加另外集合元素
		Map<String, String> m = new HashMap<String, String>();
		m.put("张三", "李四");
		m.put("王五", "小六");
		map.putAll(m);
		System.out.println(map.toString());

		// 根据键获取值
		System.out.println(map.get("张三"));

		// 获取所有键的集合
		Set<String> keySet = map.keySet();
		// 迭代器遍历
		Iterator<String> keysIterator = keySet.iterator();
		while (keysIterator.hasNext()) {
			System.out.println(keysIterator.next());
		}
		// 增强for遍历
		for (String key : keySet) {
			System.out.println(key);
		}

		// 获取所有值的集合
		Collection<String> values = map.values();
		// 迭代器遍历
		Iterator<String> valuesIterator = values.iterator();
		while (valuesIterator.hasNext()) {
			System.out.println(valuesIterator.next());
		}
		// 增强for遍历
		for (String value : values) {
			System.out.println(value);
		}

		// 获取所有键值对对象的集合
		Set<Entry<String, String>> entrySet = map.entrySet();
		// 迭代器遍历
		Iterator<Entry<String, String>> entrySetIterator = entrySet.iterator();
		while (entrySetIterator.hasNext()) {
			Entry<String, String> entry = entrySetIterator.next();
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + ":" + value);
		}
		// 增强for遍历
		for (Entry<String, String> entry : entrySet) {
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + ":" + value);
		}
	}
}

5.3、Collections类

描述：是针对集合操作的工具类

成员方法：

方法	描述
public static void sort(List list)	将指定的列表按升序排序
public static void reverse(List list)	反转指定列表中元素的顺序
public static void shuffle(List list)	使用默认的随机源随机排列指定的列表

示例代码：斗地主洗牌

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Main {
	public static void main(String[] args) {
		// 创建HashMap，键是编号，值是牌面
		HashMap<Integer, String> hm = new HashMap<Integer, String>();
		// 创建ArrayList，存储编号
		ArrayList<Integer> array = new ArrayList<Integer>();
		// 创建花色数组和点数数组
		String[] colors = { "", "", "", "" };
		String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };
		// 从0开始往HashMap里面存储编号并存储对应的牌面，同时往ArrayList里面存储编号
		int index = 0;
		for (String number : numbers) {
			for (String color : colors) {
				hm.put(index, color + number);
				array.add(index);
				index++;
			}
		}
		hm.put(index, "小王");
		array.add(index);
		index++;
		hm.put(index, "大王");
		array.add(index);
		// 洗牌(洗的是编号)
		Collections.shuffle(array);
		// 发牌(发的是编号)
		TreeSet<Integer> playerSet1 = new TreeSet<Integer>();
		TreeSet<Integer> playerSet2 = new TreeSet<Integer>();
		TreeSet<Integer> playerSet3 = new TreeSet<Integer>();
		TreeSet<Integer> dpSet = new TreeSet<Integer>();
		for (int i = 0; i < array.size(); i++) {
			int x = array.get(i);
			if (i >= array.size() - 3) {
				dpSet.add(x);
			} else if (i % 3 == 0) {
				playerSet1.add(x);
			} else if (i % 3 == 1) {
				playerSet2.add(x);
			} else if (i % 3 == 2) {
				playerSet3.add(x);
			}
		}
		// 调用看牌方法
		lookPoker("player1", playerSet1, hm);
		lookPoker("player2", playerSet2, hm);
		lookPoker("player3", playerSet3, hm);
		lookPoker("dp", dpSet, hm);
	}

	/**
	 * 看牌方法
	 * @param name 玩家名称
	 * @param ts   牌面编号
	 * @param hm   牌面集合
	 */
	public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
		System.out.print(name + ": ");
		for (Integer key : ts) {
			String poker = hm.get(key);
			System.out.print(poker + " ");
		}
		System.out.println();
	}
}