关于List、Set、Map接口讲解

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

概述

List、Set接口都是继承于Collection主接口，而Map为独立接口

1、List接口下有ArrayList、Vector、LinkedList实现类

2、Set接口下有HashSet、LinkedHashSet、TreeSet实现类

3、Map下有HashMap、LinkedHashMap、Hashtable、TreeMap实现类

特点

Collection接口：

——List接口有序，可重复

ArrayList

优点: 底层数据结构是数组，查询快，增删慢

缺点: 线程不安全，效率高

LinkedList

优点: 底层数据结构是链表，查询慢，增删快

缺点: 线程不安全，效率高

Vector

优点: 底层数据结构是数组，查询快，增删慢

缺点: 线程安全，效率低

——Set 无序，唯一

HashSet

底层数据结构是哈希表。(无序,唯一)

如何来保证元素唯一性?

答：依赖两个方法：hashCode()和equals()

LinkedHashSet

底层数据结构是链表和哈希表 (FIFO插入有序，且唯一)

原因如下两点：

答：1.由链表保证元素有序

2.由哈希表保证元素唯一

TreeSet

底层数据结构是红黑树。(唯一，且有序)

1. 如何保证元素排序的呢?

答：1.自然排序

2.比较器排序

2.如何保证元素唯一性的呢?

答：根据比较的返回值是否是0来决定

针对于Collection集合我们到底如何使用呢?（重点掌握）

唯一吗?

是：Set

排序吗?

是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

--------------------------------------------------------------------------------------

否：List

要安全吗?

是：Vector
否：ArrayList或者LinkedList

查询多：ArrayList
增删多：LinkedList

如果你知道是List，但是不知道是哪个List，就用ArrayList。如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。

Map接口：

Map接口有三个重要的实现类，分别是 HashMap、LinkedHashMap、Hashtable

1、TreeMap是有序的，HashMap和Hashtable是无序的。

2、Hashtable的方法是同步的，底层源码方法有（synchronized）这是两者主要区别。

这就意味着：

3、Hashtable是线程安全，HashMap是非线程安全。

4、HashMap效率较高，Hashtable效率较低.

重点问题重点分析

(一)、TreeSet，LinkedHashSet and HashSet 的区别

1.介绍

TreeSet，LinkedHashSet and HashSet 在Java中都是实现Set的数据结构

1.TreeSet的主要功能用于排序

2.LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)

3.HashSet只是通用的存储数据的集合

2.相同点

重复元素：因为三者都实现Set interface，所以三者都不包含重复元素.

线程安全：三者都不是线程安全的，如果要使用线程安全可以Collections.synchronizedSet()

3.不同点

性能和速度：HashSet插入数据最快，其次LinkHashSet，最慢的是TreeSet因为内部实现排序。

排序：HashSet不保证有序，LinkHashSet保证FIFO即按插入顺序排序，TreeSet安装内部实现排序，也可以自定义排序规则。

Null：HashSet和LinkHashSet允许存在null数据，但是TreeSet中插入null数据时会报NullPointerException异常。

4.不多说了上代码进行比较！

package com.jia.set;import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;public class SetDemo { public static void main(String args[]) { HashSet<String> hashSet = new HashSet<>();
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
TreeSet<String> treeSet = new TreeSet<>(); for (String data : Arrays.asList("B", "A", "D", "C", "E")) {
hashSet.add(data);
linkedHashSet.add(data);
treeSet.add(data);
} // 不保证有序
System.out.println("HashSet排序 :" + hashSet); // FIFO保证安装插入顺序排序
System.out.println("LinkedHashSet插入顺序排序 :" + linkedHashSet); // 内部实现排序
System.out.println("TreeSet内部排序 :" + treeSet); }}

运行结果：

HashSet排序 :[A, B, C, D, E]
LinkedHashSet插入顺序排序 :[B, A, D, C, E]
TreeSet内部排序 :[A, B, C, D, E]

(二)、TreeSet的两种排序方式比较

1.排序的引入 (以基本数据类型的排序为例)

package com.jia.set;import java.util.TreeSet;public class TreeSetDemo { public static void main(String[] args) { // 创建集合对象
// 自然顺序进行排序
TreeSet<Integer> treeSet = new TreeSet<Integer>(); // 创建元素并添加
// 3,6,9,12,15,18,21,22,30
treeSet.add(3);
treeSet.add(6);
treeSet.add(9);
treeSet.add(12);
treeSet.add(15);
treeSet.add(18);
treeSet.add(21);
treeSet.add(22);
treeSet.add(30); // 遍历结果
for (Integer data : treeSet) {
System.out.println("TreeSet --> "+data);
}
}
}

