JAVA集合（上篇）

天演L

已于 2023-07-02 10:26:51 修改

阅读量138

点赞数 2

分类专栏： Java se 文章标签：数据结构算法 java

于 2023-06-23 13:52:33 首次发布

本文链接：https://blog.csdn.net/weixin_61611746/article/details/131347598

版权

Java se 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.集合基础

1.集合结构体系

在这里插入图片描述

2.集合概念

集合提供一种存储空间可变的存储模型，存储的数据容量可以改变

ArrayLis<>:
- 可调整大小的数组实现
- <>：是一种特殊的数据类型，泛型
- 可储存重复元素

3.集合和数组的区别

这里写图片描述

4.ArrayList

构造与添加方法：

方法名	说明
public Arraylist()	创建一个空的集合对象
public boolean add(E e)	将指定元素添加到此集合末尾
public void add(int index,E element)	在此集合的指定位置插入指定元素

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<>();
        System.out.println(array); //[]

        //添加到集合末尾
        array.add("hello");
        array.add("word");
        array.add("java");
        System.out.println(array); //[hello, word, java]

        //指定位置，添加元素
        array.add(1,"javase");
        System.out.println(array); //[hello, javase, word, java]

        array.add(4,"javaee");
        System.out.println(array); //[hello, javase, word, java, javaee]

        array.add(6,"javaweb"); 
        System.out.println(array); //IndexOutOfBoundsException，不能中间跳一个位置
    }
}

ArrayList 常用方法

方法名	说明
public boolean remove(Object o)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素,返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中元素的个数

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<>();
        System.out.println(array); //[]

        //添加到集合末尾
        array.add("hello");
        array.add("word");
        array.add("java");
        System.out.println(array); //[hello, word, java]

        //1,public boolean remove(Object o) 	删除指定的元素，返回删除是否成功
//        System.out.println(array.remove("hello")); //true; 集合变为[word, java]
//        System.out.println(array.remove("javase")); //false; 集合变为[hello, word, java]

        //2,public E remove(int index) 	删除指定索引处的元素,返回被删除的元素
//        System.out.println(array.remove(1)); //word,集合变为[hello, java]

        //3,public E set(int index,E element) 	修改指定索引处的元素，返回被修改的元素
//        System.out.println(array.set(1,"javase")); //word;集合变为[hello, javase, java]

        //4,public E get(int index) 	返回指定索引处的元素
//        System.out.println(array.get(0)); //hello
//        System.out.println(array.get(1)); //word
//        System.out.println(array.get(2)); //java

        //5,public int size() 	返回集合中元素的个数
        System.out.println(array.size()); //3
    }
}

2.Collection集合

— List 有序,可重复

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

—Set 无序,唯一

HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法：hashCode()和equals()
LinkedHashSet
底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一
TreeSet
底层数据结构是红黑树。(唯一，有序)
1. 如何保证元素排序的呢?
自然排序
比较器排序
2.如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定

1.概述

是单列集合的顶层接口，它表示一组对象，这些对象也称Collection元素

JDK不提供此接口的直接实现，它提供更具体的子接口（Set 和 List）实现

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();

        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);
    }
}

2.Collection集合的常用方法

方法名	说明
public boolean add(E e)	添加元素
public boolean remove(Object o)	从集合中移除指定的元素
public void clear()	清空集合中的元素
public boolean contains(Object o)	判断集合中是否存在指定的元素
public boolean isEmpty()	判断集合是否为空
public int size()	集合的长度，也就是集合中元素的个数
public Object[] toArray( )	把集合中的元素，储存到数组中

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();

        //1、public boolean add(E e) 	把给定的元素添加到当前集合中
        c.add("hello");
        c.add("hello");
        System.out.println(c); //[hello, hello] ;ArrayList可以存储重复元素

        //2、public boolean remove(E e) 	把给定的对象在当前集合中删除
        /*System.out.println(c.remove("hello")); //true
        System.out.println(c.remove("java")); //false
        System.out.println(c); //[hello]*/

        //3、public void clear() 	清空集合中所有的元素
        /*c.clear();
        System.out.println(c); //[]*/

        //4、public boolean contains(Object obj) 	判断当前集合中是否存在指定的对象
        /*System.out.println(c.contains("java")); //false
        System.out.println(c.contains("hello")); //true*/

        //5、public boolean isEmpty() 	判断当前集合是否为空
//        System.out.println(c.isEmpty()); //false

        //6、public int size() 	返回集合中元素的个数
