5.1、泛型
概述：泛型是是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
泛型类：
// 格式：修饰符 class 类名<类型> { }
class Generic {
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 g1 = new Generic();
g1.setT("String");
System.out.println(g1.getT());
Generic g2 = new Generic();
g2.setT(100);
System.out.println(g2.getT());
Generic g3 = new Generic();
g3.setT(true);
System.out.println(g3.getT());
}
}
泛型方法：
// 格式：修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
class Generic {
public 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 {
void show(T t);
}
class GenericImpl implements Generic {
@Override
public void show(T t) {
System.out.println(t);
}
}
public class Main {
public static void main(String[] args) {
Generic g1 = new GenericImpl();
g1.show("String");
Generic g2 = new GenericImpl();
g2.show(30);
Generic g3 = new GenericImpl();
g3.show(true);
}
}
类型通配符：
类型通配符：
List：表示元素类型未知的List，它的元素可以匹配任何的类型
类型通配符上限：
List：它表示的类型是Number或者其子类型
类型通配符下限：
List：它表示的类型是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 collection = new ArrayList();
// 添加元素
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 iterator = collection.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// 用增强for循环遍历
for (String s : collection) {
System.out.println(s);
}
// 添加另外集合元素
Collection c = new ArrayList();
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 list = new ArrayList();
// 添加元素
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 listIterator()
ListIterator 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 collection = new HashSet();
// 添加元素
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 collection = new TreeSet(new Comparator() {
@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 map = new HashMap();
// 添加元素
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 m = new HashMap();
m.put("张三", "李四");
m.put("王五", "小六");
map.putAll(m);
System.out.println(map.toString());
// 根据键获取值
System.out.println(map.get("张三"));
// 获取所有键的集合
Set keySet = map.keySet();
// 迭代器遍历
Iterator keysIterator = keySet.iterator();
while (keysIterator.hasNext()) {
System.out.println(keysIterator.next());
}
// 增强for遍历
for (String key : keySet) {
System.out.println(key);
}
// 获取所有值的集合
Collection values = map.values();
// 迭代器遍历
Iterator valuesIterator = values.iterator();
while (valuesIterator.hasNext()) {
System.out.println(valuesIterator.next());
}
// 增强for遍历
for (String value : values) {
System.out.println(value);
}
// 获取所有键值对对象的集合
Set> entrySet = map.entrySet();
// 迭代器遍历
Iterator> entrySetIterator = entrySet.iterator();
while (entrySetIterator.hasNext()) {
Entry entry = entrySetIterator.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ":" + value);
}
// 增强for遍历
for (Entry 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 hm = new HashMap();
// 创建ArrayList，存储编号
ArrayList array = new ArrayList();
// 创建花色数组和点数数组
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 playerSet1 = new TreeSet();
TreeSet playerSet2 = new TreeSet();
TreeSet playerSet3 = new TreeSet();
TreeSet dpSet = new TreeSet();
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 ts, HashMap hm) {
System.out.print(name + ": ");
for (Integer key : ts) {
String poker = hm.get(key);
System.out.print(poker + " ");
}
System.out.println();
}
}