【Java5 特性】2.Java泛型

其他 2021-03-24 23:00:15 阅读次数: 0

目录

一、泛型概念

二、泛型的应用

1、泛型类

2、泛型接口

3、泛型方法

4、泛型数组

三、泛型通配符

1、无边界通配符

2、有边界限定通配符

四、类型擦除

小结

一、泛型概念

泛型是Java5引入的一种特性，本质上是参数化类型，即把原有具体的类型当做一种参数使用，有点类似函数中的形参和实参的使用（比如定义函数使用形参，而调用函数则使用实参）。举个例子说明，比如List集合接口的定义：public interface List<E> extends Collection<E> {...}，这里的List<E>可理解为一种类型形参，而我创建List集合的实例  List<String> list = new List<>(); ，这里的List<String>便可理解为一种类型实参。

泛型提供了一种在编译时的类型安全检查机制，防止在编译期间有不合法的类型存在。举个例子说明：比如Set set = new HashSet(); ，我们可以通过set.add("新年快乐！"); set.add(2021); set.add(false); 等方式往Set集合中加入任意类型的值，然后通过fori遍历时又想强转成String类型使用，这一切看起来没什么问题，启动程序运行之前也没有任何错误提示，但编译后的结果显示了 ClassCastException异常。我们把代码改成Set<String> set = new HashSet<>(); 后，在add加入上面那些内容，则会检查并提示类型不符，无法加入2021和false等内容，泛型在编译期间进行类型安全检查，并表明了操作的合法数据类型，这就是泛型存在的最直观优势了！

当然，泛型还可以自动的隐式的进行类型转换。当不指定类型时，编译器会提示你要进行强转，比如 List list = new ArrayList(); ，通过list.set(1, "新年快乐！"); 设置一个初始值，然后通过强制转换String str = (String)list.get(1); 才能通过编译。我们把代码改成List<String> list = new ArrayList();，重复上面步骤，就不需要在get时强转了。

泛型可用于接口，类，方法中，分别称为泛型接口，泛型类，泛型方法，而与接口，类，方法相比，实现泛型数组似乎特殊了点，这些实现过程中需要注意的一些问题，后面会分析到。

使用泛型时，你是否注意过这些符号，如？，E，T，U，R，K，V等等，它们被称为泛型通配符，它们本质上没什么区别，只是泛型使用的一种标记或约定。约定规则为：？表示的是不确定的或未知的Java类型，可看作是无边界通配符；E是element的简写，表示的是元素类型，用于Java集合结构 ；T是Type的简写，表示的是任意的Java类型，有时也可以用临近的U，R表示；K，V则表示的是键和值（key-value），用于Map映射结构。另外，一些通配符搭配 super 和 extends关键字使用，又可以当做有边界的通配符，后面会分析到。

最后值得一提的便是类型擦除了，擦除的概念也很好理解，就是JVM里并没有泛型的概念，只是我们在代码层面使用了泛型，当JVM启动并编译程序时，会将所有的泛型类及泛型方法的类型参数去掉，最好的验证是编写一段泛型代码去执行，然后打开生成的class文件就能发现其奥秘了，因此，类型擦除也可以看作是一种Java语法糖。

二、泛型的应用

Java5引入的泛型，早已经是Java中最基础、最重要的知识点了，像《Java编程思想》、《Java技术核心 卷I》等经典书籍都花了很多的篇幅介绍Java泛型。打开jdk源码，我们可以看到泛型普遍应用在了接口，类，方法上，尤其是Java集合。这里，我们将与泛型相关的变量称为类型变量。

1、泛型类

泛型类指的是具有一个或多个类型变量的类，通用格式为：修饰符  class  ClassName<通配符列表> {} 。

比如泛型类LinkedList<E>中，将E换成String或其他具体的类型，像LinkedList<String>、LinkedList<Long> 等，就可以完成泛型类型的实例化，因此可以把泛型类理解为普通类的工厂。

JDK常见的泛型类：（以Optional泛型类为例）

