Java 基础学习之类集框架四（Set、SortedSet）

阳光穿透心脏的1/2处 2024-04-17 14:42 22阅读 0赞

# 1. 基本概念 #

1.  Set 接口也属于 Collection 的常用接口，其最大特点是不允许出现重复数据。
2.  Set 接口的定义  
    （1） Set 接口也是 Collection 的子接口，定义：`public interface Set<E> extends Collection<E>`。  
    （2）Set 接口主要方法与 Collection 是一致的，也就是说 Set 接口并没有对 Collection 接口进行扩充，只是比 Collection 接口的要求更加严格，不能增加重复的元素。  
    （3）Set 接口的实例无法像 List 接口那样可以进行双向输出，因为此接口没有提供像 List 接口定义的 get(int index ) 方法。

# 2. Set 接口的常用子类 #

Set 接口中有HashSet（散列存放） 和 TreeSet( 有序存放）两个常用子类，这两个子类在使用时都会有自己的实现要求。

## 2.1 散列存放：HashSet ##

HashSet 是 Set 的一个子类，主要特点是：里面不能存放重复的元素，而且是采用散列的存储方式，所以没有顺序。

##### 实例1代码： #####

package self.learn.setdemo;
    
    import java.util.HashSet;
    import java.util.Set;
    
    public class SetDemo { 
    
    	public static void main(String[] args) { 
    		Set<String> allSet = new HashSet<String>();
    		allSet.add("A");               // 增加元素
    		allSet.add("B");
    		allSet.add("C");
    		allSet.add("C");               // 重复元素，不能加人
    		allSet.add("C");               // 重复元素，不能加人
    		allSet.add("D");
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][20190827160337483.png]  
   从结果中可以看出，对于重复的元素只会增加一次，而且程序运行时向集合中加入元素的顺序并不是集合中的保存顺序，证明 HashSet 类中的元素是无序存放的。

## 2.2 有序的存放：TreeSet ##

如果想对输入的数据进行有序排列，则要使用 TreeSet 子类。TreeSet 类定义如下：

public class TreeSet<E> extends AbstractSet<E>
    implements Sorted<E>,Cloneable,Serializable

TreeSet 类 也是继承了 AbstractSet 类，此类定义如下：

public abstract class AbstractSet<E> extends AbstractCollection<E>
    implements Set<E>

##### 实例2代码： #####

package self.learn.setdemo;
    
    import java.util.Set;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		Set<String> allSet = new TreeSet<String>();
    		allSet.add("D");
    		allSet.add("C");
    		allSet.add("C");               // 重复元素，不能加人
    		allSet.add("C");               // 重复元素，不能加人 
    		allSet.add("A");               // 增加元素
    		allSet.add("B");
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][20190827161421189.png]

## 2.3 关于 TreeSet 的排序说明：自定义类排序 ##

###### 自定义 Person 类 ######

package self.learn.setdemo;
    
    public class Person { 
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	@Override
    	public String toString() { 
    		return "Person [name=" + name + ", age=" + age + "]";
    	}	
    }

package self.learn.setdemo;
    
    import java.util.Set;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		Set<Person> allSet = new TreeSet<Person>(); // 实例 Set 集合类
    		allSet.add(new Person("张三", 30));
    		allSet.add(new Person("李四", 31));
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人 
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人
    		allSet.add(new Person("赵六", 33));
    		allSet.add(new Person("孙七", 33));               // 年龄重复
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]  
   由图可知，出现了类转换异常，存现这样的问题是因为 TreeSet 中的元素是有序存放的，所以对于一个对象必须指定好其排序规则，且 TreeSet 中的每个对象所在类都必须实现 Comparable 接口才可以正常使用。

### person 类指定好排序规则后 ###

package self.learn.setdemo;
    
    public class Person implements Comparable<Person>{              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}	
    	public int compareTo(Person per) {          // 覆写 compareTo() 方法，指定排序规则
    		if(this.age > per.age) {                // 通过年龄排序
    			return 1;
    		}else if (this.age < per.age) { 
    			return -1;
    		}else { 
    			return 0;
    		}
    	}
    }

