java 学习7.19 Set HashSet LinkedHashSet TreeSet 集合练习

最新推荐文章于 2024-07-19 21:05:39 发布

haha9417

最新推荐文章于 2024-07-19 21:05:39 发布

阅读量251

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/haha9417/article/details/96637599

版权

java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

17.08_集合框架(Set集合概述及特点)(掌握)

A:Set集合概述及特点:		通过API查看即可
 //Set：元素唯一
       // HashSet 底层数据结构是哈希表（数组+链表 JDK1.7      JDK1.8 数组+链表+二叉树）
        //HashSet 元素无序（存取顺序不一致），且唯一（元素不能重复）
        //哈希表像新华字典
B: 案例演示:	无序(存储和取出的顺序)和唯一
import java.util.HashSet;
import java.util.TreeSet;


public class MyTest {
    public static void main(String[] args) {
        //Set：元素唯一
       // HashSet 底层数据结构是哈希表（数组+链表 JDK1.7      JDK1.8 数组+链表+二叉树）
        //HashSet 元素无序（存取顺序不一致），且唯一（元素不能重复）
        //哈希表像新华字典
        // LinkedHashSet
        //TreeSet
        HashSet<String> set = new HashSet<>();
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("刘德华");
        set.add("郭富城");
        set.add("黎明");
        set.add("张学友");
        set.add("刘德华");
        set.add("郭富城");
        set.add("黎明");
        set.add("张学友");
        for (String s : set) {
            System.out.println(s);
        }
    }
}
输出
ccc
黎明
郭富城
张学友
aaaa
bbbb
刘德华

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 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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //这是一个比较的方法
    @Override
    public int compareTo(Student student) {
        //根据学生的年龄大小来排序
        //年龄一样，并不能说明是同一个对象，我们还得比较姓名是否一样

       int num=this.age-student.age;

        int num2=num==0?this.name.compareTo(student.name):num;


import java.util.TreeSet;


public class MyTest {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();

        treeSet.add(new Student("张三士大夫士大夫", 23));
        treeSet.add(new Student("张三是非得失", 23));
        treeSet.add(new Student("李四大幅度发", 23));
        treeSet.add(new Student("王五大幅度发", 20));
        treeSet.add(new Student("周六的", 30));
        treeSet.add(new Student("田七大幅度", 23));
        treeSet.add(new Student("李白大幅度发", 33));
        treeSet.add(new Student("刘星大幅度发", 63));
        treeSet.add(new Student("夏雨", 78));
        treeSet.add(new Student("张子豪", 53));
        //排序：自然排序 和 比较器排序
        //自然排序：如果采用的是空参构造，那么采用的就是自然排序
        //如果是自然排序，那么对元素有要求，要求元素必须实现一个Comparable接口，重写这个接口中的一个compareTo这个比较的方法
      Integer  中实现了Comparable接口  而  Student  类中没有实现  所以需要手动实现
        //根据此方法的返回值的正 负  0 来决定元素，排列的位置

        for (Student student : treeSet) {
            System.out.println(student);
        }


    }
}

17.13_集合框架(HashSet存储自定义对象并遍历练习)(掌握)

A:案例演示:	HashSet存储自定义对象并遍历练习

import java.util.HashSet;
import java.util.TreeSet;

public class MyTest {
public static void main(String[] args) {

    HashSet<String> set = new HashSet<>();
    set.add("aaa");
    set.add("bbb");
    set.add("ccc");
    set.add("刘德华");
    set.add("郭富城");
    set.add("黎明");
    set.add("张学友");
    set.add("刘德华");
    set.add("郭富城");
    set.add("黎明");
    set.add("张学友");
    for (String s : set) {
        System.out.println(s);
    }
}

}

17.14_集合框架(LinkedHashSet的概述和使用)

	 链表保证有序 哈希表保证元素唯一
	A:LinkedHashSet的概述:	元素有序 , 并且唯一
	B:案例演示:	LinkedHashSet的特点
import java.util.HashSet;
import java.util.LinkedHashSet;


