文章目录
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