package self.learn.setdemo;
    
    import java.util.Set;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		Set<Person> allSet = new TreeSet<Person>(); // 实例 Set 集合类
    		allSet.add(new Person("张三", 30));
    		allSet.add(new Person("李四", 31));
    		allSet.add(new Person("王五", 32));              
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人 
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人
    		allSet.add(new Person("赵六", 33));
    		allSet.add(new Person("孙七", 33));               // 年龄重复
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][20190827165631188.png]  
   从程序的运行结果 中可以发现，重复的“王五” 对象只有一个，“赵六”和“孙七” 的数据中姓名并不重复，只有年龄重复了，但是“孙七” 却没有加入到集合中。这是因为采用了比较器造成的，比较器操作的时候如果某个属性没有进行比较的话，则也会认为是同一个对象，所以此时应该将 Person 类中的 compareTo 方法中增加按姓名比较。

### 修改 person 的比较器后 ###

package self.learn.setdemo;
    
    public class Person implements Comparable<Person>{              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}	
    	public int compareTo(Person per) {          // 覆写 compareTo() 方法，指定排序规则
    		if(this.age > per.age) {                // 通过年龄排序
    			return 1;
    		}else if (this.age < per.age) { 
    			return -1;
    		}else { 
    			return this.name.compareTo(per.name); // 增加字符串的比较
    		}
    	}
    }

package self.learn.setdemo;
    
    import java.util.Set;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		Set<Person> allSet = new TreeSet<Person>(); // 实例 Set 集合类
    		allSet.add(new Person("张三", 30));
    		allSet.add(new Person("李四", 31));
    		allSet.add(new Person("王五", 32));              
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人 
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人
    		allSet.add(new Person("赵六", 33));
    		allSet.add(new Person("孙七", 33));               // 年龄重复
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][20190827170240987.png]  
   上面的程序运行结果中“孙七”出现了，而且去掉了重复的内容，但是此时的重复内容并不是真正意义的去掉。因为此时靠的是 Comparable 接口完成的，如果现在换成 HashSet 也会出现重复的内容。所以想要真正的重复内容去掉，必须深入研究 Object 类。

package self.learn.setdemo;
    
    import java.util.HashSet;
    import java.util.Set;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		Set<Person> allSet = new HashSet<Person>(); // 实例 Set 集合类
    		allSet.add(new Person("张三", 30));
    		allSet.add(new Person("李四", 31));
    		allSet.add(new Person("王五", 32));              
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人 
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人
    		allSet.add(new Person("赵六", 33));
    		allSet.add(new Person("孙七", 33));               // 年龄重复
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][20190827171217644.png]  
   从程序的运行结果可以发现，“王五”的内容重复了，也就是说，此时的程序并没有像 Set 接口规定的那样是不允许出现重发元素的。如果此时想要去掉重复的元素，则必须首先进行对象是否重复的判断，要想进行这样的判断则一个类中就必须覆写 Object 类中的 equals()方法，才能完成对象是否相等的判断，但是只覆写 equals()方法是不够的，还需覆写 hashCode() 方法，此方法表示一个哈希码，可以将类中的全部属性进行适当的计算，以求出一个不会重复的哈希码。

### 通过 Object 类去掉重复元素,通过实现 Comparable 接口排序 ###

package self.learn.setdemo;
    
    public class Person implements Comparable<Person> {              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}		
    	public boolean equals(Object obj) {        // 覆写 equals() 方法
    		if(this == obj) {                      // 地址相等
    			return true;                      // 是同一对象
    		}
    		if(!(obj instanceof Person)) {         // 传递进来的不是本类对象
    			return false;                     // 不是同一对象
    		}
    		Person p = (Person)obj;               // 进行向下转型
    		if(this.name.equals(p.name)&&this.age == p.age) {   // 属性依次比较
    			return true;                                   // 全部属性相等，是同一对象
    		}else {                   
    			return true;                                   // 属性不相等，不是同一对象
    		}		
    	}
    	
    	public int hashCode() {           // 覆写 hashCode() 方法
    		return this.name.hashCode()*this.age;  // 指定编码公式
    	}
    	
    	public int compareTo(Person per) {          // 覆写 compareTo() 方法，指定排序规则
    		if(this.age > per.age) {                // 通过年龄排序
    			return 1;
    		}else if (this.age < per.age) { 
    			return -1;
    		}else { 
    			return this.name.compareTo(per.name); // 增加字符串的比较
    		}
    	}
    	
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    }

