Java集合框架-2.【Set】【HashSet】【TreeSet】

最新推荐文章于 2024-04-26 22:19:59 发布

it_shine

最新推荐文章于 2024-04-26 22:19:59 发布

阅读量720

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/mayor125/article/details/39099909

版权

Java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

一、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

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;
       }
}

it_shine

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java集合框架-2.【Set】【HashSet】【TreeSet】

一、Set集合1、特点： ①、元素是无序的(存入和取出的顺序不一定一致)，且元素不可以重复。 ②、Set集合的功能和Collection一致。2、Set集合体系结构：Collection|--Set|--HashSet：底层数据结构是哈希表。|--TreeSet：底层数据结构是二叉树。二、HashSet集合1、特点：①、元素是无序存放的，且
复制链接

扫一扫

专栏目录