Java泛型

最新推荐文章于 2024-11-02 15:52:57 发布

雪芙花

最新推荐文章于 2024-11-02 15:52:57 发布

阅读量174

点赞数

文章标签： java 开发语言泛型

本文链接：https://blog.csdn.net/yin_ming_hui/article/details/133971824

版权

本文详细介绍了Java中的泛型概念，包括泛型类的使用、泛型方法的定义、泛型界限的应用以及函数式接口如Supplier、Consumer、Function和Predicate。此外，还讨论了类型擦除、Lambda表达式和Optional类在处理空值上的作用。

摘要由CSDN通过智能技术生成

文章目录

泛型

泛型

泛型类

例子：

class Score<T>{
    T value;
    public Score(T value){
        this.value = value;
    }

}
public class fanxing {
    public static void main(String[] args) {
        Score<String > score = new Score<>("aaa");
        System.out.println(score.value);
    }
}

泛型将数据类型的确定控制在了编译阶段
- 在编写代码的时候就能明确泛型的类型
- 如果类型不符合，将无法通过编译！
- 因为是具体使用对象时才会明确具体类型，所以说静态方法中是不能用的：
我们在方法中使用待确定类型的变量时
- 因为此时并不明确具体是什么类型
- 那么默认会认为这个变量是一个Object类型的变量
  - 因为无论具体类型是什么，一定是Object类的子类：
因为泛型本身就是对某些待定类型的简单处理，如果都明确要使用什么类型了，那大可不必使用泛型。
- 还有，不能通过这个不确定的类型变量就去直接创建对象和对应的数组：

如果要让某个变量支持引用确定了任意类型的泛型，那么可以使用?通配符

Score<?> score = new Score<>("aaa");
score = new Score<Integer>(111);
Object object = score.value;//但是注意，如果使用通配符，那么由于类型不确定，所以说具体类型同样会变成Object
System.out.println(object);//111

当然，泛型变量不止可以只有一个，如果需要使用多个的话，我们也可以定义多个：

public class Test<A, B, C> {   //多个类型变量使用逗号隔开
    public A a;
    public B b;
    public C c;
}

如果要存放基本数据类型的值，我们只能使用对应的包装类：
```
Test<Integer> test = new Test<>();
```
当然，如果是基本类型的数组，因为数组本身是引用类型，所以说是可以的：

public static void main(String[] args) {
    Test<int[]> test = new Test<>();
}

泛型与多态

不只是类，包括接口、抽象类，都是可以支持泛型的：

public interface Study<T> {
    T test();
}

当子类实现此接口时

我们可以选择在实现类明确泛型类型

interface Study4<T>{
    T test();
}
class A implements Study4<Integer>{//在实现接口或是继承父类时，如果子类是一个普通类，那么可以直接明确对应类型
    @Override
    public Integer test() {
        return null;
    }
}

或是继续使用此泛型让具体创建的对象来确定类型：

interface Study4<T>{
    T test();
}
class A<T> implements Study4<T>{//让子类继续为一个泛型类，那么可以不用明确
    @Override
    public T test() {
        return null;
    }
}

继承也是同样的：

static class A<T> {
    
}

static class B extends A<String> {

}

泛型方法

当然，类型变量并不是只能在泛型类中才可以使用，我们也可以定义泛型方法。

当某个方法（无论是是静态方法还是成员方法）需要接受的参数类型并不确定时，我们也可以使用泛型来表示：
- 在**返回值类型前添加<>**并填写泛型变量表示这个是一个泛型方法
  - ```
  private static <T> T test(T t){
      return t;
  }
```

实际上泛型方法在很多工具类中也有，比如说Arrays的排序方法：

Integer[] arr = {1, 4, 5, 2, 6, 3, 0, 7, 9, 8};
Arrays.sort(arr, new Comparator<Integer>() {   
  	//通过创建泛型接口的匿名内部类，来自定义排序规则，因为匿名内部类就是接口的实现类，所以说这里就明确了类型
    @Override
    public int compare(Integer o1, Integer o2) {   //这个方法会在执行排序时被调用（别人来调用我们的实现）
        return 0;
    }
});

Lambda表达式，像这种只有一个方法需要实现的接口，直接安排了：

Integer[] arr = {1,3,4,523,1,2,2};
Arrays.sort(arr, (o1, o2) -> {
    return o1 - o2;
});
System.out.println(Arrays.toString(arr));