package self.learn.setdemo;
    
    import java.util.HashSet;
    import java.util.Set;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		//Set<Person> allSet = new TreeSet<Person>(); // 实例 Set 集合类
    		Set<Person> allSet = new HashSet<Person>(); 
    		allSet.add(new Person("张三", 30));
    		allSet.add(new Person("李四", 31));
    		allSet.add(new Person("王五", 32));              
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人 
    		allSet.add(new Person("王五", 32));               // 重复元素，不能加人
    		allSet.add(new Person("赵六", 33));
    		allSet.add(new Person("孙七", 33));               // 年龄重复
    		System.out.println(allSet);    // 输出集合对象，调用 toString()方法
    	}
    }

##### HashSet 子类运行结果截图：没有重复元素 #####

![在这里插入图片描述][20190827200545897.png]

#### TreeSet 子类运行结果截图：没有重复元素 及排序成功 ####

![在这里插入图片描述][20190827200730550.png]

#### 提示： Object 类总结 ####

经过以上的程序代码练习，Object 类中的全部方法就介绍完了，相信读者已经清楚地知道各个方法的作用，在实际的开发中经常会碰到区分同一对象的问题，所以，一个完整的类最好覆写 Object 类的 hashCode()、equals()、toString() 3 个方法。

# 3. SortedSet 接口 #

从 TreeSet 类的定义中可以发现，TreeSet 里实现了 SortedSet 接口，此接口主要是用于排序操作的，即实现此接口的子类都属于排序的子类。SortedSet 接口定义如下：

public interface SortedSet<E> extends Set<E>

SortedSet 接口中定义的方法如下表：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public Comparator&lt;? super E&gt; comparator()</code></td> 
   <td>普通</td> 
   <td>返回与排序有关联的比较器</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public E first()</code></td> 
   <td>普通</td> 
   <td>返回集合中的第一个元素</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public SortedSet&lt;E&gt; headSet(E toElement)</code></td> 
   <td>普通</td> 
   <td>返回从开始到指定的元素的集合</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>public E last()</code></td> 
   <td>普通</td> 
   <td>返回最后一个元素</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>public SortedSet&lt;E&gt; subSet(E fromElement,E toElement)</code></td> 
   <td>普通</td> 
   <td>返回指定对象间的元素</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><code>public SortedSet&lt;E&gt; tailSet(E fromElement)</code></td> 
   <td>普通</td> 
   <td>从指定元素到最后</td> 
  </tr> 
 </tbody> 
</table>

## 3.1 验证 SortedSet 接口 ##

package self.learn.setdemo;
    
    import java.util.SortedSet;
    import java.util.TreeSet;
    public class SetDemo { 
    	public static void main(String[] args) { 
    		SortedSet<String> allSet = new TreeSet<String>(); // 实例 Set 集合类 
    		allSet.add("A");
    		allSet.add("B");
    		allSet.add("C");              
    		allSet.add("C");               // 重复元素，不能加入 
    		allSet.add("C");               // 重复元素，不能加入
    		allSet.add("D");
    		allSet.add("E");               // 年龄重复
    		System.out.println("第一个元素："+allSet.first());    // 输出集合对象，调用 toString()方法
    		System.out.println("第一个元素："+allSet.last());
    		System.out.println("headSet 元素："+allSet.headSet("C"));
    		System.out.println("tailSet 元素："+allSet.tailSet("C"));
    		System.out.println("subSet 元素："+allSet.subSet("A","D"));
    	}
    }

##### 运行结果截图： #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70 1]

[20190827160337483.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/c2a2b18a670c44afbcf6d7460de7c2b4.png
[20190827161421189.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/59e965369c3c4c8e93309690c6feca66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/8d23dbb954d44838888aeba3a7df1d60.png
[20190827165631188.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/9bb249366566483c94e52794eebd6851.png
[20190827170240987.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/8c5c595088b0409493612d7587e688d3.png
[20190827171217644.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/bd3c2918bc2f4fbc8f9b9970d45fdddf.png
[20190827200545897.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/11f3d52faae44898b8cf430f651efc53.png
[20190827200730550.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/c8f3855afbce49dc9643f0dc5cb4dd50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/4fed7c47da84471a940f60441a1b081b.png