Java--集合框架--Set

最新推荐文章于 2023-02-10 11:59:48 发布

全宇宙最可爱的宇宙

最新推荐文章于 2023-02-10 11:59:48 发布

阅读量101

点赞数

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

本文链接：https://blog.csdn.net/weixin_43216479/article/details/104320342

版权

Java 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

Set
	HashSet
	LinkedHashSet
	TreeSet

集合框架(Set集合概述及特点)

A:Set集合概述及特点:		通过API查看即可
B: 案例演示:	无序(存储和取出的顺序)和唯一
                    HashSet存储字符串并遍历
public class MyTest {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("张三");
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        hashSet.add("赵六");
        for (String s : hashSet) {
            System.out.println(s);
        }
    }
}

集合框架(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 + "]";
// }

集合框架(HashSet存储自定义对象保证元素唯一性)

A:案例演示:	存储自定义对象，并保证元素唯一性。
			如果两个对象的成员变量都相同我们认为是同一个对象.
			一开始不行。想想刚才讲解的源码，重写两个方法。

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

      数据结构 有两个 链表和哈希表
	 链表保证有序 哈希表保证元素唯一
	A:LinkedHashSet的概述:	元素有序 , 并且唯一
    B:案例演示:	LinkedHashSet的特点
    public class MyTest {
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("赵六");
        set.add("田七");
        set.add("张三");
        set.add("李四");
        set.add("王五");

        for (String s : set) {
            System.out.println(s);
        }

        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        integers.add(200);
        integers.add(300);
        integers.add(400);
        integers.add(300);
        integers.add(300);
        integers.add(100);

        HashSet<Integer> hashSet = new HashSet<>(integers);
        System.out.println(hashSet);

        LinkedHashSet<Integer> integers1 = new LinkedHashSet<>(integers);
        System.out.println(integers1);


    }
}

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

A: TreeSet集合的特点: 元素唯一,并且可以对元素进行排序
	排序:
		a:	自然排序
		b:    使用比较器排序
	到底使用的是哪一种的排序取决于,构造方法.
B:案例演示:	TreeSet存储Integer类型的元素并遍历
	存储下列元素:  20 , 18 , 23 , 22 , 17 , 24, 19 , 18 , 24
public class MyTest {
    public static void main(String[] args) {
        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 表示两个元素相等则不重复存储

集合框架(TreeSet保证元素唯一和自然排序的原理)

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

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

	注意自然排序 此对象 必须实现Comparable接口 否则报错
	A:案例演示:	TreeSet存储自定义对象并遍历练习1
	按照年龄进行排序  
	年龄就是主要条件
	次要条件就是姓名
	//先比较年龄
	int num=this.age-obj.age;
	//年龄相同再比较姓名
	int num2=(num==0)?this.name.compareTo(obj.name):num;
	最后返回 num2
public class MyTest3 {
    public static void main(String[] args) {
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",18);
        Student s4 = new Student("赵六",19);
        Student s5 = new Student("赵六",22);

        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        for (Student student : treeSet) {
            System.out.println(student.getName() + "==" + student.getAge());

        }


    }
}
public class Student implements Comparable<Student>{
    private String name;
    private int age;


    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;
        int num2=num==0?this.name.compareTo(o.name):num;

        return num2;
    }
}

集合框架(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
public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("一",21);
        Student s2 = new Student("二二",20);
        Student s3 = new Student("三三三",18);
        Student s4 = new Student("四四四四",19);
        Student s5 = new Student("五五五五五",22);
        Student s6 = new Student("六六六六六六",20);
        Student s8 = new Student("六六",20);
        Student s7 = new Student("七七七七七七七",18);
        Student s9 = new Student("七七七七七七七",20);

        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
        treeSet.add(s7);
        treeSet.add(s8);
        treeSet.add(s9);

        for (Student student : treeSet) {
            System.out.println(student.getName() + "==" + student.getAge());

        }
    }
}
public class Student implements Comparable<Student>{
    private String name;
    private int age;


    public Student1(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 i = this.name.length() - o.name.length();
        int j=i==0?this.name.compareTo(o.name):i;
        int h=j==0?this.age-o.age:j;
        return h;
    }
}

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

A:案例演示:	TreeSet保证元素唯一和比较器排序的原理及代码实现
	在创建TreeSet对象的时候,传递一个比较器对象
B: 按照年龄进行排序
public class MyTest {
    public static void main(String[] args) {

        TreeSet<Student2> set = new TreeSet<>(new Comparator<Student2>() {
            @Override
            public int compare(Student2 s1, Student2 s2) {
                int num=s1.getAge()-s2.getAge();
                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        set.add(new Student2("一",18));
        set.add(new Student2("二二",20));
        set.add(new Student2("三三三",21));
        set.add(new Student2("四四",22));
        set.add(new Student2("五",20));
        set.add(new Student2("六六六六",18));
        set.add(new Student2("七七",21));
        set.add(new Student2("八",22));

        for (Student2 student : set) {
            System.out.println(student);
        }

    }
}

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

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

  分析:
	a: 定义一个HashSet集合
	b: 产生随机数,把随机数添加到集合中
	c: 判断集合的长度,使用while循环实现
public class MyTest {
    public static void main(String[] args) {
        //方法一
        Random random = new Random();
        HashSet<Integer> set = new HashSet<>();
        while (set.size()<10){
            int num = random.nextInt(20) + 1;
            set.add(num);
        }
        System.out.println(set);

        //方法二
        int[] arr=new int[10];
        digui(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void digui(int[] arr) {
        System.out.println("调用次数");
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i]=random.nextInt(20)+1;
        }
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[j]==arr[i]){
                    digui(arr);
                }
            }
        }
    }
}

集合框架(键盘录入学生信息按照总分排序后输出在控制台)

A:案例演示:	需求：键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。
/**
	 * 步骤: 
	 * 		a: 自定义一个学生类
	 * 		b: 创建一个TreeSet集合对象(使用比较器进行排序)
	 * 		c: 键盘录入学生的数据,然后把学生的数据封装成一个学生对象,把学生对象添加到集合中
	 * 		d: 遍历集合
	 */

	Scanner sc = new Scanner(System.in);

	TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {

		@Override
		public int compare(Student s1, Student s2) {
			// TODO Auto-generated method stub
			return s1.getTotal() - s2.getTotal();
		}
	});

	System.out.println("请录入成绩");
	for (int i = 0; i < 3; i++) {
		// 获取数据
		System.out.println("请输入第" + (i + 1) + "个学生的姓名");
		String name = sc.next();
		System.out.println("请输入第" + (i + 1) + "个学生的语文成绩");
		int yw = sc.nextInt();
		System.out.println("请输入第" + (i + 1) + "个学生的数学成绩");
		int sx = sc.nextInt();
		// 封装到对象里面
		Student student = new Student(name, yw, sx);
		// 把学生对象放到集合当中
		treeSet.add(student);

	}

	// 遍历学生成绩信息
	System.out.println("姓名\t\t总分\t\t语文\t\t数学\t\t");
	for (Student stu : treeSet) {

		System.out.println(stu.getName() + "\t\t" + stu.getTotal() + "\t\t"
				+ stu.getYw() + "\t\t" + stu.getSx());

	}

全宇宙最可爱的宇宙

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java--集合框架--Set

Set HashSet LinkedHashSet TreeSet集合框架(HashSet保证元素唯一性) HashSet 底层数据结构是哈希表. HashSet 不是线程安全的集合元素可以是 null 哈希表:是一个元素为链表的数组,综合了数组和链表的优点 (像新华字典一样) (JDK1.7之前) 当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的...
复制链接

扫一扫