//        System.out.println(c.size()); //2

        //7、public Object[] toArray( 	把集合中的元素，储存到数组中
        Object[] arr = c.toArray();
        for(int i= 0;i< arr.length;i++) {
            System.out.print(arr[i]+","); //hello,hello
        }

    }
}

3.Collection集合的遍历(应用)

Collection 集合遍历有三种方法：

迭代器
foreach(增强for循环)
DK 1.8 开始的新技术 Lambda 表达式

迭代器的介绍
- 迭代器，集合的专用遍历方式
- Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
- 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

方法名	说明
Iterator<E> iterator()	创建迭代器对象，默认指向当前集合的0索引
E next()	获取迭代中的下一个元素
boolean hasNext()	如果迭代具有更多元素，则返回true

public class IteratorDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

在这里插入图片描述

4.集合的案例-Collection集合存储学生对象并遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

学生类：

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

测试类：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Student> c = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);

        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //遍历集合(迭代器方式)
        Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

3.增强for循环

增强for：简化数组和Collection集合的遍历

实现Iterable接口的类允许其对象成为增强型 for语句的目标
它是JDK5之后出现的，其内部原理是一个Iterator迭代器

定义格式：

for(元素数据类型 变量名 : 数组/集合对象名) {
    循环体;
}

范例：

import java.util.ArrayList;
import java.util.List;

public class ForDemo {
    public static void main(String[] args) {
        //int类型数组
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.println(i);
            /*
            1
            2
            3
            4
            5*/
        }
        //String类型数组
        String[] strArray = {"java","python","scala"};
        for(String s : strArray) {
            System.out.println(s);
            /*java
            python
            scala*/
        }

        //集合
        List<String> list = new ArrayList<>();
        list.add("y1");
        list.add("y2");
        list.add("y3");
        for(String lt:list) {
            System.out.println(lt);
            /*y1
            y2
            y3*/
        }

        //判断：内部原理是一个Iterator迭代器
        for(String s:list) {
            if(s.equals("y1")) {
                list.add("y4"); //ConcurrentModificationException:并发修改异常
            }
        }
/*       //并发修改异常
         for(int i=0; i<list.size(); i++) {
            String s = list.get(i);
            if(s.equals("world")) {
                list.add("javaee");
            }
        } 
 */
    }
}

数据类型一定是集合或者数组中元素的类型

list就是要遍历的集合或数组

迭代器原理：修改第三方的值不会影响到集合中的元素

快捷生成：list.for

并发修改异常

迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException

解决方法：用for循环遍历，然后用集合对象做对应的操作

4.List集合

List系列集合：添加的元素是有序，可重复，有索引
- ArrayList: 添加的元素是有序，可重复，有索引
- LinkedList: 添加的元素是有序，可重复，有索引
- Vector ：是线程安全的，速度慢，开发中很少使用

1.List集合的概述与特点

1.有序集合(也称为序列)，用户可以精确控制列表中每个元索的插入位置。用户可以通过整数索引访问元素,并获取列表中的元素
2.与Set集合不同，List集合允许重复的元素

List集合特点

1.有索引
2.有序: 存储和取出的元素顺序一致
3.可重复: 存储的元素可以重复

2.List集合的特有方法

方法名	说明
public void add(int index,E element)	该集合中的指定位置上插入元素
public E remove(int index)	删除列表中指定位置的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引的元素，返回被修改的元素
public E get(int index)	返回集合中指定位置的元素


import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("javaee");
        System.out.println(list); //[hello,world,java,javaee]

        //1、public void add(int index,E element) 	该集合中的指定位置上插入元素
        list.add(1,"javase");
        System.out.println(list); //[hello, javase, world, java, javaee]

        //2、public E remove(int index) 	删除列表中指定位置的元素，返回被删除的元素
        System.out.println(list.remove(1)); //javase
        System.out.println(list); //[hello, world, java, javaee]

        //3、public E set(int index,E element) 	修改指定索引的元素，返回被修改的元素
        System.out.println(list.set(0,"java1")); //hello
        System.out.println(list); //[java1, world, java, javaee]

        //4、public E get(int index) 	返回集合中指定位置的元素
        System.out.println(list.get(2)); //java

        //for循环遍历
        for(int i=0;i< list.size();i++) {
            //5,public E get(int index)	返回集合中指定位置的元素
            String s = list.get(i);
            System.out.println(s);
            /*java1
            world
            java
            javaee*/
        }
    }
}