/** 如：Java8新增的Optional泛型类 */
public final class Optional<T> {
    /**  类型变量 */
    private final T value;

    /** Optional构造器 */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    /** 调用Optional构造器，of()方法可实现静态创建Optional对象 */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    ......
}

为了方便理解Optional泛型类，可以将该泛型类中抽象的T当作具体的类型来分析，比如把T替换成Integer。泛型类的通配符可以有多个，比如：自定义泛型类Mouse<T, U>、自定义泛型类Mouse<T, U, S>等。

2、泛型接口

泛型接口的通用格式为：修饰符  interface  InterfaceName<通配符列表> {} ，实现泛型接口一般有两种方式：一种像Character普通类实现了泛型接口，另一种像ArrayList泛型集合类实现了泛型接口，如下：

/** Character类 实现了Comparable泛型接口 */
public final class Character 
    implements java.io.Serializable, Comparable<Character> {
    ......
}

/** ArrayList类 实现了List泛型集合接口 */
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    ......
}

JDK常见的泛型接口：（以Comparable泛型接口为例）

/** 比较器Comparable泛型接口 */
public interface Comparable<T> {
    public int compareTo(T o);
}

泛型接口的通配符可以指定多个，以Java8新增的java.util.function包下的函数式接口为例：比如BiConsumer<T, U>、Function<T, R> 、BiFunction<T, U, R>等。

3、泛型方法

上面讲到的泛型类和泛型接口内都可以定义泛型方法，当然普通类与普通接口也可以定义泛型方法，泛型方法的通用格式为：修饰符  <参数类型> 泛型返回值  methodName(通配符列表) {...} 。

对泛型方法的调用，比如调用上面的Optional泛型类的of()泛型方法，原始写法为 Optional.<String>of("新年好啊！"); ，这样写看起来很晦涩且不美观。实际大多数情况下，调用泛型方法时可以省略<String>类型参数，编译器会根据赋值的类型 和 泛型类型推断出调用泛型方法的参数类型。

JDK常见的泛型方法：（以List泛型集合接口为例，E表示集合的元素类型）

/** List泛型集合接口 */
public interface List<E> extends Collection<E> {
    /** 以以下几个接口方法为例 */
    boolean add(E e);
    E get(int index);
    boolean addAll(Collection<? extends E> c);
    Iterator<E> iterator();
    ......
}

实际中，在创建接口实例时，通过new构造器的方式确定了E的具体类型，之后调用泛型方法add()、get()等都会按照该具体类型进行操作。而像addAll()方法的类型变量需要是一个Collection集合，且要保证该集合内元素类型不能超过E对应的类型，也就是说 ，?类型是E类型 或 E类型的子类型，否则编译阶段检查会报错。有时候，类、接口或方法中为了更好的表明类型变量的使用范围，需要对类型变量加以限定或约束，通常使用extends 或 super 来限定，限定用法在分析通配符时再作详细说明。

4、泛型数组

以上讨论的泛型大多数是在Java集合容器的使用，而泛型是怎么在数组上创建、声明及使用的呢？下面编写一个测试示例，在Test类中定义了以下测试方法：

public class Test{
    /** 测试一：创建带有？通配符的List泛型数组 */
    public static void test1(){
        List<?>[] lists = new List<?>[5];
        lists[0] = Collections.singletonList("新年快乐！");
        lists[1] = Collections.singletonList(2020);
//        lists[2] = "happy new year！"; // error
//        lists[3] = 3.1415; // error
        for (int i = 0; i < lists.length; i++) {
            System.out.println(lists[i] + " "); // [新年快乐！] [2020] null null null
            // 转换成String数组
            String[] strings = (String[]) lists[i].toArray(); // java.lang.ClassCastException
            System.out.println(strings + " ");
        }
    } 

    /** 测试二：创建具体类型的List泛型数组，会编译报错*/
    public static void test2(){
        List<String>[] lists = new List<String>[5]; // compile error
    }

