Java笔记（15）泛型与Map集合

1
2
3
4
5
6
7
8
9
10
11
12
	//将泛型指定为String类型
ArrayList<String> list = new ArrayList<String>();
//这时的集合就只能添加String类型元素，添加其他类型编译器就会报错
list.add("a");
list.add("b");
//迭代器的类型也必须和集合返回的迭代器类型相同，否则编译器也会报错
Iterator<String> it = list.iterator();
while(it.hasNext()){
//这时用Integer强转就会编译器报错
Integer i = (Integer) it.next();
}

1
2
3
4
5
6
7
8
//这里的尖括号里可以起任意标识符，建议大写字母，多个泛型用逗号隔开，标识指定的泛型类型
public class Test<E> {
}
//泛型类在实例化时必须指定其具体类型，且不能是基本类型，可以是自定义的类
Test<String> test = new Test<String>();
//注意的是，泛型类不一定非要传入泛型类实参，可以是下面的形式，这种形式不会限定其接收的类型
Test test1 = new Test();

1
2
public Interface Demo<T>{}

1
2
3
4
5
6
7
8
9
10
11
public class MyTest<T> {
private T t;
public void set(T t){
this.t = t;
}
//get方法不算泛型方法，它只是使用了已经定义过的泛型成员
public T get() {
return t;
}
}

1
2
ArrayList<String> list = new ArrayList<String>();

1
2
ArrayList<String> list = new ArrayList<>();

1
2
3
4
public interface Map<K,V> {
// Query Operations
}

1
2
3
4
5
6
7
8
9
10
11
12
13
clear()：删除Map中所有的 key-value对
containsKey()：是否包含指定的key
containsValue(): 是否包含一个或多个value。
entrySet(): 返回包含的 key-value对组成的Set集合，每个集合元素都是Map.Entry对象， Entry是Map的内部类。
get()：返回指定key对应的value。
isEmpty(): 是否为空
keySet(): 返回key组成的Set集合
put(): 添加一个key-value对，如果存在，覆盖以前的
putAll(): 指定Map中复制过来
remove()：删除指定key，或 key-value。
size()：返回键值对个数
values()：返回所有 value组成的 Collection。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//创建HashMap集合
HashMap<String,String> hm = new HashMap<String,String>();
//存放元素
hm.put("0001","李四");
hm.put("0002","张三");
hm.put("0003","王二");
hm.put("0001","李麻花");
//遍历HashMap集合
Set<String> set = hm.keySet();
for(String key : set){
String value = hm.get(key);
System.out.println(key+"---"+value);
}
//结果是
0002---张三
0003---王二
0001---李麻花
可以看到李四被覆盖了，这是由于put方法的源码里针对key值相同的就将value值覆盖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
* 定义一个学生类，有姓名和分数两个属性
*/
public class Student {
private String name;
private int grade;
public Student(String name, int grade) {
super();
this.name = name;
this.grade = grade;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
//测试TreeMap集合
public class MyTest {
public static void main(String[] args) {
// 创建TreeMap集合，并重写排序比较器
TreeMap<Student, String> map = new TreeMap<Student, String>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 按分数高低排序
int num1 = o2.getGrade() - o1.getGrade();
int num2 = num1 == 0 ? o2.getName().compareTo(o1.getName()) : num1;
return num2;
}
});
// 创建6个Student对象
Student s1 = new Student("王一", 99);
Student s2 = new Student("王二", 87);
Student s3 = new Student("王三", 96);
Student s4 = new Student("王四", 98);
Student s5 = new Student("王五", 99);
Student s6 = new Student("王五", 99);
map.put(s1, "高一(2)班");
map.put(s2, "高一(1)班");
map.put(s3, "高一(3)班");
map.put(s4, "高一(2)班");
map.put(s5, "高一(8)班");
map.put(s6, "高一(2)班");
Set<Student> set = map.keySet();
for (Student s : set) {
String str = map.get(s);
System.out.println(s.getName() + "---" + s.getGrade() + "---" + str);
}
}
}
//结果
王一---99---高一(2)班
王五---99---高一(2)班
王四---98---高一(2)班
王三---96---高一(3)班
王二---87---高一(1)班
可以看出，TreeMap既有Map集合的特性key唯一且key相同时后面的覆盖前面的值，也有key排序的功能；