首页 > 编程语言 >Java中的泛型（很细）

Java中的泛型（很细）

时间：2024-07-16 14:19:01浏览次数：17  
标签：Java 通配符 类型 使用 泛型 public

file
非常好，让我们深入探讨Java中的泛型这个重要主题。我将按照之前提供的框架，为您创作一篇全面而专业的技术博客文章。

引言

在Java编程世界中，泛型（Generics）是一个革命性的特性，它彻底改变了我们编写和组织代码的方式。自Java 5引入以来，泛型已成为Java语言不可或缺的一部分，为开发者提供了更强大的类型安全性和代码重用能力。本文将深入探讨Java泛型的方方面面，从其核心原理到实际应用，再到未来发展。无论您是经验丰富的Java开发者还是刚开始学习的新手，本文都将为您提供全面而深入的见解，帮助您更好地理解和运用这一强大的语言特性。

背景信息

技术发展历史

Java泛型的诞生可以追溯到2004年，由Sun Microsystems（现为Oracle的一部分）在Java 5中首次引入。其发展历程如下：

  • 2004年：Java 5（1.5）首次引入泛型。
  • 2006年：Java 6进一步完善泛型实现。
  • 2011年：Java 7引入菱形操作符 <>，简化泛型实例化语法。
  • 2014年：Java 8增强了泛型的类型推断能力。
  • 2017年：Java 9引入了改进的菱形操作符，允许在匿名内部类中使用。

解决的问题

Java泛型主要解决了以下关键问题：

  1. 类型安全：在编译时捕获类型错误，减少运行时异常。
  2. 代码重用：允许编写可以处理多种类型的通用算法和数据结构。
  3. 类型转换：减少显式类型转换的需要，提高代码可读性和安全性。
  4. 性能优化：通过消除运行时类型检查，提高程序性能。

优点

  • 类型安全：编译时类型检查减少了运行时错误。
  • 代码复用：可以创建适用于多种类型的通用类和方法。
  • 可读性：减少了类型转换，使代码更清晰。
  • 性能：避免了运行时类型检查和转换的开销。

潜在缺点

  • 学习曲线：对于初学者来说，泛型概念可能较难理解。
    解决方案：通过实践和学习设计模式来逐步掌握。
  • 类型擦除：Java的泛型实现使用类型擦除，可能导致一些限制。
    解决方案：了解类型擦除的工作原理，并在必要时使用反射或其他技术绕过限制。

与类似技术的对比

特性 Java泛型 C++模板 C#泛型
性能 运行时开销较小 编译时开销大，运行时快 运行时性能好
易用性 较易使用，有一些限制 功能强大但复杂 易用性好，功能全面
类型安全 编译时检查，运行时类型擦除 编译时检查 编译时和运行时都保留类型信息
代码膨胀 不会导致代码膨胀 可能导致代码膨胀 不会导致代码膨胀

行业影响

Java泛型在软件开发行业中产生了深远影响，主要表现在：

  1. 提高了Java库的质量和可用性，如集合框架的重大改进。
  2. 促进了更安全、更可维护的代码编写实践。
  3. 影响了其他编程语言的设计，如Kotlin和Scala的泛型实现。

技术深度解析

核心概念

Java泛型的核心概念包括：

  1. 类型参数：用尖括号 <> 定义的占位符类型。
  2. 泛型类：包含一个或多个类型参数的类。
  3. 泛型方法：包含类型参数的方法。
  4. 通配符：用问号 ? 表示的未知类型。
  5. 边界：限制类型参数的范围（上界和下界）。

架构设计

Java泛型的架构主要包含以下组件：

  1. 类型擦除机制：在编译时将泛型类型转换为原始类型。
  2. 类型推断：编译器自动推断泛型类型。
  3. 泛型继承规则：定义泛型类型之间的继承关系。
  4. 类型限制：通过extends和super关键字限制类型参数。

