泛型&Set集合

最新推荐文章于 2023-02-15 15:17:20 发布

原创最新推荐文章于 2023-02-15 15:17:20 发布 · 289 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

JavaSE 专栏收录该内容

15 篇文章

订阅专栏

本文详细介绍了Java泛型的概念、好处、定义格式及使用场景，包括泛型类、泛型方法、泛型接口。泛型提供编译时类型安全，避免运行时类型转换异常。同时讲解了类型通配符的使用，包括无限制、上限和下限。最后通过示例展示了Set集合，特别是TreeSet的排序特性，包括自然排序和比较器排序。

泛型

1. 概述

介绍

在没有泛型前，要想实现一个通用的、可以处理不同类型的方法，就需要使用所有类的父类—>Object来作为属性和方法参数，然而当我们需要使用特定的类的方法时，就必须进行强制转换，而且这个强转很可能出现转换异常：ClassCastException

而方向在编译时期就可以检查出因Java类型不正确导致的类型转换异常，提供了编译时类型安全检测机制
好处
- 把运行时期的问题提到了编译期间
- 避免了强制类型转换
定义格式
- <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如:
- <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>
使用场景
- 泛型类 -> class 类名<类型>{ }
- 泛型方法 -> 修饰符 <类型> 返回值类型方法名(类型变量名) { }
- 泛型接口 ->修饰符 interface 接口名<类型> { }

2. 泛型类

定义格式
```
修饰符 class 类名<类型> {  }
```
注意
- 类名后面的 <类型> 可以有多个，用 , 隔开即可
- 泛型类的最常见用途就是作为容器类，比如 Java 集合容器类

代码

public class GenericityDemo01 {
    public static void main(String[] args) {
        Box<String> box1 = new Box<>();
        box1.setE("String类型");
        System.out.println(box1.getE());//String类型

        Box<Integer> box2 = new Box<>();
        box2.setE(111);
        System.out.println(box2.getE());//111
    }
}

//泛型类
class Box<E>{
    private E e;

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }
}

3. 泛型方法

定义格式

修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }

泛型方法是在被调用的时候有了具体类型

代码

public class GenericityDemo02 {
    public static void main(String[] args) {
       ArrayList<String> arrayList = new ArrayList<>();
       addArrs(arrayList,"1","2","3");
    }

    public static <T> void addArrs(ArrayList<T> array,T t1,T t2,T t3){
        array.add(t1);
        array.add(t2);
        array.add(t3);
        System.out.println(array);
    }
}

4. 泛型接口

泛型接口的使用方式
- 实现类也不给泛型（那默认类型就是 Object，就没有意义了）
- 实现类确定具体的数据类型

定义格式

修饰符 interface 接口名<类型> {  }

代码

//测试类
public class GenericityDemo03 {
    public static void main(String[] args) {
        GenericityImpl gi = new GenericityImpl();
        Integer method = gi.method(1);
        System.out.println(method);//2
    }
}

//泛型接口
interface Genericity<E>{
    E method(E e);
}

//泛型接口的实现类
class GenericityImpl implements Genericity<Integer>{

    @Override
    public Integer method(Integer integer) {
        return ++integer;
    }
}

5. 类型通配符

类型通配符：<?>

表示元素类型未知，它的元素可以匹配任何的类型

但是这样就会使得一些应该正确的基本操作都无法实现

public class GenericityDemo04 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>() ;
        addList(arrayList);
    }

    private static void addList(ArrayList<?> arrayList) {
        arrayList.add("ssss");//Error:(12, 23) java: 不兼容的类型: java.lang.String无法转换为capture#1, 共 ?
    }
}

类型通配符上限：<? extends 类型>
- ArrayListList <? extends Number> ：它表示的类型是Number或者其子类型(<=Number)
类型通配符下限： <? super 类型>
- ArrayListList <? super Number>: 它表示的类型是Number或者其父类型（>=Number）

代码

