Set接口及其实现类、Collections
五.Set集合
java.util.Set
接口和java.util.List
接口一样,同样继承自Collection
接口,它与Collection
接口中的方法基本一致,并没有对Collection
接口进行功能上的扩充,只是比Collection
接口更加严格了。与List
接口不同的是,Set
接口中元素无序,并且都会以某种规则保证存入的元素不出现重复。
六.Set集合的实现类
1.HashSet
1.1概述
java.util.HashSet
是Set
接口的一个实现类,它所存储的元素是不可重复的,并且元素都是无序的(即存取顺序不一致),java.util.HashSet
底层的实现其实是一个java.util.HashMap
支持
HashSet
是根据对象的哈希值来确定元素在集合中的存储位置,因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于:hashCode
与equals
方法。
public class HashSetDemo {
public static void main(String[] args) {
//创建 Set集合
HashSet<String> set = new HashSet<String>();
//添加元素
set.add(new String("cba"));
set.add("abc");
set.add("bac");
set.add("cba");
//遍历
for (String name : set) {
System.out.println(name);
}
/*
cba
abc
bac
*/
}
}
1.2哈希值
测试:
public class HashCodeDemo {
public static void main(String[] args) {
//同一个对象的哈希值是固定的
System.out.println("zhangsan".hashCode());//-1432604556
System.out.println("zhangsan".hashCode());//-1432604556
System.out.println("lisi".hashCode());//3322003
//默认情况下不同对象的哈希值是不同的
//而重写hashcode方法可以让不同对象的哈希值相同
//String重写了hashcode()方法
System.out.println("重地".hashCode());//1179395
System.out.println("通话".hashCode());//1179395
}
}
1.3HashSet集合存储数据的结构(哈希表)
什么是哈希表呢?
在JDK1.8之前,哈希表底层采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而JDK1.8中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。
简单的来说,哈希表是由数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的,如下图所示。
看到这张图就有人要问了,这个是怎么存储的呢?为了方便大家的理解我们结合一个存储流程图来说明一下:
总而言之,JDK1.8引入红黑树大程度优化了HashMap的性能,那么对于我们来讲保证HashSet集合元素的唯一,其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode和equals方法建立属于当前对象的比较方式。
1.4HashSet存储自定义类型元素
给HashSet中存放自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的比较方式,才能保证HashSet集合中的对象唯一。
范例:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class HashSetDemo2 {
public static void main(String[] args) {
//创建集合对象 该集合中存储 Student类型对象
HashSet<Student> stuSet = new HashSet<Student>();
//存储
Student stu = new Student("于谦", 43);
stuSet.add(stu);
stuSet.add(new Student("郭德纲", 44));
stuSet.add(new Student("于谦", 43));
stuSet.add(new Student("郭麒麟", 23));
stuSet.add(stu);
//重写toString方法后
for (Student stu2 : stuSet) {
System.out.println(stu2);
}
}
}
/*
输出:
Student{name='郭德纲', age=44}
Student{name='于谦', age=43}
Student{name='郭麒麟', age=23}
*/
2.LinkedHashSet
我们知道HashSet保证元素唯一,可是元素存放进去是没有顺序的,那么我们要保证有序,怎么办呢?
在HashSet下面有一个子类java.util.LinkedHashSet
,它是链表和哈希表组合的一个数据存储结构。
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<String>();
set.add("bbb");
set.add("aaa");
set.add("abc");
set.add("bbc");
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
/*
bbb
aaa
abc
bbc
* */
}
}
3.TreeSet
Treeset的底层实现是二叉树,可以进行默认排序,也可以自定义排序。自定义排序的时候有两种方式,1实现 Comparable 接口完成排序(重写compareTo()方法),2是实现 Comparator 接口完成排序(重写compare()方法)。
1.特点
2.默认排序
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Integer> ts=new TreeSet<>();
ts.add(10);
ts.add(50);
ts.add(40);
ts.add(30);
ts.add(30);
for (Integer a:ts)
System.out.println(a);
//10
//30
//40
//50
}
}
3.自定义排序
下面是使用TreeSet存储学生对象并按照要求排序的案例,分别通过自然排序和比较器排序的方法实现,二者功能相同。
(1)使用自然排序Comparable
案例:
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Student o) {
// return 0;
// return 1;
// return -1;
//按照年龄升序排序
int num=this.age-o.age;
//降序
// int num=o.age-this.age;
//年龄相同比较name,按字母顺序排序(String实现了compareTo()方法)
int num2 = num==0 ? this.name.compareTo(o.name):num;
return num2;
}
}
public class ComparableTest {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<>();
ts.add(new Student("zhangsan",30));
ts.add(new Student("lisi",25));
ts.add(new Student("wangwu",28));
ts.add(new Student("zhaoliu",40));
ts.add(new Student("haoli",40));
for (Student s:ts)
System.out.println(s.getName()+","+s.getAge());
// 不实现Comparable接口报错:Student cannot be cast to java.lang.Comparable
// 实现后
// lisi,25
// wangwu,28
// zhangsan,30
// haoli,40
// zhaoliu,40
}
}
总结:
(2)使用比较器Comparator
案例:
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
public class ComparatorTest {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
//this.age - s.age
//s1,s2
int num = s1.getAge() -s2.getAge();
int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});
ts.add(new Student("zhangsan",30));
ts.add(new Student("lisi",25));
ts.add(new Student("wangwu",28));
ts.add(new Student("zhaoliu",40));
ts.add(new Student("haoli",40));
for (Student s:ts)
System.out.println(s.getName()+","+s.getAge());
}
}
总结:
(3)TreeSet存储学生对象案例总结
- 自然排序和比较器排序实现的功能,比较规则定义相同
- 自然排序是在学生类中实现Comparable接口,并重写compareTo方法
- 比较器排序是在TreeSet构造方法中传递比较器接口 ,通过实现内部类的compare方法
七. Collections工具类
1. 常用方法
java.utils.Collections
是集合工具类,用来对集合进行操作。部分方法如下:
public static <T> boolean addAll(Collection<T> c, T... elements)
:往集合中添加一些元素。public static void shuffle(List<?> list)
:打乱集合顺序。public static <T> void sort(List<T> list)
:将集合中元素按照默认规则排序。public static <T> void sort(List<T> list,Comparator<? super T> )
:将集合中元素按照指定规则排序。
public class test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
// //原来写法
// list.add(10);
// list.add(30);
// list.add(20);
//采用工具类添加元素
Collections.addAll(list,20,5,90,40);//[20, 5, 90, 40]
Collections.sort(list);//[5, 20, 40, 90]
// Collections.shuffle(list);//随机洗牌
System.out.println(list);
}
}
2. 指定规则的排序
代码演示之后 ,发现我们的集合按照顺序进行了排列,可是这样的顺序是采用默认的顺序,如果想要指定顺序那该怎么办呢?
我们发现还有个方法没有讲,public static <T> void sort(List<T> list,Comparator<? super T> )
:将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。
我们还是先研究这个方法
public static <T> void sort(List<T> list)
:将集合中元素按照默认规则排序。
public class CollectionsDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法
Collections.sort(list);
System.out.println(list);//[aba, cba, nba, sba]
}
}
结果:[aba, cba, nba, sba]
我们使用的是默认的规则完成字符串的排序,那么默认规则是怎么定义出来的呢?
说到排序了,简单的说就是两个对象之间比较大小,那么在JAVA中提供了两种比较实现的方式,一种是比较死板的采用java.lang.Comparable
接口去实现,一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator
接口完成。
那么我们采用的public static <T> void sort(List<T> list)
这个方法完成的排序,实际上要求了被排序的类型需要实现Comparable接口完成比较的功能,在String类型上如下:
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
String类实现了这个接口,并完成了比较规则的定义,但是这样就把这种规则写死了,那比如我想要字符串按照第一个字符降序排列,那么这样就要修改String的源代码,这是不可能的了,那么这个时候我们可以使用
public static <T> void sort(List<T> list,Comparator<? super T> )
方法灵活的完成,这个里面就涉及到了Comparator这个接口,位于位于java.util包下,排序是comparator能实现的功能之一,该接口代表一个比较器,比较器具有可比性!顾名思义就是做排序的,通俗地讲需要比较两个对象谁排在前谁排在后,那么比较的方法就是:
-
public int compare(String o1, String o2)
:比较其两个参数的顺序。两个对象比较的结果有三种:大于,等于,小于。
如果要按照升序排序,
则o1 小于o2,返回(负数),相等返回0,01大于02返回(正数)如果要按照降序排序
则o1 小于o2,返回(正数),相等返回0,01大于02返回(负数)
public class CollectionsDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法 按照第一个单词的降序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.charAt(0) - o1.charAt(0);
}
});
System.out.println(list);//[sba, nba, cba, aba]
}
}
【Java笔记】系列