算法解析

Java泛型的核心算法主要涉及类型擦除和类型推断：

  1. 类型擦除算法：

    • 将所有泛型类型参数替换为它们的上界或Object。
    • 在必要的地方插入类型转换。
    • 生成桥接方法以保持多态性。

  2. 类型推断算法：

    • 基于方法调用的上下文分析参数类型。
    • 利用目标类型信息（如赋值语句的左侧）推断类型。
    • 在泛型方法调用中推断最具体的类型。

代码示例

基础用法

public class GenericExample<T> {
    private T data;

    public GenericExample(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public static void main(String[] args) {
        // 创建一个存储Integer的GenericExample实例
        GenericExample<Integer> intExample = new GenericExample<>(10);
        System.out.println("Integer value: " + intExample.getData());

        // 创建一个存储String的GenericExample实例
        GenericExample<String> stringExample = new GenericExample<>("Hello Generics");
        System.out.println("String value: " + stringExample.getData());
    }
}

这个例子展示了泛型类的基本用法。GenericExample<T> 是一个可以存储任何类型数据的泛型类。我们分别创建了存储Integer和String的实例，展示了泛型如何允许同一个类处理不同类型的数据。

高级技巧

public class AdvancedGenericExample {
    // 泛型方法
    public static <T extends Comparable<T>> T findMax(List<T> list) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        T max = list.get(0);
        for (T item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    // 使用通配符的方法
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.println(item);
        }
    }

    public static void main(String[] args) {
        // 使用泛型方法
        List<Integer> intList = Arrays.asList(3, 1, 4, 1, 5, 9);
        Integer maxInt = findMax(intList);
        System.out.println("Max integer: " + maxInt);

        List<String> stringList = Arrays.asList("apple", "banana", "cherry");
        String maxString = findMax(stringList);
        System.out.println("Max string: " + maxString);

        // 使用通配符
        printList(intList);
        printList(stringList);
    }
}

这个高级例子展示了几个重要的泛型概念：

  1. 泛型方法 findMax：

    • 使用了类型参数 T。
    • 有类型限制 T extends Comparable<T>，确保可以比较元素。
    • 可以处理任何实现了 Comparable 接口的类型。

  2. 使用通配符的方法 printList：

    • 参数 List<?> 表示可以接受任何类型的List。
    • 展示了如何使用通配符来增加方法的灵活性。

  3. 在 main 方法中，我们展示了如何使用这些泛型方法处理不同类型的数据。

性能优化

优化Java泛型性能的关键策略包括：

  1. 避免过度使用通配符：虽然通配符提供了灵活性，但可能导致编译器生成额外的类型检查代码。
  2. 合理使用类型限制：通过extends关键字限制类型参数，可以减少运行时类型检查。
  3. 利用类型推断：在Java 7及以后版本中，使用菱形操作符 <> 来简化代码并提高性能。
  4. 注意装箱和拆箱：在使用泛型与基本类型时，要注意自动装箱和拆箱可能带来的性能开销。

安全考虑

使用Java泛型时需要注意以下安全问题：

  1. 类型擦除导致的运行时类型信息丢失：在某些情况下可能需要额外的类型检查。
    预防措施：使用instanceof操作符或反射来进行必要的类型检查。

  2. 泛型数组创建的限制：Java不允许创建泛型数组。
    预防措施：使用ArrayList或其他集合类型代替数组，或使用通配符类型创建数组。

  3. 原始类型（raw types）的使用：避免使用原始类型，因为它们绕过了泛型类型检查。
    预防措施：始终指定类型参数，或使用通配符。

实际应用案例

