day17目录:
Set
HashSet
LinkedHashSet
TreeSet
集合练习
17.08_集合框架(Set集合概述及特点)(掌握)
A:Set集合概述及特点: 通过API查看即可
B: 案例演示: 无序(存储和取出的顺序)和唯一
17.09_集合框架(HashSet存储字符串并遍历)(掌握)
A:案例演示: HashSet存储字符串并遍历
public class SetDemo {
public static void main(String[] args) {
//List:集合元素允许重复
// Set :元素唯一,不允许重复
//HashSet:元素唯一,不允许元素重复,元素无序(存取顺序不一致)底层数据结构是哈希表(JDK1.7 数组加链表 JDK1.8 数组+链表+二叉树)。
HashSet<String> hashSet = new HashSet<>();
hashSet.add("aaa");
hashSet.add("aaa");
hashSet.add("aaa");
hashSet.add("王五");
hashSet.add("李四");
hashSet.add("王五");
hashSet.add("bbbbbbbbbbbbbb");
hashSet.add("eeeeeeee");
for (String s : hashSet) {
System.out.println(s);
}
}
}
17.10_集合框架(HashSet保证元素唯一性)(掌握)
HashSet 底层数据结构是哈希表. HashSet 不是线程安全的 集合元素可以是 null
哈希表:是一个元素为链表的数组,综合了数组和链表的优点 (像新华字典一样) (JDK1.7之前)
当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值,
然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
HashSet 集合判断两个元素相等的标准:
两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
结论:HashSet 保证元素唯一性是靠元素重写hashCode()和equals()方法来保证的,如果不重写则无法保证。
@Override
public int hashCode() {
// return 0;
// 因为成员变量值影响了哈希值,所以我们把成员变量值相加即可
// return this.name.hashCode() + this.age;
// 看下面
//s1:name.hashCode()=40,age=30
//s2:name.hashCode()=20,age=50
//尽可能的区分,我们可以把它们随变乘以一些整数
return this.name.hashCode() + this.age * 15;
}
// @Override
// public boolean equals(Object obj) {
// // System.out.println(this + "---" + obj);
// if (this == obj) {
// return true;
// }
//
// if (!(obj instanceof Student)) {
// return false;
// }
//
// Student s = (Student) obj;
// return this.name.equals(s.name) && this.age == s.age;
// }
//
// @Override
// public String toString() {
// return "Student [name=" + name + ", age=" + age + "]";
// }
17.11_集合框架(HashSet存储自定义对象保证元素唯一性)(掌握)
A:案例演示: 存储自定义对象,并保证元素唯一性。
如果两个对象的成员变量都相同我们认为是同一个对象.
一开始不行。想想刚才讲解的源码,重写两个方法。
public class MyTest {
public static void main(String[] args) {
//HashSet:底层数据结构是哈希表(JDK1.7 数组+链表) JDK1.8(数组+链表+红黑树)
//HashSet集合保证元素的唯一性,是靠元素来重写hashCode()和equals()方法来保证的,如果元素不重写则无法保证元素的唯一性。
//二来我们也要合理的去重写hashCode()方法,来尽量的减少碰撞次数。
HashSet<Student> set = new HashSet<>();
set.add(new Student("张三", 23));
set.add(new Student("张三", 23));
set.add(new Student("王五", 23));
set.add(new Student("赵六", 23));
set.add(new Student("刘德华", 23));
set.add(new Student("田七", 23));
set.add(new Student("李元霸", 23));
for (Student student : set) {
System.out.println(student);
}
}
}
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 this.name.hashCode() + this.age * 13;
return Objects.hash(name, age);
}
/*
@Override
public boolean equals(Object o) {
System.out.println("equals方法调用了");
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() {
System.out.println("hashCode方法调用了");
//张三 23 20+23 43
//王五 25 name 22+25*11
//赵六 24 name 22+23*11
return this.name.hashCode() + this.age * 13;
// return 0;
}
*
*/
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
17.12_集合框架(HashSet存储自定义对象保证元素唯一性图解及代码优化)(掌握)
A:画图演示: 画图说明比较过程
B:代码优化: 为了减少比较,优化hashCode()代码写法。最终版就是自动生成即可。
public class MyTest3 {
public static void main(String[] args) {
//HashSet 底层用的是HashMap来存的
HashSet<Integer> set = new HashSet<>();
/* public HashSet() {
map = new HashMap<>();
}*/
set.add(100);
/* public boolean add (E e){
return map.put(e, PRESENT) == null;
}
public V put (K key, V value){
return putVal(hash(key), key, value, false, true);
}
static final int hash (Object key){
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}*/
}
}
17.13_集合框架(HashSet存储自定义对象并遍历练习)(掌握)
A:案例演示: HashSet存储自定义对象并遍历练习
17.14_集合框架(LinkedHashSet的概述和使用)(理解)
数据结构 有两个:链表和哈希表
链表保证有序 哈希表保证元素唯一
A:LinkedHashSet的概述: 元素有序 , 并且唯一
B:案例演示: LinkedHashSet的特点
17.15_集合框架(TreeSet存储Integer类型的元素并遍历)(掌握)
//TreeSet:
//底层数据结是二叉树的结构,他能保证元素的唯一性,而且还能对元素进行排序。
//TreeSet 对元素进行排序,分为自然排序和比较器排序。
//自然排序:采用空参构造,用的就是自然排序,自然排序对元素有要求,要求元素实现 Comparable 接口,重写 compareTo这个方法
//根据此方法返回值的正负0 来决定元素在二叉树中所存放的位置。
// Integer
public int compareTo (Integer anotherInteger){
return compare(this.value, anotherInteger.value);
}
public static int compare ( int x, int y){
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
// String
public int compareTo (String anotherString){
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
A: TreeSet集合的特点: 元素唯一,并且可以对元素进行排序
排序:
a: 自然排序
b: 使用比较器排序
到底使用的是哪一种的排序取决于,构造方法.
B:案例演示: TreeSet存储Integer类型的元素并遍历
存储下列元素: 20 , 18 , 23 , 22 , 17 , 24, 19 , 18 , 24
//TreeSet:底层数据结是二叉树的结构,他能保证元素的唯一性,而且还能对元素进行排序。
// 存储下列元素:
// 20, 18, 23, 22, 17, 24, 19, 18, 24
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(20);
treeSet.add(18);
treeSet.add(23);
treeSet.add(22);
treeSet.add(17);
treeSet.add(24);
treeSet.add(19);
treeSet.add(18);
treeSet.add(24);
for (Integer integer : treeSet) {
System.out.println(integer);
}
注意:使用TreeSet集合进行元素的自然排序,那么对元素有要求,要求这个元素
必须实现Comparable接口 否则无法进行自然排序
保证元素的唯一性是靠compareTo方法的返回值来确定如果返回0 表示两个元素相等
则不重复存储
17.17_集合框架(TreeSet保证元素唯一和自然排序的原理和图解)(掌握)
A:画图演示: TreeSet保证元素唯一和自然排序的原理和图解
二叉树的数据结构 先存入一个树根 分两个叉
存储元素时 跟树根比较 小的放在左边 大的放在右边
如果相等就不存储
取的时候按照 左中右的顺序来取
17.18_集合框架(TreeSet存储自定义对象并遍历练习1)(掌握)
注意自然排序 此对象 必须实现Comparable接口 否则报错
TreeSet: 底层用的是TreeMap来存储的
//底层数据结是二叉树的结构,他能保证元素的唯一性,而且还能对元素进行排序。
//TreeSet 对元素进行排序,分为自然排序和比较器排序。demo4是自然排序,demo5是比较器排序
//自然排序:采用空参构造,用的就是自然排序,自然排序对元素有要求,要求元素实现 Comparable 接口,重写 compareTo这个方法
//根据此方法返回值的正负0 来决定元素在二叉树中所存放的位置。
//我们按照学生的年龄大小来排序
//空参构造,用的是自然排序
/*
* TreeSet
public TreeSet()构造一个新的空 set,该 set 根据其元素的自然顺序进行排序。
* 插入该 set 的所有元素都必须实现 Comparable 接口。
* 另外,所有这些元素都必须是可互相比较的:
* 对于 set 中的任意两个元素 e1 和 e2,执行 e1.compareTo(e2) 都不得抛出 ClassCastException。
* 如果用户试图将违反此约束的元素添加到 set
* (例如,用户试图将字符串元素添加到其元素为整数的 set 中),则 add 调用将抛出 ClassCastException。
A:案例演示: TreeSet存储自定义对象并遍历练习1
按照年龄进行排序
年龄就是主要条件
次要条件就是姓名
//先比较年龄
int num=this.age-obj.age;
//年龄相同再比较姓名
int num2=(num==0)?this.name.compareTo(obj.name):num;
最后返回 num2
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 student) {
// System.out.println("比较的方法调用了" + student);
//根据年龄来比。
//比较的逻辑由我们来重写
System.out.println(this + "=====" + student);
int num = this.age - student.age;
//如果年龄相同,并不能说明是同一个对象,还得比较姓名
int num2 = num == 0 ? this.name.compareTo(student.name) : num;
return -num2; //正 负 0
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
17.19_集合框架(TreeSet存储自定义对象并遍历练习2)(掌握)
A:案例演示: TreeSet存储自定义对象并遍历练习2
按照姓名的长度进行排序
主要条件是姓名的长度
然后是姓名
然后是年龄
//先比较姓名长度
int num=this.name.length()-obj.name.length();
//如果姓名长度一样再比较年龄
int num2=(num==0)?this.age-obj.age:num;
//如果年龄相同 再比较姓名
int num3=(num2==0)?this.name.compareTo(obj.name):num2;
最后返回 num3
//比较元素大小的方法
@Override
public int compareTo(Student student) {
//按照姓名的长度来排序
int num = this.name.length() - student.name.length();
//姓名长度一样了,还得比较姓名内容一样不
int i = this.name.compareTo(student.name);
int num2 = num == 0 ? this.name.compareTo(student.name) : num;
//姓名长度一样了,内容一样了,还得比较年龄是否一样
int num3 = num2 == 0 ? this.age - student.age : num2;
return num3;
}
17.20_集合框架(TreeSet保证元素唯一和比较器排序的原理及代码实现)(掌握)
A:案例演示: TreeSet保证元素唯一和比较器排序的原理及代码实现
在创建TreeSet对象的时候,传递一个比较器对象
B: 按照年龄进行排序
public class MyComparator 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; //正 负 0
}
}
- 常规方式:
public class MyTest {
public static void main(String[] args) {
/* TreeSet()
构造一个新的空 set,该 set 根据其元素的自然顺序进行排序。*/
/* TreeSet(Comparator < ? super E > comparator)
构造一个新的空 TreeSet,它根据指定比较器进行排序。*/
//*如果使用有参构造,那就是比较器排序*
MyComparator myComparator = new MyComparator();
TreeSet<Student> treeSet = new TreeSet<>(myComparator);
/*
public TreeSet(Comparator < ? super E > comparator) {
this(new TreeMap<>(comparator));
}
public TreeMap(Comparator < ? super K > comparator) {
this.comparator = comparator;
}*/
treeSet.add(new Student("张曼玉222222", 18));
treeSet.add(new Student("张曼555", 18));
treeSet.add(new Student("张曼玉222", 18));
treeSet.add(new Student("王祖贤111", 17));
treeSet.add(new Student("李冰冰", 20));
treeSet.add(new Student("范冰冰111111", 15));
treeSet.add(new Student("钟楚红55555555555555555", 30));
treeSet.add(new Student("林青霞", 60));
treeSet.add(new Student("毛舜筠", 38));
treeSet.add(new Student("张曼玉", 18));
treeSet.add(new Student("周慧敏dddd", 29));
treeSet.add(new Student("李丽珍", 48));
treeSet.add(new Student("刘亦菲", 48));
treeSet.add(new Student("刘亦菲", 48));
treeSet.add(new Student("刘亦菲", 48));
treeSet.add(new Student("刘亦菲", 49));
for (Student student : treeSet) {
System.out.println("年龄" + student.getAge() + "===" + student.getName());
}
}
}
- 匿名内部类方法传入比较器:
//比较器的方式,采用有参构造,传入比较器,重写compare()方法根据此方法,返回值的正负0,来决定元素放置的左右顺序。
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
//按照姓名长度排序
int num = s1.getName().length() - s2.getName().length();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
return -num3;
}
});
- Arraylist的sort方法:
```java
ArrayList<Integer> integers = new ArrayList<>();
integers.add(2);
integers.add(29);
integers.add(25);
integers.add(20);
integers.add(22);
integers.add(22);
integers.sort(new Comparator<Integer>() {
@Override
public int compare(Integer a, Integer b) {
return b - a;
}
});
System.out.println(integers);
int[] arr = {2, 6, 1, 4, 5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
- Arrays的sort方法:
Integer[] arr2 = {2, 6, 1, 4, 5};
Arrays.sort(arr2, new Comparator<Integer>() {
@Override
public int compare(Integer a, Integer b) {
return -Integer.compare(a, b);
//return b - a;
/* public static int compare ( int x, int y){
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}*/
}
});
17.22_集合框架(产生10个1-20之间的随机数要求随机数不能重复)(掌握)
A:案例演示
需求:编写一个程序,获取10个1至20的随机数,要求随机数不能重复。
并把最终的随机数输出到控制台。
选HashSet 可以不重复
选TreeSet 不重复还可以排序
分析:
a: 定义一个HashSet集合
b: 产生随机数,把随机数添加到集合中
c: 判断集合的长度,使用while循环实现
17.23_集合框架(键盘录入学生信息按照总分排序后输出在控制台)(掌握)
A:案例演示: 需求:键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。
/**
* 步骤:
* a: 自定义一个学生类
* b: 创建一个TreeSet集合对象(使用比较器进行排序)
* c: 键盘录入学生的数据,然后把学生的数据封装成一个学生对象,把学生对象添加到集合中
* d: 遍历集合
*/
km17.24_day17总结
练习:
public class MyTest2 {
public static void main(String[] args) {
//去除Arraylist集合中的重复元素
ArrayList<Integer> integers = new ArrayList<>();
integers.add(29);
integers.add(29);
integers.add(29);
integers.add(29);
integers.add(29);
integers.add(29);
integers.add(25);
integers.add(20);
integers.add(22);
integers.add(22);
integers.add(220);
integers.add(220);
//LinkedHashSet<Integer> integers1 = new LinkedHashSet<>(integers);
//System.out.println(integers1);
for (int i = 0; i < integers.size() - 1; i++) {
for (int j = i + 1; j < integers.size(); j++) {
//拿每一个元素跟后面的每一个元素去比较,如果有相同的就删掉
Integer integer = integers.get(i);
Integer integer1 = integers.get(j);
if (integer.equals(integer1)) {
integers.remove(j);
j--; //注意 j--
}
}
}
System.out.println(integers);
}
}