一、Set集合
1、特点：
①、元素是无序的(存入和取出的顺序不一定一致)，且元素不可以重复。
②、Set集合的功能和Collection一致。
2、Set集合体系结构：
Collection
|--Set
|--HashSet：底层数据结构是哈希表。
|--TreeSet：底层数据结构是二叉树。
二、HashSet集合
1、特点：
①、元素是无序存放的，且元素不可以重复。
②、底层的数据结构是哈希表。
HashSet的无序验证：
class HashSetDemo
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add("java01");
hs.add("java01"); //重复元素。
hs.add("java02");
hs.add("java03");
hs.add("java03"); //重复元素。
hs.add("java04");
Iterator it = hs.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
输出结果为：java04
java02
java03
java01
从结果可以看出HashSet中元素是不能重复且是无序存放的。保证了集合中元素的唯一性。
2、哈希表：存放哈希值的表。
可以通过Object类中的hashCode()方法来算出对象的哈希值。
class Demo{ }
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Demo d1 = new Demo();
Demo d2 = new Demo();
sop(d1.toString()+"..."+d1.hashCode()); //Demo@5e1077...6164599
sop(d2.toString()+"..."+d2.hashCode()); //Demo@18b3364...25899876
}
}
3、HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法：hashCode()方法和equals()方法来完成。
如果元素的hashCode值相同，才会判断equals是否为true，判断元素的内容。
如果元素的hashCode值不同，则不会调用equals，视为两个不同的元素。
注意：对于自定义的对象，只覆写equals()方法或者只hashCode()方法是无法保证集合中元素唯一性的。
代码示例：
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
/*
public int hashCode()
{
System.out.println(this.name+"......hashCode");
return name.hashCode()+age*23; //为了保证hashCode的唯一性。
}
*/
public boolean equals(Object obj) //覆写了equals方法。
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"...equals..."+p.name);
return this.name.equals(p.name)&& this.age == p.age; //比较姓名和年龄。
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class HashSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(newPerson("a1",11));
hs.add(newPerson("a2",12));
hs.add(newPerson("a3",13));
hs.add(newPerson("a2",12)); //重复的姓名和年龄信息。
hs.add(newPerson("a4",14));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"......"+p.getAge());
}
}
}
输出结果：
a1......11
a3......13
a2......12
a2......12
a4......14
可以发现输出结果中出现了重复的元素。
原因：因为此例中每一个添加进去的元素都是一个个不同的对象，它们的内存地址值是不一样的，即使元素内容相同，却也无法保证是同一个元素。
或者将上面例子中的equals方法注释，只使用hashCode方法比较的话，输出结果也是会出现重复。
输出结果：
a1......hashCode
a2......hashCode
a3......hashCode
a2......hashCode
a4......hashCode
a1......11
a2......12
a2......12
a3......13
a4......14
原因：虽然保证了集合中每个元素的hashCode值是唯一的，但是不能保证元素的内容是一致的，所以就会出现重复的输出结果。
当自定义对象所在类中既覆写了equals方法又覆写了hashCode方法，从输出的结果中可以发现每增加一个元素就会计算该元素的hashCode值，如果hashCode值一致，则会使用equals方法比较元素的内容是否相同，如果相同则表明是同一个元素，就不会存入到集合中去。
输出结果：
a1......hashCode
a2......hashCode
a3......hashCode
a2......hashCode
a2...equals...a2
a4......hashCode
a1......11
a2......12
a3......13
a4......14
4、hashCode的现实生活举例：
现实生活中人们的身份证号码，是唯一的，相当于使用了hashCode方法。并且当进行实名制买火车票的时候，验票口还会核对姓名等信息，相当于使用了equals方法。如果核对通过，表示个人信息是正确无误的。
5、开发中建议：
现实开发中建议一个完整的类最好覆写Object类中的toString()、equals()、hashCode()等方法。
6、HashSet和ArrayList判断和删除元素的依据：
HashSet：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
先依赖hashCode方法，再依赖equals方法。
ArrayList：只依赖equals方法。
代码示例：
import java.util.*;
class HashSetTest2
{
public static void sop(Objectobj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(newPerson("a1",11));
hs.add(newPerson("a2",12));
hs.add(newPerson("a3",13));
sop(hs.contains(new Person("a1",11))); //true
//sop(hs.remove(new Person("a2",12))); //true
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"......"+p.getAge());
}
}
}
输出结果：
a1......hashCode
a2......hashCode
a3......hashCode
a1......hashCode //先以来hashCode方法。
a1...equals...a1 //再依赖equals方法。
true
a1......11
a2......12
a3......13
三、TreeSet集合
1、特点：
①、可以对Set集合中的元素进行排序。
②、底层的数据结构是二叉树。
验证TreeSet集合的有序性：
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add("cba");
ts.add("abcd");
ts.add("aaa");
ts.add("bca");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
输出结果：
aaa
abcd
bca
cba
从输出的结果中可以发现元素是按照“自然顺序”的方式进行有序存放的。
2、TreeSet存储自定义对象的问题：
代码示例：
import java.util.*;
class TreeSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(newStudent("lisi02",22));
ts.add(newStudent("lisi007",20));
ts.add(newStudent("lisi09",19));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName()+"..."+stu.getAge());
}
}
}
class Student
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
运行结果会出现ClassCastException异常。
①、异常原因：因为TreeSet集合是有序的，会对存入的元素进行自然排序。但是普通的自定义类没不具备排序的功能，所以就抛出ClassCastException异常。
②、处理方式：让自定义类实现Comparable接口，强制让实现该接口的对象元素进行排序。这种排序方式成为：自然排序。
然后只需要在自定义类中覆写Comparable接口中的compareTo()方法就可以了。
int compareTo(T o)
compareTo方法的理解：
o表示要比较的对象，即参数对象。可以表示任何类型的对象。
返回结果：是int型的数值。如果该对象大于、等于、或者小于要比较的对象，则返回结果有负整数、零、正整数，即小于0，等于0，大于0。
③、解决示例：
import java.util.*;
class TreeSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable //该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj) //覆写Comparable接口中的compareTo方法。
{
if(!(obj instanceof Student))
throw new RuntimeException("不是学生类的对象");
Student s = (Student)obj;
System.out.println(this.name+"...compareTo..."+s.name);
if(this.age>s.age) //当前对象大于指定对象就返回一个正整数的值。
return 1;
if(this.age==s.age) //当前对象等于指定对象就返回0。
return 0;
return -1; //当前对象小于指定对象就返回一个负整数的值。
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
运行结果是：
lisi02...compareTo...lisi02
lisi007...compareTo...lisi02
lisi09...compareTo...lisi02
lisi09...compareTo...lisi007
lisi09...19
lisi007...20
lisi02...22
结果分析：当lisi02传进集合中后，lisi02这个对象调用自己的compareTo方法和自己比较了一下；当lisi007这个对象传进集合中后，lisi007就调用自己的compareTo方法和lisi02这个对象进行比较；当lisi09这个对象传入集合之后，lisi09这个对象就调用自己的compareTo方法和lisi02、lisi007这两个对象分别进行了一次比较，以此类推。
另一种问题：当存入的对象中出现比较的属性数值相同，但其它未比较的属性不相同时，元素没有成功存入集合的情况。
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19)); //存入的学生姓名不同，但是年龄相同。被认为是同一个学生对象。
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName()+"..."+stu.getAge());
}
}
输出结果是：
lisi02...compareTo...lisi02
lisi007...compareTo...lisi02
lisi09...compareTo...lisi02
lisi09...compareTo...lisi007
lisi08...compareTo...lisi007
lisi08...compareTo...lisi09
lisi09...19
lisi007...20
lisi02...22
发现lisi08这个对象元素没有被存入集合中，被认为是重复的元素。
问题原因：因为学生类中被覆写的compareTo方法中只判断比较了age属性，没有判断学生对象的name属性造成的。
处理方式：当主要条件相同时，一定要比较一下次要条件。当次要条件也相同，则表示是同一个对象元素。
修改Student类中被覆写的compareTo方法：
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("不是学生类的对象");
Student s = (Student)obj;
System.out.println(this.name+"...compareTo..."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name); //比较次要判断条件。
}
return -1;
}
3、TreeSet底层数据结构—— 二叉树
对象元素：
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi11",40));
ts.add(new Student("lisi16",30));
ts.add(new Student("lisi12",36));
ts.add(new Student("lisi10",29));
ts.add(new Student("lisi22",90));
图例：
4、TreeSet集合判断和删除元素的依据：
TreeSet集合保证元素唯一性的依据是：compareTo方法是return 0。和equals、hashCode方法没关系。
5、TreeSet集合的排序方式：
两种方式：
第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。
第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
6、自定义比较器
①、应用：实现TreeSet集合的第二种排序方式。
②、作用：可以按照需求来自定义需要比较的内容，以达到排序方式。
③、实现方式：
定义一个类，实现Comparator接口，并覆写compare方法。
然后将自定义的比较器做为参数传递给TreeSet集合的构造函数。
示例代码：
import java.util.*;
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi06",18));
ts.add(new Student("lisi007",29));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName()+"..."+stu.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num =s1.getName().compareTo(s2.getName());
if(num==0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
/*
if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()==s2.getAge())
return 0;
return -1;
*/
}
return num;
}
}