    /** 测试三：强转成具体类型的List泛型数组 */
    public static void test3() {
        @SuppressWarnings("unchecked")
        List<String>[] lists = (List<String>[]) new List[5];

        lists[0] = Collections.singletonList("2020");
        lists[1] = Collections.singletonList("2021");
//        lists[2] = Collections.singletonList(2020); // error
        for (int i = 0; i < lists.length; i++) {
            System.out.print(lists[i] + " ");  // [2020] [2021] null null null

            // List<String>[]的String[] 强转成 Integer[]
            Integer[] integers = (Integer[]) lists[i].toArray(); // java.lang.ClassCastException
            System.out.println(integers + " ");
        }

        // List<String>[]的String[] 强转成 Integer[]
        Integer[] integerArr = (Integer[]) Arrays.stream(lists).toArray(); // ok
        for (int i = 0; i < integerArr.length; i++) {
            System.out.println(integerArr[i] + " ");
        }
    }

    /** 测试四：只声明具体类型的List泛型数组*/
    public static void test4(){
        List<String>[] lists = null;
        lists[0] = Collections.singletonList("新年快乐！"); // NPE
        for (int i = 0; i < lists.length; i++) {
            System.out.print(lists[i] + " ");
        }
    }
}

test1()方法使用了？通配符直接构造了List泛型数组， 而？代表不确定类型，可以给该List泛型数组赋任意类型的固定值（注意不能直接赋值！），然后去遍历该List泛型数组，但是想要强转成String[]使用，由于虚拟机在编译阶段进行了泛型的类型擦除，此时会出现类型转换错误；

test2()方法则直接构造具体类型的List泛型数组，编辑器提示了错误，说明这种方式不允许使用的，究其原因大致如下：创建一个数组时，数组必须要知道所持有对象的具体类型，而运行时泛型类型会被擦除，这显然违背了数组的要求，因此不能直接构造具体类型的泛型数组；

test3()方法是基于test2()方法进行了类型强转，强转不会报错但编辑器会出现警告信息，可以使用@SuppressWarnings("unchecked")注解消除警告，也是由于虚拟机在编译阶段进行了泛型的类型擦除，通过toArray()方法强转成目标类型均会出现类型转换错误！！

最后，test4()方法只进行了声明并没有初始化，因此不能进行后续的赋值和遍历操作，赋值一定会报NPE异常。

从上面的分析中我们可以总结出：

  1. 不能直接构造具体类型的泛型数组，但可以通过强制转换的方式构造具体类型的泛型数组，也可以只声明具体类型的泛型数组，另外，也可以通过？通配符的方式直接构造出未知类型的泛型数组；
  2. 虽然通过不同的方式构造出了泛型数组，但是JVM存在类型擦除机制 —— 会将参数类型当做原始类型去处理，因此，进行强转成目标类型数组时，总是会抛java.lang.ClassCastException异常！

上面的例子都是对List数组所持有的对象类型String进行参数化，使用过程中充满着各种危险，想一想真的是太为难自己了.....，那么我们直接对数组所持有的对象进行参数化，结果会什么样的呢？ArrayList<E>集合类中带参的toArray()方法就是一个不错的例子：

    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

该方法的功能是，返回运行时指定类型的数组，传入的T[]是数组本身类型，也就是说数组的类型在运行时就已确定了，避免了被JVM擦除类型，这样自然能通过强转的方式转换了。当然，也要注意T[]不能为null，数组的元素也要保持类型一致（直白一点就是：是String就得都是String，不能包含其他类型）。

经过上面的一系列demo测试使我深深的体会到，如果不能正确认识和理解泛型数组存在的问题，使用泛型数组编码必定会困难重重，且到处是坑。那么怎样才能正确的且安全的去构造和使用泛型数组呢？从toArray()方法带给我们的启示可知，在运行时就要确定好数组的类型，从而避免出现泛型擦除，这样才能真正的转型成功，不会出现类型转换错误。

基于这种思路，我们可以利用反射机制，在运行时构造出确定类型的对象数组，这样才正确且安全，demo演示如下：

