JavaSE Set HashSet LinkedHashSet TreeSet 集合练习

最新推荐文章于 2022-07-21 20:45:06 发布

Hoooooope!

最新推荐文章于 2022-07-21 20:45:06 发布

阅读量211

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_43563187/article/details/112298349

版权

JavaSE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

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);

    }
}

Hoooooope!

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JavaSE Set HashSet LinkedHashSet TreeSet 集合练习

day17目录：Set HashSet LinkedHashSet TreeSet集合练习17.08_集合框架(Set集合概述及特点)(掌握)A:Set集合概述及特点: 通过API查看即可B: 案例演示: 无序(存储和取出的顺序)和唯一17.09_集合框架(HashSet存储字符串并遍历)(掌握)A:案例演示: HashSet存储字符串并遍历17.10_集合框架(HashSet保证元素唯一性)(掌握) HashSet 底层数据结构是哈希表. HashSet 不是线程安
复制链接

扫一扫