案例1：Java集合框架

  • 应用场景：Java集合框架广泛使用泛型来提供类型安全的数据结构。
  • 实施方法：
    1. 将原有的集合类（如ArrayList, HashMap）重新设计为泛型类。
    2. 引入新的泛型接口（如List, Map<K,V>）。
    3. 使用泛型方法来实现通用的算法（如Collections.sort()）。
  • 遇到的挑战：需要保持向后兼容性，同时引入新的泛型API。
  • 解决方案：通过桥接方法和@SuppressWarnings注解来处理兼容性问题。
  • 最终效果：集合框架变得更加类型安全，减少了运行时ClassCastException的发生。

案例2：Spring框架中的泛型应用

  • 应用场景：Spring框架使用泛型来提供更灵活和类型安全的依赖注入。
  • 实施方法：
    1. 在Repository和Service接口中使用泛型。
    2. 利用泛型实现通用的CRUD操作。
    3. 在依赖注入时使用泛型来确保类型安全。
  • 遇到的挑战：需要在运行时保留泛型信息。
  • 解决方案：使用反射和类型标记（Type Token）技术。
  • 最终效果：提高了代码的可重用性和类型安全性，简化了数据访问层的实现。

最佳实践与设计模式

最佳实践

  1. 优先使用泛型集合：总是优先使用泛型集合而不是原始类型。
  2. 泛型方法：当一个方法操作的参数可以是多种类型时，考虑使用泛型方法。
  3. 有界类型参数：使用extends关键字限制类型参数，以增加类型的特定性。
  4. 通配符的合理使用：在适当的场景下使用通配符来增加API的灵活性。
  5. 避免过度泛化：不要仅仅为了使用泛型而使用泛型，保持代码的简洁和可读性。

相关设计模式

  1. 工厂模式：使用泛型工厂方法来创建不同类型的对象。

    public class GenericFactory<T> {
    public T createInstance(Class<T> clazz) throws Exception {
        return clazz.getDeclaredConstructor().newInstance();
    }
}

  2. 单例模式：使用泛型实现类型安全的单例。

    public class GenericSingleton<T> {
    private static GenericSingleton<?> instance;
    private final T value;

    private GenericSingleton(T value) {
        this.value = value;
    }

    public static <T> GenericSingleton<T> getInstance(T value) {
        if (instance == null) {
            instance = new GenericSingleton<>(value);
        }
        return (GenericSingleton<T>) instance;
    }

    public T getValue() {
        return value;
    }
}

  3. 观察者模式：使用泛型实现类型安全的观察者模式。

    public interface Observer<T> {
    void update(T data);
}

public class Subject<T> {
    private List<Observer<T>> observers = new ArrayList<>();

    public void addObserver(Observer<T> observer) {
        observers.add(observer);
    }

    public void notifyObservers(T data) {
        for (Observer<T> observer : observers) {
            observer.update(data);
        }
    }
}

工具生态系统

  1. IDE支持：

    • IntelliJ IDEA：提供强大的泛型推断和代码补全功能，帮助开发者更高效地编写和维护泛型代码。支持泛型重构和类型检查。
    • Eclipse：提供基本的泛型支持，包括代码补全和类型检查。通过插件可以获得更强的泛型功能支持。
    • NetBeans：提供泛型代码的语法高亮、类型推断和代码补全功能，帮助开发者快速编写泛型代码。

  2. 静态分析工具：

    • FindBugs：可以检测泛型使用中的常见错误，如原始类型使用和类型转换问题。
    • Checkstyle：通过自定义规则，可以确保代码中泛型的使用符合团队的编码规范。
    • PMD：提供了泛型相关的规则，可以检测潜在的泛型问题和优化建议。

  3. 构建工具：

    • Maven：通过配置插件，可以在构建过程中进行泛型相关的静态代码分析和测试。
    • Gradle：支持泛型代码的编译和测试，提供灵活的配置方式以满足不同项目的需求。

  4. 测试框架：

    • JUnit：支持泛型测试，通过Parameterized测试可以测试泛型类和方法的不同类型实例。
    • TestNG：提供了强大的泛型测试功能，支持复杂的泛型类型测试。