案例：

在这里插入图片描述

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //2、创建集合对象
        List<Student> list = new ArrayList<Student>();
        //3、创建学生对象
        Student s1 = new Student("y1",10);
        Student s2 = new Student("y2",20);
        Student s3 = new Student("y3",30);
        //4、学生对象添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //5、遍历集合：迭代器方法
        Iterator<Student> it = list.iterator();
        while(it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
            /*y1,10
            y2,20
            y3,30*/
        }
        System.out.println("--------");
        
        //6。普通for：带有索引的遍历方式
        for(int i=0; i<list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");
        
        //7、遍历集合：for循环
        for(int i=0;i<list.size();i++) {
            Student ss = list.get(i);
            System.out.println(ss.getName()+","+ss.getAge());
            /*y1,10
            y2,20
            y3,30*/
        }
    }
}

5.List集合的实现类

1.List集合子类特点

ArrayList:底层数据结构数组实现，查询快，增删慢

LinkedList:底层数据结构链表实现，查询慢，增删快

2.ArrayList集合存储学生对象三种方式遍历

学生类：

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

测试类：

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);

        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //迭代器：集合特有的遍历方式
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //普通for：带有索引的遍历方式
        for(int i=0; i<array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //增强for：最方便的遍历方式
        for(Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

6.LinkedList集合

特有方法：

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("java");
        linkedList.add("python");
        linkedList.add("scala");
        System.out.println(linkedList); //[java, python, scala]

        //1、public void addFirst(E,e) 	在该列表开头插入指定的元素
        linkedList.addFirst("1");
        System.out.println(linkedList); //[1, java, python, scala]

        //2、public void addLast(E,e) 	将指定的元索追加到此列表的末尾
        linkedList.addLast("5");
        System.out.println(linkedList); //[1, java, python, scala, 5]

        //3、public E getFirst() 	返回此列表中的第一个元索
        System.out.println(linkedList.getFirst()); //1

        //4、public E getLast() 	返回此列表中的最后一个元素
        System.out.println(linkedList.getLast()); //5

        //5、public E removeFirst 	从此列表中删除并返回第一个元素
        System.out.println(linkedList.removeFirst()); //1
        System.out.println(linkedList);//[java, python, scala, 5]

        //6、public E removeLast 	从此列表中删除并返回最后一个元素
        System.out.println(linkedList.removeLast()); //5
        System.out.println(linkedList); //[java, python, scala]
    }
}

ArrayList与LinkList的区别

ArrayList 底层是基于数组实现的，ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

LinkedList 底层是基于链表实现的，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
正因为底层数据结构的不同，他们适用的场景不同，ArrayList 更适合随机查找，LinkedList 更适合删除和添加，查询、添加、删除的时间复杂度不同。

7.set集合

1.set集合概述

Set集合的特点
- 不包含重复元素的集合
- 没有带索引的方法，所以不能使用普通for循环

Set集合是接口通过实现类实例化（多态的形式）
- HashSet：添加的元素是无序，不重复，无索引的
- LinkedHashSet: 添加的元素是有序，不重复，无索引的
- TreeSet: 不重复，无索引，按照大小默认升序排列

import java.util.HashSet;
import java.util.Set;

public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<String>();

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");

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

2.哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

pubilc int hashcode() :返回对象的哈希码值

对象的哈希值特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下，不同对象的哈希值是不同的。而重写hashCode0方法，可以实现让不同对象的哈希值相同

获取哈希值：

学生类：

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 int hashCode() {
        return 0;
    }
}

测试类：

public class HashDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("张三",23);

        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode()); 
        System.out.println(s1.hashCode()); 
        System.out.println("--------");

        Student s2 = new Student("李四",24);

        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写，可以实现不同对象的哈希值是相同的
        System.out.println(s2.hashCode()); 
        System.out.println("--------");

        System.out.println("hello".hashCode()); //99162322
        System.out.println("world".hashCode()); //113318802
        System.out.println("java".hashCode()); //3254818

        System.out.println("world".hashCode()); //113318802
        System.out.println("--------");

        System.out.println("唱".hashCode()); //21809

        System.out.println("跳".hashCode()); //36339
    }
}

8..HashSet

1.概述

HashSet集合特点