public class GenericArrayDemo<T> {
    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArrayDemo(Class<T> tClass, int size) {
        array = (T[]) Array.newInstance(tClass, size); // 通过反射机制，确定运行时的数组类型
    }

    public T[] getArray() {
        return array;
    }

    public static void main(String[] args) {
        GenericArrayDemo<String> demo = new GenericArrayDemo<>(String.class, 8);
        String[] strings = demo.getArray();
        System.out.println(strings.length); // 8

        GenericArrayDemo<Double> genericArrayDemo = new GenericArrayDemo<>(Double.class, 10);
        Double[] doubles = genericArrayDemo.getArray();
        System.out.println(doubles.length); // 8
    }
}

三、泛型通配符

1、无边界通配符

常见的泛型通配符含义前面已经解释了，通配符是作为使用泛型时的一种约定，比如？和E本质上是没啥区别的，比如List<E>集合也可以写成List<?>。然而没有规矩不成方圆，约定就是约定，还是要遵守的了，但有没有想过List<?>和原始的List有何区别呢。

经测试，自定义的List<?>泛型接口是不能添加对象的，因为？表示不确定的类型，理所当然不能有添加方法了，甚至无法定义List<?>接口.而原始的List默认拥有的元素是Object类型，可以添加任意Object类型，如下：

public class Test {
    public static void main(String[] args) {
        // 原始List集合，能添加任意Object元素 
        List list = new ArrayList();
        list.add("新年好啊！");
        list.add(3.1415926);
        list.add(false);
    }
}
/** 定义List<?>泛型接口，编辑器检查报错，不支持这种类型 */
interface List_1<?> {
    boolean add(? o);
}

因此，?表达的类型是未知的，最好不要去使用，像List<?>中的 ? 通配符被称为无边界通配符。一般地，没有对类型变量进行限定或约束的，比如List<E>、Optional<T>、Map<K, V>等中的通配符，我们也可以看作是一种无边界通配符（只是与?相比，它们标记的使用场景是具体的）。

不加限定的通配符使用起来很简单，但也容易引发一些的问题，举个例子，自定义一个泛型方法maxBy()，它使用Comparable接口的compareTo()方法实现寻找对象数组最大值功能：

public class Test{
    public static <T> T maxBy(T[] values){
        if (StringUtils.isEmpty(values))
            return null;
        // 使用Comparable接口的方法比较
        T maxValue = values[values.length - 1];
        for(int i = values.length - 2; i >= 0; i--)
            maxValue = maxValue.compareTo(values[i]);
        return maxValue;
    }

    /** 调用maxBy()获取指定数组最大值 */
    public static void main(String[] args) {
        String[] strings;
        Double[] doubles;
        LocalDateTime[] times;
        String maxStr = Test.maxBy(strings);
        Double maxDouble = Test.maxBy(doubles);
        LocalDateTime maxTime = Test.maxBy(times);
    }
}

class A {
    ......
}

这里的类型变量T 代表了任意对象类型，使用时可指明为String类、Double类、LocalDateTime类等对象类型，然而自定义一个类A，把类型变量T 换成类A的对象类型，调用maxBy()方法却会报编译错误。因为String、Double、LocalDateTime等类都实现了Comparable接口，它们的对象类型才能去替换类型变量T。因此，需要对类型变量加以限定，来表明实例化时可替换的对象类型，这里将maxBy()方法改造一下：<T extends Comparable> T maxBy(T[] values) ，这样看起来语义表达就很清晰了。

2、有边界限定通配符

Java中，在类，接口或方法上，使用 extends 或 super 限定类型变量，此时的通配符（即类型变量）就具有了有界特性，我们将 A extends BoundingType 称为上界限定（或者子类型限定，通配符A则是上界限定通配符了），将 B super BoundingType 称为下界限定（或者超类型限定，通配符B则是下界限定通配符了）。