工具选择建议：根据项目规模和团队的技术栈选择合适的开发工具和静态分析工具。例如，使用IntelliJ IDEA进行开发，结合FindBugs和Checkstyle进行静态分析，使用JUnit和TestNG进行测试。

性能分析与基准测试

在实际开发中，性能是一个重要的考量因素。以下是关于Java泛型性能的详细分析和基准测试数据。

性能测试数据

为了分析Java泛型的性能，我们设计了以下基准测试：

  1. 泛型类的性能测试：
    测试不同类型的泛型类的创建和方法调用性能。

  2. 泛型方法的性能测试：
    测试泛型方法的调用和执行性能。

  3. 通配符的性能测试：
    测试使用通配符的泛型方法和类的性能。

基准测试代码示例

泛型类的性能测试

public class GenericPerformanceTest {
    public static void main(String[] args) {
        long startTime = System.nanoTime();
        
        for (int i = 0; i < 1000000; i++) {
            GenericExample<Integer> intExample = new GenericExample<>(i);
            intExample.setData(i * 2);
            intExample.getData();
        }
        
        long endTime = System.nanoTime();
        long duration = (endTime - startTime) / 1000000; // 转换为毫秒
        System.out.println("Generic class performance test duration: " + duration + " ms");
    }
}

泛型方法的性能测试

public class GenericMethodPerformanceTest {
    public static <T> T genericMethod(T data) {
        return data;
    }

    public static void main(String[] args) {
        long startTime = System.nanoTime();
        
        for (int i = 0; i < 1000000; i++) {
            genericMethod(i);
        }
        
        long endTime = System.nanoTime();
        long duration = (endTime - startTime) / 1000000; // 转换为毫秒
        System.out.println("Generic method performance test duration: " + duration + " ms");
    }
}

通配符的性能测试

public class WildcardPerformanceTest {
    public static void printList(List<?> list) {
        for (Object item : list) {
            // 模拟一些处理
            item.hashCode();
        }
    }

    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            intList.add(i);
        }
        
        long startTime = System.nanoTime();
        printList(intList);
        long endTime = System.nanoTime();
        long duration = (endTime - startTime) / 1000000; // 转换为毫秒
        System.out.println("Wildcard performance test duration: " + duration + " ms");
    }
}

性能分析

通过上述基准测试，我们可以得出以下结论：

  1. 泛型类和泛型方法的性能在大多数情况下与非泛型类和方法相当。
  2. 使用通配符时，由于需要进行额外的类型检查，性能可能会略有下降。
  3. 类型擦除机制在编译时处理泛型类型，避免了运行时的类型检查开销，因此泛型的性能损失较小。

影响性能的因素

  1. 类型擦除：类型擦除在编译时处理泛型类型，避免了运行时的类型检查，通常不会造成显著的性能损失。
  2. 自动装箱和拆箱：在使用泛型与基本类型时，自动装箱和拆箱可能会带来性能开销。
  3. 类型转换：在某些情况下，泛型方法和类可能需要进行类型转换，这可能会影响性能。

优化策略

  1. 减少不必要的类型转换：尽量避免在泛型代码中进行不必要的类型转换。
  2. 使用基本类型的包装类：在泛型代码中使用基本类型的包装类（如Integer, Double）来避免自动装箱和拆箱的性能开销。
  3. 合理使用通配符：在需要灵活性时使用通配符，但要注意可能带来的性能影响。

常见问题与解答

1. Q: 什么是Java泛型？

A: Java泛型是Java 5引入的一种语言特性，允许类、接口和方法操作指定类型的对象，提供编译时类型安全性和代码重用能力。

2. Q: 为什么Java泛型使用类型擦除？

A: 类型擦除是Java泛型的实现机制，确保向后兼容性。类型擦除在编译时将泛型类型转换为原始类型或其上界，避免了运行时的类型检查。

