在完成对C语言的学习后，我最近开始了对C++和Java的学习，目前跟着视频学习了一些语法，也跟着敲了一些代码，有了一定的掌握程度。现在将跟着视频做的笔记进行整理。本篇博客是整理Java知识点的第十九篇博客。

本篇博客介绍了Java的Set集合。

本系列博客所有Java代码都使用IntelliJ IDEA编译运行，版本为2022.1。所用JDK版本为JDK11。

目录

Set集合

Set集合概述和特点

哈希值

HashSet集合概述和特点

HashSet集合存储学生对象并遍历

LinkedHashSet集合概述和特点

TreeSet集合概述和特点

Comparable

Comparator

成绩排序

不重复的随机数

Set集合

Set集合概述和特点

Set集合不包含重复元素，没有带索引的方法，不能用普通for循环遍历。

可以通过HashSet实现Set，需要导包，import java.util.HashSet

HashSet对集合的迭代顺序不保证。

import java.util.Set;
import java.util.HashSet;
public class settest1 {
 public static void main(String[] args) {
  Set test = ne HashSet();
  test.add("Hello");
  test.add("Java");
  test.add("This is ");
  test.add("set");
  test.add("Java");

  for(String s:test){
   System.out.println(s);
  }
 }
}

程序创建了一个HashSet集合，并使用增强for循环进行遍历。程序的输出是

Java
set
Hello
This is 
顺序与加入集合的顺序不一样。

哈希值

哈希值，是JDK根据对象的地址或数字算出的int类型的数值。

Object类有一个方法可以获取对象的哈希值，即

public int hashCode()，返回对象的哈希值

同一个对象多次调用hashCode方法，返回的值相同。默认情况下不同对象哈希值不同。重写hashCode方法可以实现不同对象哈希值相同。

public class student {
 private String name;
 private int age;
 public student(){}
 public student(String name,int age) {
  this.name = name;
  this.age = age;
 }

 public void setname(String name){
  this.name = name;
 }
 public String getname(){
  return name;
 }
 public void setage(int age){
  this.age = age;
 }
 public int getage(){
  return age;
 }
}

这是下面出现的学生类。

public class hashcode {
 public static void main(String[] args) {
  student s1 = ne student("Opal", 26);
  student s2 = ne student("Olga", 20);
  System.out.println(s1.hashCode());
  System.out.println(s2.hashCode());

  System.out.println("hello".hashCode());
  System.out.println("haha".hashCode());
  System.out.println("hehe".hashCode());

  System.out.println(s1.hashCode());
  System.out.println(s2.hashCode());
 }
}

这段程序获取对象的哈希值并输出。程序的输出是

1784662007
997110508
99162322
3194802
3198650
1784662007
997110508

HashSet集合概述和特点

HashSet的底层数据结构是哈希表，HashSet对集合的迭代顺序不作任何保证，不能用普通for循环进行遍历。不包含重复元素。

HashSet进行添加时，调用对象的hashCode方法获取对象的哈希值，根据哈希值计算出存储位置，该位置没有元素就将元素存入该位置。如果有元素，就遍历该位置所有元素，和新存入的元素比较哈希值，都不相同就将元素存入该位置。有相同就调用equals方法比较对象内容是否相等，结果为false就将元素存入该位置，否则表明元素重复，不进行存储。

import java.util.Set;
import java.util.HashSet;
public class settest2 {
 public static void main(String[] args){
  Set test = ne HashSet();
  test.add("Jebi");
  test.add("Mangkhut");
  test.add("Kong-rey");
  test.add("Yutu");
  for(String s:test){
   System.out.println(s);
  }
 }
}

程序创建了一个HashSet集合，并使用增强for循环进行输出。程序的输出是

Mangkhut
Jebi
Kong-rey
Yutu

HashSet集合存储学生对象并遍历

import java.util.Objects;

public class hashsetstudent {
 private String name;
 private int age;

 public hashsetstudent() {
 }
 public hashsetstudent(String name,int age){
  this.name = name;
  this.age = age;
 }

 public void setname(String name){
  this.name = name;
 }
 public String getname(){
  return name;
 }

 public void setage(int age){
  this.age = age;
 }
 public int getage(){
  return age;
 }

 @Override
 public boolean equals(Object o) {
  if (this == o) return true;
  if (o == null || getClass() != o.getClass()) return false;
  hashsetstudent that = (hashsetstudent) o;
  return age == that.age && name.equals(that.name);
 }

 @Override
 public int hashCode() {
  return Objects.hash(name, age);
 }
}

这是对应的学生类，并重写了equals方法和hashCode方法。

