java：set集合

一、set集合的概述和特点

1.Set集合特点

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

2.哈希值

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

Object类中有一个方法可以获取对象的哈希值：public int hashCode（）；//返回对象的哈希码值

结论：

1.同一个对象多次调用hashCode（）方法返回的哈希值是相同的

2.默认情况下 ，不同对象的哈希值是不相同的

3.通过方法重写，可以实现不同对象的哈希值是相同的

3.HashSet集合概述和特点

HashSet集合特点

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

4.常见数据结构之哈希表

1.哈希表

• JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
• JDK8以后，在长度较长是时候，底层实现了优化

2.哈希表存储过程

存储过程理解：我们需要将左边的hello，world....字符串添加到哈希表中。

第一：如何获取哈希表上面对应的数字，需要将他们的哈希值对16取余。可以看到hello对应哈希表上的2，world也对应2...

第二：将hello放到哈希表中的2存在的位置，当把world也存放到哈希表2的位置的时候，就需要跟上一个hello进行对比，比较哈希值发现不一样，将world存放到hello的下面。

第三：同样是world，需要存放到2的位置，首先比较哈希值，发现相同，再比较字符串发现也相同。set集合不存储相同元素，所以要删除。

5.LinkedHashSet集合概述和特点

LinkedHashSet集合特点

• 哈希表和链表实现的Set接口，具有可预测的迭代次序
• 由链表保证元素有序，也就是说元素的存储
• 由哈希表保证元素唯一，也就是没有重复的元素

二、TreeSet集合概述和特点

特点

1.元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法

TreeSet（）：根据其元素的自然排序进行排序

TreeSet（Comparetor conmparator），根据指定的比较器进行排序

2.没有带索引的方法，所以不能使用for循环遍历

3.由于是set集合，所以不包含重复元素

1.使用TreeSet构造方法观察集合的排列顺序

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer>treeSet= new TreeSet<Integer>();//泛型里面使用基本类型的包装类

        //添加元素
        treeSet.add(10);//这里添加的是int类型的，因为可以自动装箱
        treeSet.add(40);
        treeSet.add(30);
        treeSet.add(20);
        treeSet.add(50);

        //遍历集合
        for (Integer i:treeSet){
            System.out.println(i);
        }
    }
}

结果展示

总结：使用TreeSet构造方法按照基本类型从低到高进行排序。

2.自然排序Comparable的使用

代码完成一个存储学生对象，并按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