运行结果：

TreeSet --> 3
TreeSet --> 6
TreeSet --> 9
TreeSet --> 12
TreeSet --> 15
TreeSet --> 18
TreeSet --> 21
TreeSet --> 22
TreeSet --> 30

2.如果是引用数据类型来说，比如自定义对象，又该如何排序呢?

比如创建一个学生类：

package com.jia.set;//学生类
public class Student { private Integer id;
private String name; public Student() {
} public Student(Integer id, String name) {
this.id = id;
this.name = name;
} public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}

测试类：

package com.jia.set;import java.util.TreeSet;public class StudentTreeSetDemo { public static void main(String[] args) { TreeSet<Student> treeSet = new TreeSet<Student>();
//创建元素对象
Student s1=new Student(1,"张三");
Student s2=new Student(2,"李四");
Student s3=new Student(3,"王五");
Student s4=new Student(4,"赵六");
Student s5=new Student(5,"陈七");
Student s6=new Student(6,"杨八"); //将元素对象添加到集合对象中
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
treeSet.add(s6); //遍历结果
for (Student student : treeSet) {
System.out.println(student.getId()+"--->"+student.getName());
}
}
}

结果报错：

Exception in thread "main" java.lang.ClassCastException: com.jia.set.Student cannot be cast to java.lang.Comparable
at java.util.TreeMap.compare(TreeMap.java:1294)
at java.util.TreeMap.put(TreeMap.java:538)
at java.util.TreeSet.add(TreeSet.java:255)
at com.jia.set.StudentTreeSetDemo.main(StudentTreeSetDemo.java:20)
原因分析：
由于不知道该安照那一中排序方式排序，所以会报错。
解决方法：
1.自然排序
2.比较器排序

（1）自然排序

自然排序要进行一下操作：

1.Student类中实现Comparable接口

2.重写Comparable接口中的Comparable()方法

public int compareTo(T o); 比较此对象与指定对象的顺序。

package com.jia.set;//学生类
public class Student implements Comparable<Student> { private Integer id;
private String name; public Student() {
} public Student(Integer id, String name) {
this.id = id;
this.name = name;
} public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
} @Override
public int compareTo(Student s) {
//return -1; //-1表示放在红黑树的左边,即逆序输出
//return 1; //1表示放在红黑树的右边，即顺序输出
//return o; //表示元素相同，仅存放第一个元素
//主要条件姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树
int num = this.name.length()-s.name.length();
//姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
//如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
//如果这两个字符串相等，则结果为 0
int num1 = num==0?this.name.compareTo(s.name):num;
//姓名的长度和内容相同，不代表id值相同，所以还要判断id
int num2=num1==0?this.id-s.id:num1;
return num2;
}
}

运行结果：

1--->张三
2--->李四
6--->杨八
3--->王五
4--->赵六
5--->陈七

（2）比较器排序

步骤：1.单独创建一个比较类，以ComparatorTest为例，并且让其继承Comparator接口

2.重写Comparable接口中的Comparable()方法

compare(T o1,T o2) 比较用来排序的两个参数。

TreeSet(Comparator<? superE> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。

创建比较类ComparatorTest:

package com.jia.set;import java.util.Comparator;public class ComparatorTest implements Comparator<Student> { @Override
public int compare(Student s1,Student s2) {
// 姓名长度
int num = s1.getName().length() - s2.getName().length();
// 姓名内容
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
// id值
int num3 = num2 == 0 ? s1.getId() - s2.getId() : num2; return num3;
}
}

学生类：

package com.jia.set;//学生类
public class Student { private Integer id;
private String name; public Student() {
super();
} public Student(Integer id, String name) {
this.id = id;
this.name = name;
} public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}}

测试类：

package com.jia.set;import java.util.TreeSet;public class StudentTreeSetDemo { public static void main(String[] args) { TreeSet<Student> treeSet = new TreeSet<Student>(new ComparatorTest());
//创建元素对象
Student s1=new Student(1,"张三");
Student s2=new Student(2,"李四");
Student s3=new Student(3,"王五");
Student s4=new Student(4,"赵六");
Student s5=new Student(5,"陈七");
Student s6=new Student(6,"杨八"); //将元素对象添加到集合对象中
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
treeSet.add(s6); //遍历结果
for (Student student : treeSet) {
System.out.println(student.getId()+"--->"+student.getName());
}
}
}