import java.util.Set;
import java.util.HashSet;
public class hashsetstudenttest {
 public static void main(String[] args){
  Set test = ne HashSet();
  hashsetstudent hss1 = ne hashsetstudent("Olaf",25);
  hashsetstudent hss2 = ne hashsetstudent("Odile",17);
  hashsetstudent hss3 = ne hashsetstudent("Otis",24);
  hashsetstudent hss4 = ne hashsetstudent("Olaf",25);

  test.add(hss1);
  test.add(hss2);
  test.add(hss3);
  test.add(hss4);

  for(hashsetstudent hss:test){
   System.out.println("The name is " + hss.getname());
   System.out.println("The age is " + hss.getage());
  }
 }
}

这段代码创建了几个hashsetstudent类对象，并放入集合后进行遍历输出。程序的输出是

The name is Olaf
The age is 25
The name is Odile
The age is 17
The name is Otis
The age is 24

LinkedHashSet集合概述和特点

LinkedHashSet是用哈希表和链表实现的Set接口，具有可预测的迭代次序。元素的存储和取出的顺序一致，并且没有重复元素。

使用LinkedHashSet需要导包，import java.util.LinkedHashSet

import java.util.Set;
import java.util.LinkedHashSet;
public class linkedhashsettest {
 public static void main(String[] args){
  Set test = ne LinkedHashSet();
  test.add("Hello");
  test.add("orld");
  test.add("Java");

  for(String s:test){
   System.out.println(s);
  }
 }
}

程序创建了一个LinkedHashSet，并进行遍历输出。程序的输出是

Hello
orld
Java

TreeSet集合概述和特点

TreeSet集合的元素按照一定的规则排序。具体排序方法取决于构造方法。

TreeSet()按照默认排序进行排序。

TreeSet(Comparator parator)根据指定的比较器进行排序。

使用TreeSet要进行导包，import java.util.TreeSet

TreeSet不能用普通for循环进行遍历，不包含重复元素。

集合存放基本数据类型时，应该放包装类（如用Integer而不是int）。

import java.util.Set;
import java.util.TreeSet;
public class treesettest {
 public static void main(String[] args){
  Set test = ne TreeSet();
  test.add(10);
  test.add(15);
  test.add(20);
  test.add(5);
  test.add(25);

  for(int i:test){
   System.out.println(i);
  }
 }
}

程序创建了一个TreeSet集合test，并加入五个Integer，随后进行遍历输出。程序的输出是

5
10
15
20
25
可见默认是从小到大排序。

Comparable

用TreeSet存储自定义对象时，无参构造方法使用自然排序。自然排序，就是让元素所属的类实现Comparable接口，并重写CompareTo方法。

public class parablestudent implements Comparable{
 private String name;
 private int age;

 public parablestudent(){
 }
 public parablestudent(String name,int age){
  this.name = name;
  this.age = age;
 }

 public void setname(String name){
  this.name = name;
 }
 public String getname(){
  return name;
 }
 public void setage(int age){
  this.age = age;
 }
 public int getage(){
  return age;
 }

 public int pareTo(parablestudent cs) {
  if(this.getage() != cs.getage()){
   return this.getage() - cs.getage();
  }else{
   return this.getname().pareTo(cs.getname());
  }
 }
}

这是学生类，重写了pareTo方法，将当前对象和参数进行比较，先比较年龄，年龄相等再比较姓名。并将结果返回。

import java.util.Set;
import java.util.TreeSet;
public class parabletest {
 public static void main(String[] args){
  Set test = ne TreeSet();
  parablestudent cs1 = ne parablestudent("Peter",19);
  parablestudent cs2 = ne parablestudent("Patricia",19);
  parablestudent cs3 = ne parablestudent("Rene",14);
  parablestudent cs4 = ne parablestudent("Marty",25);
  test.add(cs1);
  test.add(cs2);
  test.add(cs3);
  test.add(cs4);

  for(parablestudent cs:test){
   System.out.println("The name is " + cs.getname());
   System.out.println("The age is " + cs.getage());
  }
 }
}

程序创建了parablestudent类的对象，并加入TreeSet集合，随后进行遍历输出。程序的输出是

The name is Rene
The age is 14
The name is Patricia
The age is 19
The name is Peter
The age is 19
The name is Marty
The age is 25

Comparator

用TreeSet存储自定义对象时，带参构造方法使用比较器排序对元素进行排序。需要让集合构造方法接收Comparator的实现类对象，并重写pare(T o1,T o2)方法。

使用比较器排序需要导包，import java.util.Comparator

public class paratorstudent {
 private String name;
 private int age;

 public paratorstudent(){
 }
 public paratorstudent(String name,int age){
  this.name = name;
  this.age = age;
 }