包括数组复制方法：

public static void main(String[] args) {
    String[] arr = {"AAA", "BBB", "CCC"};
    String[] newArr = Arrays.copyOf(arr, 3);   //这里传入的类型是什么，返回的类型就是什么，也是用到了泛型
    System.out.println(Arrays.toString(newArr));
}

泛型的界限

现在有一个新的需求
- 现在没有String类型的成绩了
- 但是成绩依然可能是整数，也可能是小数，这时我们不希望用户将泛型指定为除数字类型外的其他类型，我们就需要使用到泛型的上界定义：
  - ```
  class Score<T extends Number>{ //设定类型参数上界，必须是Number或是Number的子类
      T value;
      public Score(T value){
          this.value = value;
      }
  }
```
只需要在泛型变量的后面添加extends关键字即可指定上界
- 使用时，具体类型只能是我们指定的上界类型或是上界类型的子类，不得是其他类型。否则一律报错：
实际上就像这样：
同样的，当我们在使用变量时，泛型通配符也支持泛型的界限：
- ```
Score<? extends Integer> score = new Score<>(666);
```

下界

Score<? super Integer> score = new Score<>(666);

只不过下界仅适用于通配符，对于类型变量来说是不支持的。下界限定就像这样：

类型擦除

编译时的类型检查

可以不指定类型，直接绕过检查，使用原始 object

Score score = new Score(111);
score.value = "222";
System.out.println(score.value);//222

最终编译完 --》有上界用上界类型，没有上界就是 object 类型
实际上在Java中并不是真的有泛型类型（为了兼容之前的Java版本）因为所有的对象都是属于一个普通的类型
- 一个泛型类型编译之后，实际上会直接使用默认的类型：
- ```
public abstract class A {
    abstract Object test(Object t);  //默认就是Object
}
```

当然，如果我们给类型变量设定了上界，那么会从默认类型变成上界定义的类型：

public abstract class A <T extends Number>{   //设定上界为Number
    abstract T test(T t);
}

那么编译之后：

public abstract class A {
    abstract Number test(Number t);  //上界Number，因为现在只可能出现Number的子类
}

因此，泛型其实仅仅是在编译阶段进行类型检查
- 当程序在运行时，并不会真的去检查对应类型
- 所以说哪怕是我们不去指定类型也可以直接使用：
  - Test test = new Test(); //对于泛型类Test，不指定具体类型也是可以的，默认就是原始类型
- 只不过此时编译器会给出警告：

同样的，由于类型擦除，实际上我们在使用时，编译后的代码是进行了强制类型转换的：

public static void main(String[] args) {
    A<String> a = new B();
    String  i = a.test("10");     //因为类型A只有返回值为原始类型Object的方法
}

实际上编译之后：

public static void main(String[] args) {
    A a = new B();
    String i = (String) a.test("10");   //依靠强制类型转换完成的
}

不支持创建泛型数组
- 要用只能用原始类型：
  - Score<String>[] scores = new Score[10];
- 只不过只是把它当做泛型类型的数组还是可以用的：

函数式接口

函数式接口就是JDK1.8专门为我们提供好的用于Lambda表达式的接口
- 这些接口都可以直接使用Lambda表达式，非常方便，这里我们主要介绍一下四个主要的函数式接口：

Supplier供给型函数式接口

这个接口是专门用于供给使用的，其中只有一个get方法用于获取需要的对象。

@FunctionalInterface   //函数式接口都会打上这样一个注解
public interface Supplier<T> {
    T get();   //实现此方法，实现供给功能
}

比如我们要实现一个专门供给Student对象Supplier，就可以使用：

public class Student {
    public void hello(){
        System.out.println("我是学生！");
    }
}
//专门供给Student对象的Supplier
private static final Supplier<Student> STUDENT_SUPPLIER = Student::new;
public static void main(String[] args) {
    Student student = STUDENT_SUPPLIER.get();
    student.hello();
}

Consumer消费型函数式接口

