文章目录
JAVA——Set集合
集合继承关系一览图：
Set集合概述及特点
- Set集合概述及特点：（通过API查看即可）
a. 元素唯一 - Set集合的三个子类实现：
a. HashSet
b. LinkedHashSet
c. TreeSet
HashSet:
-
特点：
a. 底层数据结构是Hash表(数组+链表 JDK1.7 数组+链表+二叉树 JDK1.8)
b. HashSet 不是线程安全的 .
c. 集合元素可以是 null.
d. 元素无重复且无序！ -
哈希表：是一个元素为链表的数组,综合了数组和链表的优点 (像新华字典一样) (JDK1.7之前)
-
HashSet 如何保证元素唯一性？
a. 元素的唯一性是靠元素重写hashCode()和equals()方法来保证的，如果不重写这两个方法，则无法保证唯一性！(需要注意的是：很多非自定义类已经重写过了相关的方法，比如：Integer或String等)
b. 存储方法：先通过调用每个对象的hashCode()方法来得到一个数值（作为在hash表格中存储的索引号），然后如果存在同样的序号，则在该序号下使用链式存储数据，此时会根据对象的equals()方法进行对比，如果equals()返回为：true，则不进行存储。
c.（问题：那如果相同数值的对象算出来的hashCode()不一样，有可能会导致重复吗？应该有相应的机制来避免这种情况：这只是老师上课的阐述方式，具体过程需要查看源码来解决！）
d. hashCode()的作用：将16进制的地址值转变为一个整数(不同对象的hashCode()的数值是不同的！)，在HashSet中的作用：减少在Hash数据表结构中的碰撞（由于：hashCode()返回的数值相同，导致在同一个序号下进行：链式存储。会导致：查询和添加的效率变得底下！） -
问题：同一个父类的不同子类中初始化出来的父类对象是同一个吗？其hashCode()返回的数值是相同的吗？
回答：不是同一个，hashCode()的返回值不同，通过调用父类的super.hashCode()得到此结论！ -
HashSet存储自定义对象保证元素唯一性图解：
-
无序性和无重复性的示例：
public class MyTest { public static void main(String[] args) { //List:元素有序，允许重复元素 //Set:元素唯一 //HashSet LinkedHashSet TreeSet //HashSet:顶层数据结构是哈希表（数组+链表 JDK1.7 数组+链表+二叉树 JDK1.8） //HashSet 元素唯一，且无序（存取顺序不一致） HashSet<String> set = new HashSet<>(); set.add("张曼玉"); set.add("张曼玉"); set.add("王祖贤"); set.add("钟楚红"); set.add("林青霞"); set.add("杨超越"); set.add("张曼玉"); set.add("王祖贤"); set.add("钟楚红"); set.add("林青霞"); set.add("杨超越"); for (String s : set) { System.out.println(s); } } } ---------- 输出： 林青霞 杨超越 王祖贤 钟楚红 张曼玉 -
自定义对象的唯一性和无序性示例：
（注意：如果没有合理的去重写hashCode方法，就导致碰撞次数过多，以及形成的链表过长，会降低插入数据和读写数据的性能！)
a. 自定义学生类：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 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); } }b. 主方法函数：
public class MyTest3 { public static void main(String[] args) { //HashSet 底层数据结构是哈希表，元素无序，且唯一，元素的唯一性是靠 元素重写hashCode()和equals方法来保证的。如果元素不重写hashCode() 和 equals方法，则无法保证唯一性。 //HashSet 集合 底层用HashMap 来存的 HashSet<Student> set = new HashSet<>(); set.add(new Student("杨超越",20)); set.add(new Student("杨幂", 22)); set.add(new Student("杨紫", 20)); set.add(new Student("杨洋洋", 20)); set.add(new Student("杨超越", 20)); //重复数据 set.add(new Student("杨幂", 22)); //重复数据 set.add(new Student("杨紫", 20)); //重复数据 set.add(new Student("杨洋洋", 20)); //重复数据 for (Student student : set) { System.out.println(student.getName()+"==="+student.getAge()); } } } ------------- 输出： 杨紫===20 杨幂===22 杨洋洋===20 杨超越===20
LinkedHashSet的概述和使用
- 概述：LinkedHashSet 底层数据结构是链表和哈希表，元素唯一，且有序（存取顺序一致）链表保证了有序性，哈希表保证了唯一性。
- 示例：(有序性和唯一性)
public class MyTest { public static void main(String[] args) { // LinkedHashSet 底层数据结构是链表和哈希表，元素唯一，且有序（存取顺序一致）链表保证了有效，哈希表保证了唯一 LinkedHashSet<String> set = new LinkedHashSet<>(); set.add("张曼玉"); set.add("王祖贤"); set.add("钟楚红"); set.add("林青霞"); set.add("杨超越"); set.add("张曼玉"); set.add("王祖贤"); set.add("钟楚红"); set.add("林青霞"); set.add("杨超越"); for (String s : set) { System.out.println(s); } } } ---------- 输出： 张曼玉 王祖贤 钟楚红 林青霞 杨超越 - 示例：（利用LinkedHashSet 使用有参构造对ArrayList 的元素进行去重）
注意：(其他的set子类也可以达到此效果，只不过各有各的特性而已！）
public class MyTest {
public static void main(String[] args) {
ArrayList<String> strings = new ArrayList<>();
strings.add("aaa");
strings.add("bbb");
strings.add("ccc");
strings.add("ddd");
strings.add("aaa");
strings.add("bbb");
strings.add("ccc");
strings.add("ddd");
//使用有参构造，对List 集合去重
LinkedHashSet<String> strings1 = new LinkedHashSet<>(strings); //核心代码！
System.out.println(strings1);
}
}
--------------
输出：
[aaa, bbb, ccc, ddd]
TreeSet的概述和使用：
- 概述：层数据结构是二叉树，元素唯一且有排序。
- 特点：
a. 是能够对元素进行排序！
b. （存储进去的时候就已经有序了：被自动排序了。这个顺序和LinkedHashSet是不一样的，LinkedHashSet是按照加入顺序来存储的！） - 问题：对于非数字元素的排序有意义吗？回答：当然有意义，对于自定义的对象进行排序，是非常有用的，不仅仅是数组才能比较大小，自定义对象也可以根据自定义的逻辑比较大小。
- 存储结构(存储方法)
- TreeSet集合能够对元素进行排序的方式分两种：
a. 自然排序：自然排序，你使用的是无参构造，自然排序，对排的元素有要求，要求是：元素必须实现一个Comparable接口，重写该接口中的compareTo()方法，根据此方法，返回的“正，负，0”来决定元素在二叉树中的左右位置，返回0就不往里面放。
示例1：（按照名字长度作为主要顺序，年龄作为次要顺序！）
注意：
a. compateTo返回负数：放在左边。返回正数：放在右边。返回0：则不进行存储。
b. 对TreeSet进行遍历的时候，默认顺序是：左中右（即：从小到大）
c. 所以：如果想反向遍历一个TreeSet的话，只能在存储的时候，将其return的数值加负号，改变其存储的结构！
示例2：（按照年龄作为主顺序，名字长度作为次要顺序）------------（自定义类：） 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 void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int compareTo(Student o) { // 按照名字长度来进行排序： int num = this.name.length()>o.name.length()?1:(this.name.length()==o.name.length()?0:-1); // int num = this.name.length() - o.name.length(); 简单写法 //这里还考虑一个问题：是否名字的内容相同？ num = num==0?this.name.compareTo(o.name):num; //如果名字长度相同，则按照年龄来进行排序： int num2 = num==0?(this.age>o.age?1:(this.age==o.age?0:-1)):num; return num2; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } ------------(主类) public class MyTest2{ public static void main(String[] args) { //存储学生对象，按照学生得年龄大小来排序 //TreeSet 集合 能够对元素进行排序，排序方式，分两种 //一种是自然排序：自然排序，你使用得是无参构造，自然排序，对排序得元素有要求，要求，元素必须实现一个 // Comparable 接口，重写该接口中得 compareTo()方法，根据此方法 返回得正负 0 来决定元素在二叉树中的左右位置，返回0 就不往里面方法 //一种是比较器排序 TreeSet<Student> set = new TreeSet<>(); set.add(new Student("杨超越asdfasfd", 20)); set.add(new Student("杨超越2", 20)); set.add(new Student("杨超越2", 19)); set.add(new Student("杨超越2", 21)); set.add(new Student("杨超越sdfsdf", 20)); set.add(new Student("杨子涵", 22)); set.add(new Student("杨树林sss", 25)); set.add(new Student("杨康sss", 29)); set.add(new Student("杨过ssssssssss", 23)); set.add(new Student("杨梅sssssssssssssssssssssssssssssss", 18)); set.add(new Student("杨紫dfdfdfdfdf", 16)); set.add(new Student("杨洋洋", 17)); set.add(new Student("杨洋洋asddfassd", 17)); for (Student student : set) { System.out.println(student); } } } ------------------ 输出：(先按照名字长度来进行比较，然后再按照年龄大小来比较！) Student{name='杨洋洋', age=17} Student{name='杨子涵', age=22} Student{name='杨超越2', age=19} Student{name='杨超越2', age=20} Student{name='杨超越2', age=21} Student{name='杨康sss', age=29} Student{name='杨树林sss', age=25} Student{name='杨超越sdfsdf', age=20} Student{name='杨超越asdfasfd', age=20} Student{name='杨紫dfdfdfdfdf', age=16} Student{name='杨洋洋asddfassd', age=17} Student{name='杨过ssssssssss', age=23} Student{name='杨梅sssssssssssssssssssssssssssssss', age=18}
b. 比较器排序：采用的是TreeSet的有参构造(针对TreeSet的对象生成是调用的有参构造)，这个构造方法传入一个比较器(Comparetor接口) 你要重写这个接口的compate()根据此方法返回的“正，负，零”来决定元素的左右顺序。（无需重写Student类中的方法。）----------------------(自定义类) 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 void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int compareTo(Student o) { //比较逻辑是按照年龄比 int num=this.age - o.age; //比较名字长度： num = num==0?this.name.length()>o.name.length()?1:this.name.length()==o.name.length()?0:-1:num; //年龄和名字长度一样不能说明是同一个对象，还得比较姓名是否一样 int num2=num==0?this.name.compareTo(o.name):num; return num2; //根据 返回值的 正 负 0 来决定元素的左右顺序 } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } } --------------------（主函数） public class MyTest2 { public static void main(String[] args) { //存储学生对象，按照学生得年龄大小来排序 //TreeSet 集合 能够对元素进行排序，排序方式，分两种 //一种是自然排序：自然排序，你使用得是无参构造，自然排序，对排序得元素有要求，要求，元素必须实现一个 // Comparable 接口，重写该接口中得 compareTo()方法，根据此方法 返回得正负 0 来决定元素在二叉树中的左右位置，返回0 就不往里面方法 //一种是比较器排序 TreeSet<Student> set = new TreeSet<>(); set.add(new Student("杨超越asdfasfd", 20)); set.add(new Student("杨超越2", 20)); set.add(new Student("杨超越3", 20)); set.add(new Student("杨超越sdfsdf", 20)); set.add(new Student("杨子涵", 22)); set.add(new Student("杨树林sss", 25)); set.add(new Student("杨康sss", 29)); set.add(new Student("杨过ssssssssss", 23)); set.add(new Student("杨梅sssssssssssssssssssssssssssssss", 18)); set.add(new Student("杨紫dfdfdfdfdf", 16)); set.add(new Student("杨洋洋", 17)); set.add(new Student("杨洋洋asddfassd", 17)); for (Student student : set) { System.out.println(student); } } } ------- 输出：(可以看出，首先按照年龄排序，年辆一样的，按照名字长短再排序！) Student{name='杨紫dfdfdfdfdf', age=16} Student{name='杨洋洋', age=17} Student{name='杨洋洋asddfassd', age=17} Student{name='杨梅sssssssssssssssssssssssssssssss', age=18} Student{name='杨超越2', age=20} Student{name='杨超越3', age=20} Student{name='杨超越sdfsdf', age=20} Student{name='杨超越asdfasfd', age=20} Student{name='杨子涵', age=22} Student{name='杨过ssssssssss', age=23} Student{name='杨树林sss', age=25} Student{name='杨康sss', age=29}
Student自定义类的展示：（这个Student类为后续代码所使用的类的参考）
注意：这个comparetor 是一个接口，传入实现该接口的子类的对象！（即：可以使用匿名内部类来进行参数传递！）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 + '}'; } }
示例1：（自定义一个实现Comparator接口的类）
示例2：（无需自定义类来实现该接口，利用匿名内部类来实现！）--------------------------(自定义类) class MyCompareTor implements Comparator<Student>{ @Override public int compare(Student s1, Student s2) { //根据年龄排序 int num=s1.getAge()-s2.getAge(); int num2=num==0?s1.getName().compareTo(s2.getName()):num; return num2; } } ---------------------------（主函数：） public class MyTest { public static void main(String[] args) { //比较器排序：采用的是有参构造，这个这个构造方法传入一个比较器（Comparetor 接口）你要重写这个接口中的 // compare()方法，并根据此方法的返回值的正 负 0 来决定元素排列的左右顺序。 MyCompareTor myCompareTor = new MyCompareTor(); TreeSet<Student> set= new TreeSet<>(myCompareTor); set.add(new Student("杨超越asdfasfd", 20)); set.add(new Student("杨超越2", 20)); set.add(new Student("杨超越sdfsdf", 20)); set.add(new Student("杨子涵", 22)); set.add(new Student("王祖贤", 22)); set.add(new Student("王祖贤", 23)); set.add(new Student("杨树林sss", 25)); set.add(new Student("杨康sss", 29)); set.add(new Student("杨过ssssssssss", 23)); set.add(new Student("杨梅sssssssssssssssssssssssssssssss", 18)); set.add(new Student("杨紫dfdfdfdfdf", 16)); set.add(new Student("杨洋洋", 17)); set.add(new Student("杨洋洋asddfassd", 17)); for (Student student : set) { System.out.println(student); } } } --------------- 输出： Student{name='杨紫dfdfdfdfdf', age=16} Student{name='杨洋洋', age=17} Student{name='杨洋洋asddfassd', age=17} Student{name='杨梅sssssssssssssssssssssssssssssss', age=18} Student{name='杨超越2', age=20} Student{name='杨超越asdfasfd', age=20} Student{name='杨超越sdfsdf', age=20} Student{name='杨子涵', age=22} Student{name='王祖贤', age=22} Student{name='杨过ssssssssss', age=23} Student{name='王祖贤', age=23} Student{name='杨树林sss', age=25} Student{name='杨康sss', age=29}public class MyTest { public static void main(String[] args) { //比较器排序：采用的是有参构造，这个这个构造方法传入一个比较器（Comparetor 接口）你要重写这个接口中的 // compare()根据此方法的返回值的正 负 0 来决定元素排列的左右顺序 //我们采用匿名内部类来传 TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { //根据年龄排序 int num = s1.getAge() - s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); set.add(new Student("杨超越asdfasfd", 20)); set.add(new Student("杨超越2", 20)); set.add(new Student("杨超越sdfsdf", 20)); set.add(new Student("杨子涵", 22)); set.add(new Student("王祖贤", 22)); set.add(new Student("王祖贤", 23)); set.add(new Student("杨树林sss", 25)); set.add(new Student("杨康sss", 29)); set.add(new Student("杨过ssssssssss", 23)); set.add(new Student("杨梅sssssssssssssssssssssssssssssss", 18)); set.add(new Student("杨紫dfdfdfdfdf", 16)); set.add(new Student("杨洋洋", 17)); set.add(new Student("杨洋洋asddfassd", 17)); for (Student student : set) { System.out.println(student); } } } ------- 输出：(可以看到与上一个示例结果一致！) Student{name='杨紫dfdfdfdfdf', age=16} Student{name='杨洋洋', age=17} Student{name='杨洋洋asddfassd', age=17} Student{name='杨梅sssssssssssssssssssssssssssssss', age=18} Student{name='杨超越2', age=20} Student{name='杨超越asdfasfd', age=20} Student{name='杨超越sdfsdf', age=20} Student{name='杨子涵', age=22} Student{name='王祖贤', age=22} Student{name='杨过ssssssssss', age=23} Student{name='王祖贤', age=23} Student{name='杨树林sss', age=25} Student{name='杨康sss', age=29} - 比较器在其他领域的使用：(在Arrays.sort()方法上的使用！)
a. 示例：(在Arrays.sort()方法中传入一个比较器，用来自定义排序的逻辑)
b. 引出一个问题：public class MyTest { public static void main(String[] args) { Integer[] arr={20,30,1,20,75,100}; //Arrays.sort(arr); //System.out.println(Arrays.toString(arr)); System.out.println("--------------------------"); Arrays.sort(arr, new Comparator<Integer>() { @Override public int compare(Integer a, Integer b) { return (a-b); } }); System.out.println(Arrays.toString(arr)); } } ---- 输出： -------------------------- [1, 20, 20, 30, 75, 100]- 泛型指定只能用引用类型
- 在使用基本类型的数组的时候，最好定义为其包装类型（因为其能自动拆箱），但包装类型的数据更为灵活，比如说：在这种Arrays.sort()的方式示例上。
案例：(产生10个1-20之间的随机数要求随机数不能重复)
- 示例：
public class MyTest3 { public static void main(String[] args) { /* A: 案例演示 需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。 并把最终的随机数输出到控制台。 选HashSet 可以不重复 选TreeSet 不重复还可以排序*/ TreeSet<Integer> integers = new TreeSet<>(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1 - o2; } }); //方法一： Random random = new Random(); int size = integers.size(); for (int i = 0; i < 10; i++) { int i1 = random.nextInt(20) + 1; integers.add(i1); if(integers.size() != size+1){ i--; }else { size++; System.out.println(i1); } } System.out.println("============="); //方法二： // while(true){ // int r = random.nextInt(20)+1; // integers.add(r); // if(integers.size()==10){ // break; // } // } for (Integer integer : integers) { System.out.println(integer); } } }
案例：(键盘录入学生信息按照总分排序后输出在控制台)
- 自定义学生类信息：
class StudentS { String name; int chinese_score; int math_score; int english_score; int total_score; public String getName() { return name; } public StudentS(String name, int chinese_score, int math_score, int english_score) { this.name = name; this.chinese_score = chinese_score; this.math_score = math_score; this.english_score = english_score; this.total_score = chinese_score + math_score + english_score; } public void setName(String name) { this.name = name; } public int getChinese_score() { return chinese_score; } public void setChinese_score(int chinese_score) { this.chinese_score = chinese_score; } public int getMath_score() { return math_score; } public void setMath_score(int math_score) { this.math_score = math_score; } public int getEnglish_score() { return english_score; } public void setEnglish_score(int english_score) { this.english_score = english_score; } public int getTotal_score() { return total_score; } public void setTotal_score(int total_score) { this.total_score = total_score; } } - 主函数：
public class MyTest { public static void main(String[] args) { TreeSet<StudentS> studentS = new TreeSet<>(new Comparator<StudentS>() { @Override public int compare(StudentS o1, StudentS o2) { int num = o1.total_score - o2.total_score; int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num; return num2; } }); for (int i = 0; i < 3; i++) { Scanner scanner = new Scanner(System.in); System.out.println("请输入第" + i + "个学生的姓名:"); String name = scanner.nextLine(); System.out.println("请输入第" + i + "个学生的语文成绩:"); int chinese_score = scanner.nextInt(); System.out.println("请输入第" + i + "个学生的数学成绩:"); int math_score = scanner.nextInt(); System.out.println("请输入第" + i + "个学生的英语成绩:"); int english_score = scanner.nextInt(); studentS.add(new StudentS(name, chinese_score, math_score, english_score)); } int x = 0; System.out.printf("%-10s", "No"); System.out.printf("%-10s", "name"); System.out.printf("%-15s", "Chinese_score"); System.out.printf("%-15s", "Math_score"); System.out.printf("%-15s", "English_score"); System.out.printf("%-15s", "Total_score"); System.out.printf("\n"); for (StudentS student : studentS) { //System.out.println("" + (x++) + "\t\t" + student.getName() + "\t\t" + student.getChinese_score() + "\t\t" + student.getMath_score() + "\t\t" + student.getEnglish_score() + "\t\t" + student.getTotal_score()); System.out.printf("%-10s", x); System.out.printf("%-10s", student.getName()); System.out.printf("%-15s", student.getChinese_score()); System.out.printf("%-15s", student.getMath_score()); System.out.printf("%-15s", student.getEnglish_score()); System.out.printf("%-15s", student.getTotal_score()); System.out.printf("\n"); } } } -------- 输出： 请输入第0个学生的姓名: seozheng 请输入第0个学生的语文成绩: 88 请输入第0个学生的数学成绩: 85 请输入第0个学生的英语成绩: 77 请输入第1个学生的姓名: lulu 请输入第1个学生的语文成绩: 88 请输入第1个学生的数学成绩: 90 请输入第1个学生的英语成绩: 82 请输入第2个学生的姓名: yumin 请输入第2个学生的语文成绩: 77 请输入第2个学生的数学成绩: 82 请输入第2个学生的英语成绩: 90 No name Chinese_score Math_score English_score Total_score 0 yumin 77 82 90 249 0 seozheng 88 85 77 250 0 lulu 88 90 82 260
扫一扫
8098
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