public class GenericityDemo04 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Number> list3 = new ArrayList<>();
        ArrayList<Object> list4 = new ArrayList<>();

        method(list1);
        method(list2);
        method(list3);
        method(list4);

        getElement1(list1);
        getElement1(list2);//报错
        getElement1(list3);
        getElement1(list4);//报错

        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
    }

    // 泛型通配符: 此时的泛型?,可以是任意类型
    public static void method(ArrayList<?> list){}
    // 泛型的上限: 此时的泛型?,必须是Number类型或者Number类型的子类
    public static void getElement1(ArrayList<? extends Number> list){}
    // 泛型的下限: 此时的泛型?,必须是Number类型或者Number类型的父类
    public static void getElement2(ArrayList<? super Number> list){}
}

Set 集合

1. Set

特点
- 不可存储重复元素（去重）
- 存取顺序不一致（因为set集合底层不是使用的数组结构）
- 没有索引

基本使用

public class SetDemo01 {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("ccc");
        set.add("ccc");
        set.add("aaa");
        set.add("bbb");

        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
            //aaa
            //bbb
            //ccc
        }
        System.out.println("--------------");
        for (String s : set) {
            System.out.println(s);
            //aaa
            //bbb
            //ccc
        }
    }
}

2. TreeSet

特点
- 可以将元素按照规则进行排序（字符串和数字，都可以默认排序，从小到大）
  - TreeSet() :根据其元素的自然排序进行排序
  - TreeSet(Comparator comparator) ：根据指定的比较器进行排序
注意
- 想要使用TreeSet，需要制定排序规则

代码

public class TreeSetDemo03 {
    public static void main(String[] args) {
        TreeSet<Integer> its = new TreeSet<>();
        its.add(5);
        its.add(1);
        its.add(1);
        its.add(3);
        System.out.println(its);//[1, 3, 5]

        TreeSet<Shape> shapes = new TreeSet<>();
        shapes.add(new Shape(10));
        shapes.add(new Shape(9));
        shapes.add(new Shape(11));
        System.out.println(shapes);//ClassCastException

    }
}
class Shape{
    private Integer area;

    public Shape() {
    }

    public Shape(Integer area) {
        this.area = area;
    }

    public Integer getArea() {
        return area;
    }

    public void setArea(Integer area) {
        this.area = area;
    }

    @Override
    public String toString() {
        return "Shape{" +
                "area=" + area +
                '}';
    }
}

3. 自然排序 Comparable

概述
- 在上面的例子中，我们可以看到，在使用我们自己定义的Shape类的时候，TreeSet集合并不能有效的去排序我们的Shape类型的数据。
- 这时候我们就需要在Shape类中实现Comparable接口
- 重写接口中的compareTo方法

代码

class Shape implements Comparable<Shape>{
    private Integer area;

    public Shape() {
    }

    public Shape(Integer area) {
        this.area = area;
    }

    public Integer getArea() {
        return area;
    }

    public void setArea(Integer area) {
        this.area = area;
    }

    @Override
    public String toString() {
        return "Shape{" +
                "area=" + area +
                '}';
    }

    @Override
    public int compareTo(Shape o) {
        return this.area - o.area;
    }
}

4. 比较器排序 Comparator

用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法

代码

public class TreeSetDemo02 {
    public static void main(String[] args) {
        TreeSet<Teacher> teachers = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                int result = o1.getAge()-o2.getAge();
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });

        teachers.add(new Teacher("zs",10));
        teachers.add(new Teacher("ls",12));
        teachers.add(new Teacher("ww",14));
        teachers.add(new Teacher("zl",14));

        System.out.println(teachers);

    }
}

class Teacher {
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Teacher(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Teacher() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    }

5. 两种比较方式的总结

两种比较方式小结
- 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
- 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
- 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序
两种方式中关于返回值的规则
- 如果返回值为负数，表示当前存入的元素是较小值，存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果返回值为正数，表示当前存入的元素是较大值，存右边