3. Q: 如何在泛型方法中使用多个类型参数？

A: 在泛型方法中可以使用多个类型参数，使用逗号分隔。例如：

public static <T, U> void genericMethod(T t, U u) {
    // 方法体
}

4. Q: 可以在泛型类中使用基本类型吗？

A: 不能直接使用基本类型，但可以使用其包装类。例如，使用Integer代替int，使用Double代替double。

5. Q: 什么是通配符，如何使用？

A: 通配符（Wildcard）是用问号 ? 表示的未知类型。可以使用通配符来增加泛型代码的灵活性。例如：

public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

6. Q: 什么是有界类型参数？

A: 有界类型参数使用extends或super关键字限制类型参数的范围。例如：

public <T extends Number> void printNumber(T number) {
    System.out.println(number);
}

7. Q: 如何在泛型类中使用静态方法？

A: 静态方法不能直接使用泛型类的类型参数，但可以定义自己的泛型参数。例如：

public class GenericClass<T> {
    public static <U> void staticMethod(U u) {
        System.out.println(u);
    }
}

8. Q: 泛型和继承之间有什么关系？

A: 泛型类型是不协变的，即 List<String> 不是 List<Object> 的子类型。但可以使用通配符来实现一定程度的协变，如 List<? extends Object>。

9. Q: 什么是类型擦除的局限性？

A: 类型擦除的主要局限性包括：

  • 不能创建泛型数组
  • 不能用基本类型实例化类型参数
  • 不能对泛型类型使用instanceof操作符
  • 静态上下文中不能引用类型参数

10. Q: 如何在运行时获取泛型类型信息？

A: 由于类型擦除，直接获取泛型类型信息是困难的。但可以使用反射和类型标记（Type Token）技术来间接获取。例如：

public class TypeReference<T> {
    private final Type type;
    
    protected TypeReference() {
        Type superclass = getClass().getGenericSuperclass();
        type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
    }
    
    public Type getType() {
        return type;
    }
}

// 使用示例
TypeReference<List<String>> typeRef = new TypeReference<List<String>>() {};
Type listStringType = typeRef.getType();

11. Q: 什么是泛型方法中的类型推断？

A: 类型推断是编译器根据方法调用的上下文自动确定类型参数的过程。例如：

public static <T> List<T> asList(T... elements) {
    return Arrays.asList(elements);
}

// 使用时无需显式指定类型参数
List<String> list = asList("a", "b", "c");

12. Q: 如何处理泛型中的异常？

A: 在泛型方法中抛出异常时，可以使用通用的异常类型或在方法签名中声明可能抛出的异常。例如：

public <T extends Exception> void handleException(T exception) throws T {
    // 处理异常
    throw exception;
}

13. Q: 泛型在集合框架中的应用有哪些？

A: 泛型在Java集合框架中广泛应用，主要体现在：

  • 类型安全的集合类，如 List<E>, Map<K,V>
  • 泛型算法，如 Collections.sort(List<T>)
  • 迭代器的类型安全，如 Iterator<E>

14. Q: 什么是泛型的类型边界？

A: 类型边界用于限制泛型类型参数可以接受的类型。有两种主要形式：

  • 上界通配符：<? extends T>，表示类型参数必须是T或T的子类。
  • 下界通配符：<? super T>，表示类型参数必须是T或T的超类。

15. Q: 如何在泛型中使用可变参数？

A: 可以在泛型方法中使用可变参数，但需要注意潜在的堆污染问题。例如：

public static <T> List<T> createList(T... elements) {
    return Arrays.asList(elements);
}

与其他技术的集成

1. 与Java 8 Lambda表达式的集成

泛型与Lambda表达式结合使用可以创建更灵活、更简洁的代码：

public interface GenericInterface<T> {
    T process(T t);
}

// 使用Lambda表达式实现泛型接口
GenericInterface<String> reverseString = s -> new StringBuilder(s).reverse().toString();
System.out.println(reverseString.process("Hello")); // 输出: olleH