新建学生对象使它继承Comparable接口

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 s) {
//        return 0;
//        return 1;
//        return -1;
        //按照年龄从小到大排序
        int num =this.age - s.age;
        //年龄相同时，按照姓名的字母顺序排序
        int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

新建一个测试类

/**
 * 存储学生对象并遍历，创建集合使用无参构造方法
 * 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();

        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);
        Student s5 = new Student("linqingxia", 33);

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

        //遍历集合
        for (Student s:ts){
            System.out.println(s.getName()+","+s.getAge());
        }

    }
}

测试结果

总结：

• 使用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
• 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo（T o）方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

3.比较器排序Comparator的使用

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

创建学生类

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

测试类代码

/**
 * 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
 * 要求：按照年龄从大到小排序，年龄相同时，按照姓名的字母顺序排序
 */
public class TreeSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts= new TreeSet<Student>(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("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);
        Student s5 = new Student("linqingxia", 33);

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

        //遍历集合
        for (Student s:ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

测试结果

总结

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

三、泛型

1.泛型概述

泛型：时JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型他的本质是参数化类型，也就是说所操作的类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型这种参数类型可以用在类、方法和接口中，分别被称为泛型类，泛型方法，泛型接口。

2.泛型定义格式：

• <类型>：指定一种类型的格式，这里的类型可以看成形参
• <类型1，类型2...>指定多种类型格式，多种类型之间用逗号隔开。这里的类型可以看成形参
• 将来具体调用的时候给定的类型可以看成实参，并且实参的类型只能是引用数据类型

3.泛型的好处

• 把运行期的问题提前到了编译期间
• 避免了强制类型转换

4.泛型类

泛型类的定义格式：

• 格式：修饰符class类型<类型>{}
• 范例：public class Generic<T>{}      (此处T可以随便写为任意标识，常见的如T,E,K.V等形式的参数常用于表示泛型)

5.泛型方法

泛型方法的定义格式：

• 格式：修饰符<类型>返回值类型方法名（类型  变量名）{}
• 范例：public<T>void show(T t){}

泛型类的使用案例

新建一个类，放置一个泛型方法

//泛型类演示
public class Generic {
    //泛型方法
    public <T> void show(T t){
        System.out.println(t);
    }
}

测试代码

public class Demo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("林青霞");
        g.show(30);
        g.show(true);
        g.show(12.34);
    }
}

总结：泛型方法只需要实例化一次，跟泛型类不一样，泛型类每次使用都要实例化一次。泛型方法你每次传入的是什么类型就会得到什么类型。

6.泛型接口

泛型接口的定义格式：

• 格式：修饰符interface接口名<类型>{}
• 范例：public interface Generic<T>{}

7.泛型通配符

为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符：<?>
• List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型
• 这种带通配符的List仅代表他是各种泛型List的父类，并不能把元素添加其中

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上线

• 类型通配符上限：<?extends 类型>
• List<?extends Number>:它表示的类型是Number或者其子类类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下线

• 类型通配符下线：<?super 类型>
• List<?super Number>:它表示的类型是Number或者其父类型

8.可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

• 格式：修饰符  返回值类型  方法名（数据类型...变量名）{}
• 范例：public static int sum （int...a）{}

代码展示

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));

        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));


    }
//    public static int sum(int a,int b){
//        return a+b;
//    }
//    public static int sum(int a,int b,int c){
//        return a+b+c;
//    }
//    public static int sum(int a,int b,int c,int d){
//        return a+b+c+d;
//    }
//
//
//    public static int sum(int a,int b,int c,int d,int e){
//        return a+b+c+d+e;
//    }
//    public static int sum(int a,int b,int c,int d,int e,int f){
//        return a+b+c+d+e+f;
//    }
//    public static int sum(int a,int b,int c,int d,int e,int f,int g){
//        return a+b+c+d+f+e+g;
//    }


    //使用可变参数
//    public static int sum(int ...a){
//        System.out.println(a);
//        return 0;
//    }
    //输出的结果
    /**
     * [I@677327b6
     * 0
     * [I@14ae5a5
     * 0
     * [I@7f31245a
     * 0
     * [I@6d6f6e28
     * 0
     * [I@135fbaa4
     * 0
     * [I@45ee12a7
     * 0
     * 可以看出a是一个数组并且是int类型的
     */


    //本质是数组中的数据逐个相加
    public static int sum(int ...a){
        int sum =0;
        for(int i:a){
            sum+=i;
        }
        return sum;
    }


}

运行结果：

注意：当方法中包含可变参数和不可变参数时，可变参数应该放在最后

代码展示

    public static int sum(int b,int ...a){
        int sum =0;
        for(int i:a){
            sum+=i;
        }
        return sum;
    }

可变参数注意事项

• 这里的变量其实是一个数组
• 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

9.可变参数的使用

Arrays工具类中有一个静态方法：

public static <T>List<T>asList(T ...a);返回由指定数组支持的固定大小的列表

返回的集合不能做增删操作，可以做修改操作。

List接口有一个静态方法：

public static <E>List<E>of(E...elements);返回包含任意数量元素的不可变列表

返回的集合不能做增删改操作。

set接口中有一个静态方法：

public staic<E>Set<E>of(E...elements);返回一个包含任意数量元素的不可变集合

在给元素的时候，不能给重复元素

返回的集合不能做增删操作，没有修改的方法