第五章泛型&集合

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接口

子接口特点：

List接口：按照顺序存取，元素可以重复，有索引，可使用迭代器、增强for循环、普通for循环遍历
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接口

子类特点：

ArrayList集合：底层是数组结构实现，查询快、增删慢
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接口

子类特点：

HashSet集合：底层由哈希表支撑，元素存取无序，对象添加需要重写hashCode和equals方法
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接口

接口特点：

键值对映射关系
一个键对应一个值，键不可以重复，值可以重复
凡是对象作为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();

	}

}

巴特西

第五章泛型&集合

5.1、泛型

5.2、集合

5.2.1、Collection接口

5.2.2、List接口

5.2.3、Set接口

5.2.4、Map接口

5.3、Collections类

最新文章

热门文章

巴特西

第五章 泛型&集合

5.1、泛型

5.2、集合

5.2.1、Collection接口

5.2.2、List接口

5.2.3、Set接口

5.2.4、Map接口

5.3、Collections类

最新文章

热门文章

第五章泛型&集合