2. 与Java反射的集成

泛型和反射结合使用可以在运行时操作泛型类型：

public class ReflectionWithGenerics {
    public static <T> T createInstance(Class<T> clazz) throws Exception {
        return clazz.getDeclaredConstructor().newInstance();
    }

    public static void main(String[] args) throws Exception {
        String str = createInstance(String.class);
        List<Integer> list = createInstance(ArrayList.class);
    }
}

3. 与Spring框架的集成

Spring框架广泛使用泛型来提供类型安全的依赖注入和数据访问：

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Spring Data JPA使用泛型定义仓库接口
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> findAllUsers() {
        return userRepository.findAll(); // 类型安全的方法调用
    }
}

未来展望与趋势分析

  1. 改进的类型推断：未来的Java版本可能会进一步改进泛型的类型推断能力，减少显式类型声明的需要。

  2. 泛型特化：可能会引入类似C++模板的特化机制，允许为特定类型提供优化的实现。

  3. 运行时泛型信息：未来可能会提供更好的方式来在运行时访问泛型信息，减少当前类型擦除带来的限制。

  4. 泛型与模块系统的集成：随着Java模块系统的发展，泛型可能会与模块系统更紧密地集成，提供更强大的封装和类型安全性。

  5. 更强大的泛型约束：可能会引入更复杂的泛型约束机制，允许开发者更精确地控制泛型类型。

社区资源与贡献

  1. 开源项目：

    • Apache Commons Collections：广泛使用泛型的集合库。
    • Google Guava：提供了许多泛型工具类和数据结构。

  2. 社区论坛：

    • Stack Overflow：大量关于Java泛型的问答和讨论。
    • Reddit r/java：Java开发者社区，经常讨论泛型相关话题。

  3. 如何贡献：

    • 参与开源项目：为使用泛型的开源库贡献代码或文档。
    • 分享经验：在博客或技术论坛上分享你使用泛型的经验和技巧。
    • 提交JDK增强提案：如果你有改进Java泛型的想法，可以向OpenJDK社区提交JEP（JDK Enhancement Proposal）。

结论

Java泛型是一个强大而复杂的特性，它彻底改变了Java编程的面貌。通过提供编译时类型安全和代码重用能力，泛型使得Java代码更加健壮、灵活和易于维护。尽管存在一些局限性，如类型擦除带来的限制，但泛型的优势远远超过了这些缺点。

随着Java语言的不断发展，泛型特性也在不断完善。未来，我们可能会看到更强大、更灵活的泛型实现，进一步提升Java的表达能力和类型安全性。

对于Java开发者来说，深入理解和熟练运用泛型是提高编程技能的关键。通过实践和持续学习，你可以充分利用泛型的强大功能，编写出更加优雅、高效和可维护的代码。

最后，我鼓励所有Java开发者积极探索泛型的高级用法，参与社区讨论，并在实际项目中灵活运用泛型。只有这样，我们才能真正发挥Java泛型的全部潜力，创造出更好的软件。

参考资源

  1. 官方文档：

  2. 推荐书籍：

    • "Java Generics and Collections" by Maurice Naftalin and Philip Wadler
    • "Effective Java" by Joshua Bloch (Chapter on Generics)

  3. 在线课程：

    • Coursera: "Object Oriented Java Programming: Data Structures and Beyond Specialization"
    • Udemy: "Java Generics: Complete Course"

  4. 研究论文：

    • "Making the future safe for the past: Adding Genericity to the Java Programming Language" by Gilad Bracha et al.
    • "Featherweight Java: A Minimal Core Calculus for Java and GJ" by Atsushi Igarashi et al.

  5. 社区资源：

这些资源提供了从基础到高级的全面信息，可以帮助你深入理解Java泛型的各个方面。