上界限定表达形式：A extends BoundingType，其中BoundingType 为限定类型，A为 BoundingType 的子类型（包括了A 为 BoundingType本身），A 和 BoundingType可以是类，也可以接口，而使用extends 关键字则能更清晰表达出这种子类型的关系。BoundingType 可以有多个限定类型，用&隔开表示（例如：T extends RandomAccess & Serializable）。

下界限定表达形式：B super BoundingType，同样的BoundingType 为限定类型，B 为 BoundingType 的父类型（包括了B 为 BoundingType本身），使用super 关键字则能更清晰表达出这种父类型的关系。

有很多人包括我初次接触到泛型时，看到<T, U extends Comparable<? super U>>这种泛型的声明（据说目的是为了帮助程序员排除调用参数上不必要的限制），简直头皮发麻有木有，哈哈哈哈。有了上面的基础之后，这个泛型声明看起来没那么恐怖了，以Comparator接口源码中的几个泛型方法为例，分析下有界限定通配符的应用：

/** Comparator泛型接口，以其中的几个方法为例分析 */
@FunctionalInterface
public interface Comparator<T> {
    /** compare() */
    int compare(T o1, T o2);
    
    /** comparing() */
    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

    /** thenComparing() */
    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }

    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
    
    ......
}

Comparator接口用注解@FunctionalInterface被标记成了一个函数式接口，关于函数式接口可以参考我的另一篇文章：Lambda表达式与函数式接口。Java8开始，允许接口有方法的默认实现，这大大的增强了Comparator接口的功能，其中：

int compare(T o1, T o2);

  • 是一个抽象方法，Java8之前使用函数式接口进行比较，需要通过new Comparator的方式并重写该方法；

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor){...}

  • 是一个静态方法，有具体的逻辑实现，可直接通过 Comparator.comparing(参数) 的方式调用；
  • 先分析该方法的参数，该参数是一种Function的函数式接口，Function是有参数有返回值的，其中? super T表示的是入参参数类型（即通配符?的类型是T 或T 的父类型），? extends U表示的是返回值类型（即通配符?的类型是U 或U 的子类型）；
  • 再分析该方法的返回值，返回类型的是Comparator<T>类型，该类型的泛型声明为<T, U extends Comparable<? super U>>，这个声明的意思是：比较时入参类型是T， 返回值类型U是实现了Comparable接口的类型，而Comparable接口本身也是泛型接口，继续使用? super U限定返回值类型；
  • 上面的T，U限定类型都是抽象的，通过实例化指明具体的类型后便可豁然开朗，举个例子说明 —— 自定义一个类：Milk，该类不实现任何接口，再写一个方法：Double getMilkPrice(){}，最后要想比较牛奶的价格：Comparator<Milk> price =  Comparator.comparing(Milk -> Milk.getMilkPrice()); ，这里T被具化成了Milk的实例类型，U被具化成了Double对象类型，Double则是一个实现了Comparable<Double>接口的包装类。为了验证限定类型U 是否能具化为Milk的实例类型，可修改代码：Comparator<Milk> price =  Comparator.comparing(Milk -> Milk);，结果如下图，报了一个编译错误！说明上面的分析是完全正确的！

default <U extends Comparable<? super U>> Comparator<T> thenComparing(Function<? super T, ? extends U> keyExtractor) {...}

  • 是一个默认方法，有具体的逻辑实现，需要通过Comparator实例的引用去调用thenComparing(参数)；
  • 有了上面静态方法的分析，这个方法中有界限定通配符相对简单了，Function接口的入参和返回值类型同理，该方法的Comparator<T>的泛型声明只声明返回值的限定<U extends Comparable<? super U>>；
  • 接着上面的例子：Comparator<Milk> nbr = price.thenComparing(Milk->Milk.getNbr()); ，T、U分别用具体的Milk实例、String对象替代了，而String是一个实现了Comparable<String>接口的类。

四、类型擦除

编写一段常见集合泛型使用的测试代码：

import java.util.*;

public class Test{
   public static void main(String[] args) {
      List<String> list = new ArrayList<>();
      Set<Integer> set = new HashSet<>();
      Map<String,Long> map = new HashMap<>();
   }
}