这个接口专门用于消费某个对象的。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);    //这个方法就是用于消费的，没有返回值

    default Consumer<T> andThen(Consumer<? super T> after) {   //这个方法便于我们连续使用此消费接口
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

使用起来也是很简单的：

//专门消费Student对象的Consumer
private static final Consumer<Student> STUDENT_CONSUMER = student -> System.out.println(student+" 真好吃！");
public static void main(String[] args) {
    Student student = new Student();
    STUDENT_CONSUMER.accept(student);
}

andThen方法继续调用：

public static void main(String[] args) {
    Student student = new Student();
    STUDENT_CONSUMER   //我们可以提前将消费之后的操作以同样的方式预定好
            .andThen(stu -> System.out.println("我是吃完之后的操作！")) 
            .andThen(stu -> System.out.println("好了好了，吃饱了！"))
            .accept(student);   //预定好之后，再执行
}

这样，就可以在消费之后进行一些其他的处理了，使用很简洁的代码就可以实现：

Function函数型函数式接口

这个接口消费一个对象，然后会向外供给一个对象（前两个的融合体）

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);   //这里一共有两个类型参数，其中一个是接受的参数类型，还有一个是返回的结果类型

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

apply方法，这个是我们需要实现的：

//这里实现了一个简单的功能，将传入的int参数转换为字符串的形式
private static final Function<Integer, String> INTEGER_STRING_FUNCTION = Object::toString;
public static void main(String[] args) {
    String str = INTEGER_STRING_FUNCTION.apply(10);
    System.out.println(str);
}

compose将指定函数式的结果作为当前函数式的实参：

public static void main(String[] args) {
    String str = INTEGER_STRING_FUNCTION
            .compose((String s) -> s.length())   //将此函数式的返回值作为当前实现的实参
            .apply("lbwnb");   //传入上面函数式需要的参数
    System.out.println(str);
}

相反的，andThen可以将当前实现的返回值进行进一步的处理，得到其他类型的值：

public static void main(String[] args) {
    Boolean str = INTEGER_STRING_FUNCTION
            .andThen(String::isEmpty)   //在执行完后，返回值作为参数执行andThen内的函数式，最后得到的结果就是最终的结果了
            .apply(10);
    System.out.println(str);
}

Function中还提供了一个将传入参数原样返回的实现：

public static void main(String[] args) {
    Function<String, String> function = Function.identity();   //原样返回
    System.out.println(function.apply("不会吧不会吧，不会有人听到现在还是懵逼的吧"));
}

Predicate断言型函数式接口

接收一个参数，然后进行自定义判断并返回一个boolean结果。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);    //这个方法就是我们要实现的

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

例：

public class Student {
    public int score;
}
private static final Predicate<Student> STUDENT_PREDICATE = student -> student.score >= 60;
public static void main(String[] args) {
    Student student = new Student();
    student.score = 80;
    if(STUDENT_PREDICATE.test(student)) {  //test方法的返回值是一个boolean结果
        System.out.println("及格了，真不错，今晚奖励自己一次");
    } else {
        System.out.println("不是，Java都考不及格？隔壁初中生都在打ACM了");
    }
}

我们也可以使用组合条件判断：

public static void main(String[] args) {
    Student student = new Student();
    student.score = 80;
    boolean b = STUDENT_PREDICATE
            .and(stu -> stu.score > 90)   //需要同时满足这里的条件，才能返回true
            .test(student);
    if(!b) System.out.println("Java到现在都没考到90分？你的室友都拿国家奖学金了");
}

同样的，这个类型提供了一个对应的实现，用于判断两个对象是否相等：

public static void main(String[] args) {
    Predicate<String> predicate = Predicate.isEqual("Hello World");   //这里传入的对象会和之后的进行比较
    System.out.println(predicate.test("Hello World"));
}

判空包装

判空包装类Optional，这个类可以很有效的处理空指针问题。

private static void test(String str){
    Optional
            .ofNullable(str)   //将传入的对象包装进Optional中
            .ifPresent(s -> System.out.println("字符串长度为："+s.length()));  //如果不为空，则执行这里的Consumer实现
}

我们再获取时可以优雅地处理为空的情况：
- 我们可以对于这种有可能为空的情况进行处理，如果为空，那么就返回另一个备选方案：
  - ```
  private static void test(String str){
      String s = Optional.ofNullable(str).orElse("我是为null的情况备选方案");
      System.out.println(s);
  }
```

将包装的类型直接转换为另一种类型：

private static void test(String str){
    Integer i = Optional
                    .ofNullable(str)
                    .map(String::length)   //使用map来进行映射，将当前类型转换为其他类型，或者是进行处理
                    .orElse(-1);
    System.out.println(i);
}