底层数据结构是哈希表
对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以是不包含重复元素的集合

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo01 {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();

        hs.add("java");
        hs.add("python");
        hs.add("scala");

        hs.add("scala");

        Iterator<String> it=hs.iterator();
        while(it.hasNext()){
            String s=it.next();
            System.out.println(s);
            /*python
            java
            scala*/
        }
        System.out.println("==========");

        for(String s:hs) {
            System.out.println(s);
            /*python
            java
            scala*/
        }

    }
}

2.HashSet集合保证元素唯一性源码分析（重要）

HashSet 1.7版本的存储流程

在这里插入图片描述

HashSet练习：

创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求：学生对象的成员变量值相同，我们就认为是同一个对象

思路

学生类：

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;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

测试类：

import java.util.HashSet;

public class HashSetDemo02 {
    public static void main(String[] args) {
        HashSet<Student> hs = new HashSet<>();

        Student s1 = new Student("y1",10);
        Student s2 = new Student("y2",20);
        Student s3 = new Student("y3",30);
        Student s4 = new Student("y3",30);

        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

        for(Student s: hs) {
            System.out.println(s.getName()+","+s.getAge());
            /*y3,30
            y2,20
            y1,10
            y3,30；s4内容和s3重复并存入了，需要重写hashCode()和equals()
            */

            //重写后
            /*
            y1,10
            y3,30
            y2,20*/
        }
    }
}

注意：如果HashSet集合要存储自定义对象，那么必须重写hashcode和equals方法

4.LinkedHashSet集合

LinkedHashSet集合特点

哈希表和链表实现的Set接口，具有可预测的迭代次序

由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

由哈希表保证元素唯一，也就是说没有重复的元素

9.TreeSet集合

1.TreeSet集合概述

元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
- TreeSet()：根据其元素的自然排序进行排序
- TreeSet(Comparator comparator) ：根据指定的比较器进行排序

没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以不包含重复元素的集合


import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();

        //jdk5以后添加元素自动装箱int》integer
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);

        for(Integer i:ts) {
            System.out.println(i);
            /*
            10
            20
            30
            40
            50*/
        }

    }
}

2.自然排序Comparable的使用

案例需求
- 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

实现步骤
- 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

学生类：

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

测试类：

package ceshi;

import java.util.TreeSet;

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

        //创建学生类
        Student s1 = new Student("y1",10);
        Student s2 = new Student("y3",30);
        Student s3 = new Student("y2",20);
        Student s4 = new Student("y4",40);

        Student s5 = new Student("a4",40); //判断按字母排序

        Student s6 = new Student("y4",40); //判断会存储重复值吗

        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历集合
        for(Student s:ts) {
            System.out.println(s.getName()+","+s.getAge());
            /*y1,10
            y2,20
            y3,30
            a4,40
            y4,40*/
        }
    }
}

3.比较器排序Comparator的使用

需求：

存储学生对象并遍历，创建TreeSet集合使用带参构造方法
要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

步骤：

用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元索进行排序的
比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(To1,T o2)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

学生类：

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

测试类：

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

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = 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;
            }
        });

        Student s1 = new Student("y2",20);
        Student s2 = new Student("y1",10);
        Student s3 = new Student("y3",30);
        Student s4 = new Student("y4",40);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        for(Student s:ts) {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

练习：不重复的随机数

编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo {
    public static void main(String[] args) {
//        Set<Integer> set = new HashSet<>();
        Set<Integer> set = new TreeSet<>();

        Random r = new Random();
        //判断集合是否《10
        while(set.size()<10) {
            int number = r.nextInt(20)+1;
            set.add(number); //把随机数添加到集合
        }

        for (Integer i:set) {
            System.out.print(i+" "); //1(哈希set集合）：16 17 2 20 8 9 10 11 14 15
            //2（TreeSet集合)：1 3 4 5 6 7 8 10 16 19 
        }
    }
}

TreeSet的主要功能用于排序
LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)
HashSet只是通用的存储数据的集合

天演L

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
JAVA集合（上篇）

是单列集合的顶层接口，它表示一组对象，这些对象也称Collection元素JDK不提供此接口的直接实现，它提供更具体的子接口（Set 和 List）实现//创建Collection集合的对象//添加元素：boolean add(E e)//输出集合对象1.有序集合(也称为序列)，用户可以精确控制列表中每个元索的插入位置。用户可以通过整数索引访问元素,并获取列表中的元素2.与Set集合不同，List集合允许重复的元素List集合特点1.有索引2.有序: 存储和取出的元素顺序一致。
复制链接

扫一扫