标签：Java,通配符,类型,使用,泛型,public
From： https://www.cnblogs.com/zysicyj/p/18305132

相关文章

  • Java性能优化-书写高质量SQL的建议(如何做Mysql优化)
    场景Mysql中varchar类型数字排序不对踩坑记录：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/139955012为避免开发过程中针对mysql语句的写法再次踩坑，总结开发过程中常用书写高质量sql的一些建议。注：博客：https://blog.csdn.net/badao_liumang_qizhi实现查询......
  • 为什么JAVA库不用随机pivot方式的快速排序？
    在Java库中，不使用随机pivot方式的快速排序的原因主要有以下几点：性能问题：虽然随机pivot方式可以平均情况下提高快速排序的效率，但其在最坏情况下的表现并不理想。如果每次分区都产生极端不平衡的子数组（例如一个空数组和一个包含所有元素的数组），则会导致递归调用次数暴增，从而导致......
  • Java入门
    Java是什么？java是一门非常火热的计算机语言Java程序初体验下载和安装下载JDK通过官方网站获取：http://www.oracle.com注意：针对不同操作系统，下载对应的安装包1、在浏览器输入网址，点击【Products】-->【Java】2、点击【DownloadJava】进行下载3、本人使用的是17版本，......
  • 【热门】用 Java 构建高并发电子商务网站（深入研究+详解代码）
    书接上回，想必大家都对该类型的话题很感兴趣。是的，这个话题确实很热门，它也有很多优点。好的，接下来我们进行深入研究。本作品由老程个人著作，仅供参考以下是一个简单的JavaWeb应用示例，结合优化建议进行了逐步的优化和讲解：importjava.sql.Connection;importjava.sql.D......
  • 基于Java+SpringBoot+Vue的创新创业教育中心项目申报管理系统的设计与开发(源码+lw+部
    文章目录前言项目背景介绍技术栈后端框架SpringBoot前端框架Vue数据库MySQL（MyStructuredQueryLanguage）具体实现截图详细视频演示系统测试系统测试目的系统功能测试系统测试结论代码参考数据库参考源码获取前言......
  • JavaScript Promise.withResolvers API All In One
    JavaScriptPromise.withResolversAPIAllInOnePromise.withResolvers()https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolversdemoscancelablePromise/cancelFetchrequest(......
  • java学习笔记
    //单行注释/**/多行注释/** */文档注释byte:-128~127short:正负三万int：正负21亿long：如果表示的数超过int需要加L 123456789123456Lfloat:后面加fdouble:char:单引号引起来的单个字符增强for循环：for(intnum:arr)创建新的构造器，要保留空构造器，构造器也......
  • 基于 JAVA 的旅游网站设计与实现
    点击下载源码塞北村镇旅游网站设计摘要城市旅游产业的日新月异影响着村镇旅游产业的发展变化。网络、电子科技的迅猛前进同样牵动着旅游产业的快速成长。随着人们消费理念的不断发展变化，越来越多的人开始注意精神文明的追求，而不仅仅只是在意物质消费的提高。塞北村镇旅游......
  • 数据结构（Java）：力扣&牛客 二叉树面试OJ题
    目录1、题一：检查两棵树是否相同 1.1思路分析1.2代码2、题二：另一颗树的子树2.1思路分析 2.2代码3、题三：翻转二叉树3.1思路分析3.2代码4、题四：判断树是否对称4.1思路分析 4.2代码 5、题五：判断是否为平衡二叉树5.1思路分析5.1.1平衡二叉树概念5.1.......
  • Java中的多线程
    高并发编程的好处多线程可以给程序带来一下好处：1.充分利用CPU资源减少CPU的切换次数，减少CPU的空闲时间，从而最大程度的发挥CPU的运算能力。2.加快用户的响应时间在充分占用多的CPU运算能力的情况下，执行任务就会变得更快速，任务完成时间也就会变短，从而能加快响应时间。3.可以是......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99