再打开编译后生成的class文件：

/** Test.class */
public class Test {
  public static void main(String[] paramArrayOfString) {
    ArrayList arrayList = new ArrayList();
    HashSet hashSet = new HashSet();
    HashMap hashMap = new HashMap();
  }
}

这就是所谓的类型擦除了，对于JVM而言是没有泛型的，只有普通的类、普通的方法及原始类型。在编译过程中，所有泛型的类型参数都是通过它们的限定参数来替换的，有时候为了类型的安全性，可能会使用强制类型转换。

Java泛型也是一把双刃剑，给我们带来类型安全检查、类型自动转换等优势的同时，也产生了诸多的限制和约束问题，而这些问题大多数是由类型擦除引起的，下面盘点一下这些限制：

1、泛型的类型参数不能是基本类型

如：Milk<int>会编译报错。这是因为类型擦除后，原始类型会用Object代替类型参数，而Object是不能存放基本类型值的。

2、运行时的类型的查询比较不能是泛型

如：假设类型变量m,n均为泛型类的实例引用，if(m  instanceof  n) 或 if(m == n) 会编译报错。这是因为JVM没有泛型，只有原始类型，无法进行泛型类型的查询或比较。

3、不能直接构造具体类型的泛型数组

如：Optional<String>[] strings = new Optional<String>[10]; 会编译报错，但可以声明具体类型的泛型数组，或构造时可以强转成具体类型的泛型数组。

4、不能实例化类型变量

如：new T()；会编译报错，不能实例化泛型类的类型变量，但可以实例化泛型类，如Test<T> a = new Test<T>(); 是可以的。这是因为在编译期间没法确定泛型参数化类型，也就找不到对应的类字节码文件，因此不能实例化泛型类的类型变量。

5、不能使用带有类型变量的静态属性和静态方法

如：private static T data; //编译报错  public static T getData() { return data; } //编译报错。这是因为拥有类型变量的静态成员是类中所有对象共享的，且该静态成员在类中也只存在独立的一份，假如A对象需要将T替换成String类型去调用该静态成员，B对象需要将T替换成Long类型去调用该静态成员，这样看似共享，但却无法保证静态成员的唯一性。从类型擦除方面考虑的话，擦除时，进行强制转换可能会造成类型转换错误。

6、不能抛出或捕获泛型类的实例

以下均是不合法的：（可以编写代码验证测试）

  • 泛型类不能继承异常类及异常的实现类，如public class TestType<T>  extends Exception{}。
  • catch块不能捕获泛型类的实例 ，如 try{}catch(T e){}。

7、类型擦除后，泛型类的方法名称引起的冲突

如：定义一个Order类，自定义了一个泛型方法 boolean equals(T value)，当类型擦除后就是 boolean equals(Object o) ，与Object的equals()发生了冲突！可以修改Order类的equals()，避免与Object的方法冲突。

8、注意Varages警告

向参数个数可变的方法传递一个泛型类型的实例，调用该方法时会出现一个Varages警告，有两个方法可以避免：一是使用注解@SuppressWarnings("unchecked") ；二是用注解@SafeVarages。

小结

最后还是做下总结吧，个人感觉深入Java泛型还是有点难度的，尤其是搞明白泛型数组的构造问题，及类型擦除带来的一系列限制问题。本文从整体上对Java泛型的知识点做了一番梳理总结，从为什么要引入泛型，怎么理解泛型，如何将泛型应用在接口、类和方法上，有哪些泛型通配符及表达的含义，为什么使用限定类型的通配符，怎么构建泛型数组及使用过程中的问题，如何正确安全的构建泛型数组，由于JVM类型擦除给泛型带来了一系列的限制分析等。这一过程着实花了不少时间去思考，分析和码字整理，算是进一步巩固了基础吧，这个过程收获还是挺多的。还是那句话，不积硅步无以至千里，点滴付出终将有所收获，共同进步吧~

猜你喜欢

转载自blog.csdn.net/qq_29119581/article/details/112093159
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022