public class MyTest2 {
    public static void main(String[] args) {
        //LinkedHashSet 底层数据结构是链表和哈希表  元素有序且唯一  链表保证了有序，哈希表保证了唯一
        //线程不安全效率高
        LinkedHashSet<String> strings = new LinkedHashSet<>();
        strings.add("aaa");
        strings.add("bbb");
        strings.add("ccc");
        strings.add("ddd");
        strings.add("eee");
        strings.add("fff");
        strings.add("aaa");
        strings.add("bbb");
        strings.add("ccc");
        strings.add("ddd");
        strings.add("eee");
        strings.add("fff");
        for (String string : strings) {
            System.out.println(string);
        }
        输出
        ：aaa
bbb
ccc
ddd
eee
fff

17.15_集合框架(TreeSet存储Integer类型的元素并遍历)(掌握)

A: TreeSet集合的特点: 元素唯一,并且可以对元素进行排序
	排序:
		a:	自然排序
		b:    使用比较器排序
	到底使用的是哪一种的排序取决于,构造方法.
B:案例演示:	TreeSet存储Integer类型的元素并遍历
	存储下列元素:  20 , 18 , 23 , 22 , 17 , 24, 19 , 18 , 24
	import java.util.TreeSet;
public class TreeSetDemo {
    public static void main(String[] args) {
       // 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);
        System.out.println(treeSet);
    }
}
输出   [17, 18, 19, 20, 22, 23, 24]
底层结构是二叉树  直接输出 就行了

注意：使用TreeSet集合进行元素的自然排序，那么对元素有要求，要求这个元素
必须实现Comparable接口否则无法进行自然排序

  保证元素的唯一性是靠compareTo方法的返回值来确定如果返回0 表示两个元素相等
		则不重复存储
基本类型的包装类  重写了comparaTo方法  而 引用类型  没有重写
如  Integer 重写了  而 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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //这是一个比较的方法
    @Override
    public int compareTo(Student student) {
        //根据学生的年龄大小来排序
        //年龄一样，并不能说明是同一个对象，我们还得比较姓名是否一样

       int num=this.age-student.age;

        int num2=num==0?this.name.compareTo(student.name):num;


        return -num2; //根据返回值的正 负 0 来决定元素的放置位置
    }
}

17.17_集合框架(TreeSet保证元素唯一和自然排序的原理和图解)(掌握)

A:画图演示:	TreeSet保证元素唯一和自然排序的原理和图解
                 二叉树的数据结构 先存入一个树根 分两个叉
		 存储元素时 跟树根比较 小的放在左边 大的放在右边
		 如果相等就不存储
		 取的时候按照 左中右的顺序来取

17.18_集合框架(TreeSet存储自定义对象并遍历练习1)

注意自然排序此对象必须实现Comparable接口否则报错

	按照年龄进行排序  
	年龄就是主要条件
	次要条件就是姓名
	//先比较年龄
	int num=this.age-obj.age;
	//年龄相同再比较姓名
	int num2=(num==0)?this.name.compareTo(obj.name):num;
	最后返回 num2
	这里的this  代表 下一个 数据    而obj 代表的是  根节点

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

17.20_集合框架(TreeSet保证元素唯一和比较器排序的原理及代码实现)(掌握)

A:案例演示:	TreeSet保证元素唯一和比较器排序的原理及代码实现
	在创建TreeSet对象的时候,传递一个比较器对象


	import java.util.Comparator;
import java.util.TreeSet;

public class MyTest2 {
    public static void main(String[] args) {

        //TreeSet()
        //构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
       // TreeSet
        // 自然排序，使用空参构造，他的要求就是元素必须实现 Compareble接口，重写compareTo方法 ，根据此方法的返回值的正 负 0 来决定元素的放置位置
        //比较器排序：采用有参构造，你在创建TreeSet对象时，需要传入一个Comparetor 比较器

        //TreeSet(Comparator < ? super E > comparator)
        //构造一个新的空 TreeSet，它根据指定比较器进行排序。
        //Comparator<T> 比较器
        //int compare (T o1, T o2)
        //比较用来排序的两个参数。
        //通过匿名内部类来传入
       
        //比较器排序：就是我们在创建TreeSet对象时，给他传入一个比较器，重写比较器里面的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;
            }
        });


        treeSet.add(new Student("张三士大夫士大夫", 23));
        treeSet.add(new Student("张三是非得失", 23));
        treeSet.add(new Student("李四大幅度发", 23));
        treeSet.add(new Student("王五大幅度发", 20));
        treeSet.add(new Student("周六的", 30));
        treeSet.add(new Student("田七大幅度", 23));
        treeSet.add(new Student("李白大幅度发", 33));
        treeSet.add(new Student("刘星大幅度发", 63));
        treeSet.add(new Student("夏雨", 78));
        treeSet.add(new Student("张子豪", 53));


        for (Student student : treeSet) {
            System.out.println(student);
        }
        }
    }

B: 按照年龄进行排序

17.22_集合框架(产生10个1-20之间的随机数要求随机数不能重复)

A:案例演示
	需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
		  并把最终的随机数输出到控制台。
		  选HashSet 可以不重复
		  选TreeSet 不重复还可以排序

  分析:
	a: 定义一个HashSet集合
	b: 产生随机数,把随机数添加到集合中
	c: 判断集合的长度,使用while循环实现

import java.util.Random;
import java.util.TreeSet;


public class MyTest {
    public static void main(String[] args) {
        //A:
        //案例演示
        //需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
        //并把最终的随机数输出到控制台。
        //选HashSet 可以不重复
        //选TreeSet 不重复还可以排序
        TreeSet<Integer> treeSet = new TreeSet<>();
        Random random = new Random();
        while (treeSet.size()<10){
            int num = random.nextInt(20) + 1;

            treeSet.add(num);
        }

        System.out.println(treeSet);

    }
}

haha9417

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 学习7.19 Set HashSet LinkedHashSet TreeSet 集合练习

17.08_集合框架(Set集合概述及特点)(掌握)A:Set集合概述及特点: 通过API查看即可 //Set：元素唯一 // HashSet 底层数据结构是哈希表（数组+链表 JDK1.7 JDK1.8 数组+链表+二叉树） //HashSet 元素无序（存取顺序不一致），且唯一（元素不能重复） //哈希表像新华字典B: 案例演示:...
复制链接

扫一扫

专栏目录