 public void setname(String name){
  this.name = name;
 }
 public String getname(){
  return name;
 }
 public void setage(int age){
  this.age = age;
 }
 public int getage(){
  return age;
 }
}

这是学生类。

import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
public class paratortest {
 public static void main(String[] args){
  Set test = ne TreeSet(
    ne Comparator(){
     public int pare(paratorstudent csa,paratorstudent csb){
      if(csa.getage() != csb.getage()){
       return csa.getage() - csb.getage();
      }else{
       return csa.getname().pareTo(csb.getname());
      }
     }
    }
  );

  paratorstudent cs1 = ne paratorstudent("Peter",19);
  paratorstudent cs2 = ne paratorstudent("Patricia",19);
  paratorstudent cs3 = ne paratorstudent("Rene",14);
  paratorstudent cs4 = ne paratorstudent("Marty",25);
  test.add(cs1);
  test.add(cs2);
  test.add(cs3);
  test.add(cs4);

  for(paratorstudent cs:test){
   System.out.println("The name is " + cs.getname());
   System.out.println("The age is " + cs.getage());
  }
 }
}

程序的TreeSet使用了一个比较器，用匿名内部类，重写了pare方法，先比较年龄再比较姓名。随后向其中加入四个paratorstudent对象并进行遍历输出。

程序的输出是

The name is Rene
The age is 14
The name is Patricia
The age is 19
The name is Peter
The age is 19
The name is Marty
The age is 25

成绩排序

public class studentscore {
 private String name;
 private int ascore;
 private int bscore;

 public studentscore(){}
 public studentscore(String name,int ascore,int bscore){
  this.name = name;
  this.ascore = ascore;
  this.bscore = bscore;
 }

 public void setname(String name){
  this.name = name;
 }
 public String getname(){
  return name;
 }

 public void setascore(int ascore){
    this.ascore = ascore;
 }
 public int getascore(){
  return ascore;
 }

 public void setbscore(int bscore){
  this.bscore = bscore;
 }
 public int getbscore(){
  return bscore;
 }

 public int getscore(){
  return ascore + bscore;
 }
}

studentscore类的成员变量ascore和bscore代表英语和数学的分数，getscore成员方法返回ascore和bscore的和。

import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
public class studentscoretest {
 public static void main(String[] args) {
  Set test = ne TreeSet(
    ne Comparator() {
     public int pare(studentscore a, studentscore b) {
      if (a.getscore() != b.getscore()) {
       return b.getscore() - a.getscore();
      } else {
       return b.getname().pareTo(a.getname());
      }
     }
    }
  );

  studentscore sc1 = ne studentscore("Nicholas",75,84);
  studentscore sc2 = ne studentscore("Norbert",65,56);
  studentscore sc3 = ne studentscore("Narda",86,73);
  studentscore sc4 = ne studentscore("Nestor",90,97);
  studentscore sc5 = ne studentscore("Nadine",78,84);
  studentscore sc6 = ne studentscore("Norman",85,93);

  test.add(sc1);
  test.add(sc2);
  test.add(sc3);
  test.add(sc4);
  test.add(sc5);
  test.add(sc6);

  for(studentscore sc:test){
   System.out.println("The name is " + sc.getname());
   System.out.println("The score of English is " + sc.getascore());
   System.out.println("The score of Math is " + sc.getbscore());
  }
 }
}

这段代码创建了一个TreeSet，并用比较器规定排序规则是先比较总分后比较姓名，进行降序排序。随后加入几个studentscore类对象并进行遍历输出。程序的输出是

The name is Nestor
The score of English is 90
The score of Math is 97
The name is Norman
The score of English is 85
The score of Math is 93
The name is Nadine
The score of English is 78
The score of Math is 84
The name is Nicholas
The score of English is 75
The score of Math is 84
The name is Narda
The score of English is 86
The score of Math is 73
The name is Norbert
The score of English is 65
The score of Math is 56

不重复的随机数

利用Set的成员不能重复的特性，可以得到不重复元素的集合。

import java.util.Random;
import java.util.Set;
import java.util.HashSet;
public class randomnumber {
 public static void main(String[] args){
  Random r = ne Random();
  int number;

  Set test = ne HashSet();
  hile(test.size()<10){
   number = r.nextInt(20) + 1;
   test.add(number);
  }

  for(int num:test){
   System.out.println(num);
  }
 }
}

这段代码创建了一个HashSet集合test，存储Integer类型数据。随后进入循环，要求元素个数达到10个后退出。循环内每次生成一个1-20的随机数，随后加入集合。由于Set元素的特性，出现相同元素时个数不变，得到10个不相同的数。遍历输出。一次运行的结果是（用空格代替换行）

16 3 4 20 5 9 10 11 14 15