Monodyee

这个屌丝很懒，什么也没留下！

热门标签

Java反射+集合+泛型面试题总结

作者：Monodyee | 2024-05-02 09:42:56

踩

Java反射+集合+泛型面试题总结

Java反射是Java编程语言的一个特性，它允许在运行时检查类、接口、字段和方法的信息，并且能够在运行时创建和操作对象。通过反射API，开发者可以在不知道具体类型信息的情况下访问类的内部属性和方法，或者构造一个类的对象，这对于实现动态加载类和执行未知类型的代码特别有用。Java集合与泛型是Java编程中紧密相关的两个概念，它们一起为开发者提供了强大且类型安全的数据结构和操作机制。Java集合框架是一组接口和类的集合，位于java.util包中，用于存储、组织、操纵以及检索对象的集合。泛型是在Java 5中引入的一个重要特性，它允许在定义类、接口和方法时使用类型参数，这样编译器就可以在编译时执行类型检查，从而提高代码的安全性和可读性。在集合框架中，泛型的应用尤为关键，它允许我们指定集合所保存的对象类型。通过这种方式，编译器会在编译时确保添加到集合中的元素符合类型约束，如果尝试插入错误类型的对象，则会引发编译错误。同时，使用泛型也避免了运行时强制类型转换的问题，提高了程序的健壮性和性能。在集合内部，尽管由于类型擦除的原因，运行时实际没有泛型信息，但在编译阶段类型检查已经完成，从而保证了类型安全。

1.什么是java的反射？

2.反射的常见用法？

3.什么是java序列化，什么时候需要序列化？

4.反射机制的优缺点？

5.java反射的作用？

6.反射的具体应用场景，举个例子？

7.Java可以通过反射的方式加载注解吗？

8.Java反射创建对象效率高还是通过new创建对象的效率高？为什么？

9.jdk7，8，11，17的区别？

10.springboot2 与springboot3的区别？

11、ArrayList 和 linkedList 的区别？

12、HashMap 扩容机制？

13、Collection 与 Collections 的区别？

14、说说 List,Set,Map 三者的区别？

15、ConcurrentHashMap 、 Hashtable、HashMap 的区别?

16、poll()方法和 remove()方法的区别？

17、什么是Java泛型？泛型在Java的作用？

1.什么是java的反射？

Java反射机制是指在运行状态中，Java程序可以获取类的信息（如类名、属性、方法等）并进行动态操作的能力。通过反射API，程序能够在运行时创建对象、调用任意方法、访问或修改字段，甚至是构造函数和类的内部信息。

具体来说，Java反射的核心概念包括以下几个方面：

Class对象：每个加载到JVM中的类都有一个对应的Class对象，它是反射操作的基础入口点。
获取类信息：通过Class对象，可以获取类的包名、父类、接口、注解、字段（包括静态和非静态）、方法（包括公共、保护、私有和默认访问权限的方法）等详细信息。
实例化对象：即使没有显式知道类名，也可以通过Class.forName()方法加载类并使用newInstance()方法无参构造一个类的实例。如果需要调用带参数的构造函数，则需通过getConstructor()或getDeclaredConstructor()方法获得构造器，并调用其newInstance()方法。
操作字段和方法：反射允许你在运行时查找、访问、修改类的字段值，以及调用方法，即使这些字段或方法是私有的也是如此。
动态代理：Java反射机制也支持动态生成代理类，这在实现AOP（面向切面编程）框架时非常有用。

总之，反射在很多高级应用场景中扮演着重要角色，比如在依赖注入框架、ORM库、代码生成工具、测试工具以及任何需要在编译期未知类型信息的情况下动态操作类和对象的场合。然而，由于它打破了编译时类型安全检查，过度或不恰当的使用可能会引入潜在的安全性和性能问题。

2.反射的常见用法？

1）获取Class对象：
Class.forName(“类的全称”)
类名.class / 实例化对象.getClass()

2）根据class对象获取Field（成员变量）对象：
Field getField(name)：根据字段名获取某个public的field（包括父类）
Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类）
Field[] getFields()：获取所有public的field（包括父类）
Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）

3）根据Field 获取设置成员变量值：
filed.get(“实例化对象”）：获取"实例化对象"的filed字段值
filed.setAccessible(true) ：设置访问权限，如果filed为private,则调用get或set时会抛异常 IllegalAccessException，若设置为true不管什么访问限制均可访问
filed.set(“实例化对象”,“值”）：设置"实例化对象"的filed字段值

4）根据class获取Method（成员方法）对象：
Method getMethod(name, Class…)：获取某个public的Method（包括父类）
Method getDeclaredMethod(name, Class…)：获取当前类的某个Method（不包括父类） — 可获取private 方法
Method[] getMethods()：获取所有public的Method（包括父类）
Method[] getDeclaredMethods()：调用非public方法，我们通过Method.setAccessible(true)允许其调用

5）根据Method实现成员方法的调用实现：
‘class类’ invoke(‘实例化对象，静态方法此为null’, Object… ‘方法参数’) 方法调用
getName()：返回方法名称
getReturnType()：返回方法返回值类型，也是一个Class实例
getParameterTypes()：返回方法的参数类型，是一个Class数组
getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。
setAccessible(true) ：非public 方法需要

6）通过Class获取Constructor 构造器
getConstructor(Class…)：获取某个public的Constructor；
getDeclaredConstructor(Class…)：获取某个Constructor；
getConstructors()：获取所有public的Constructor；
getDeclaredConstructors()：获取所有Constructor。

7）通过Constructor 实例对象
newInstance(Object… parameters) ：创建一个实例对象
setAccessible(true) ：通过设置来访问非public构造方法。
通过 Class 获取继承关系：‘父类Class’ getSuperclass() 获取父类class


/**
 * @author nuist__NJUPT
 * @ClassName Reflect
 * @description: 反射对象类
 * @date 2024/02/25
 */
public class Reflect {
    private String name ;
    private String gender ;
    private Integer age ;
    private Boolean married ;
 
    public Reflect() {
    }
 
    public Reflect(String name, String gender, Integer age, Boolean married) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.married = married;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getGender() {
        return gender;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    public Boolean getMarried() {
        return married;
    }
 
    public void setMarried(Boolean married) {
        this.married = married;
    }
 
    @Override
    public String toString() {
        return "Reflect{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", married=" + married +
                '}';
    }
 
    public void display(){
        System.out.println("姓名：" + name + "性别：" + gender + "年龄：" + age + "婚姻状况：" + married);
    }
 
 
}


 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
/**
 * @author nuist__NJUPT
 * @ClassName Test
 * @description: 测试类
 * @date 2024/02/25
 */
public class Test {
 
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InstantiationException, InvocationTargetException {
 
        Reflect reflect = new Reflect() ;
 
        // 获取类的Class对象
        Class<?> aClass = Class.forName("com.design.pattern.reflect.Reflect");
        // 获取带参数的构造方法
        Constructor<?> constructor = aClass.getDeclaredConstructor(String.class, String.class, Integer.class, Boolean.class);
        // 获取无参数的构造方法
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        // 创建实例对象
        Object object = aClass.newInstance();
        // 访问私有字段并修改值
        Field name = aClass.getDeclaredField("name");
        // 显式开启对私有字段的访问权限
        name.setAccessible(true);
        // 修改字段值
        name.set(object, "new name");
        // 访问所有字段
        Field[] declaredFields = aClass.getDeclaredFields();
        for(Field obj : declaredFields){
            obj.setAccessible(true);
            switch (obj.getName()){
                case "name":
                    obj.set(object, "王阳明");
                    break;
                case "gender":
                    obj.set(object, "男");
                    break;
                case "age":
                    obj.set(object, 18);
                    break;
                case "married":
                    obj.set(object, false);
                    break;
                default:
                    break;
            }
        }
        // 获取字段值
        System.out.println(name.get(object));
        // 获取和调用字段
        Method display = aClass.getDeclaredMethod("display");
        display.invoke(object) ;
 
    }
 
}

3.什么是java序列化，什么时候需要序列化？

序列化：将 Java 对象转换成字节流的过程。
反序列化：将字节流转换成 Java 对象的过程。

当 Java 对象需要在网络上传输或者持久化存储到文件中时，就需要对 Java 对象进行序列化处理。

序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。

4.反射机制的优缺点？

Java反射机制的优缺点如下：

优点：

1. 灵活性和扩展性：反射允许程序在运行时动态地获取类的信息，加载类并创建对象实例，使得代码可以在不了解具体类型信息的情况下处理多种类型的数据，极大地增强了程序的灵活性和扩展性。

2. 降低耦合度：通过反射可以实现基于接口或配置文件驱动的设计，减少模块间的硬编码依赖，降低了系统的耦合度。

3. 框架支持：许多Java框架（如Spring、Hibernate等）都大量使用反射技术，能够实现实现依赖注入、ORM映射等功能，简化开发过程，提高开发效率。

4. 运行期类型的判断与操作：反射可用于序列化、反序列化、代理模式以及运行时修改类的行为等场景。

缺点：

1. 性能开销：反射操作通常比正常的Java代码执行慢很多，因为它涉及到JVM在运行时解析类信息并进行安全检查。频繁的反射调用会导致性能下降。

2. 安全性问题：反射可以访问私有成员，如果过度或不当地使用，可能破坏封装性，导致安全漏洞，或者暴露不应该被外部访问的对象状态。

3. 易用性及可读性：过度依赖反射会使代码变得复杂，难以理解和维护。此外，由于绕过了编译器的静态类型检查，可能导致错误不易发现，直到运行时才暴露出问题。

4. 稳定性：对反射API的不当使用可能导致不稳定的行为，特别是在处理内部类或泛型的时候，需要额外小心以避免ClassCastException或其他类型的运行时异常。

因此，在实际开发中，虽然反射机制提供了一种强大的工具，但应谨慎使用，并尽量在真正需要其灵活性和动态性的地方使用它。对于那些对性能要求较高的系统或组件，应尽可能避免不必要的反射操作。

5.java反射的作用？

Java反射机制的作用主要包括以下几点：

1. 运行时类信息的获取：在运行期间，程序可以动态地获取到任何已加载类的信息，包括类名、包名、父类、接口、构造方法、字段（属性）、方法等。

2. 动态创建对象和调用方法：即使在编译期并不知道具体类型，也可以通过Class对象实例化该类的对象，并调用其任意方法或访问/修改其属性值，包括私有方法和私有属性。

3. 实现灵活的框架设计：很多Java框架如Spring、Hibernate等都大量使用了反射技术，它允许框架根据配置文件或其他元数据在运行时动态地装配对象、执行注入等操作，大大提高了框架的灵活性和扩展性。

4. 兼容未知类型：在序列化与反序列化过程中，以及在网络通信协议解析中，可以通过反射处理未知类型的对象。

5. 工具类支持：反射被广泛应用于单元测试工具中，用来检查私有成员变量和私有方法，进行更全面的测试。

6. 动态代理：Java中的动态代理功能也依赖于反射机制，能够实现代理模式，在运行时生成一个实现了一组给定接口的新类实例。

总之，Java反射机制提供了一种强大的编程手段，使得程序能够在运行时发现并操作自身结构的能力，极大地提升了程序的可扩展性和灵活性。然而，过度或不适当使用反射也可能带来性能损失、破坏封装原则等问题，因此在实际开发中应权衡利弊，合理使用反射技术。

6.反射的具体应用场景，举个例子？

动态代理：在Java中，利用反射机制可以实现非常灵活的动态代理功能。例如，在Java的标准库java.lang.reflect.Proxy类中，就提供了创建动态代理对象的能力。

7.Java可以通过反射的方式加载注解吗？

Java可以通过反射API加载和解析注解（Annotation）。以下是一个通过反射获取并使用注解的例子：


import java.lang.reflect.Method;
import java.lang.reflect.AnnotatedElement;
 
public class AnnotationDemo {
    public static void main(String[] args) throws Exception {
        // 获取MyClass类的Class对象
        Class<?> clazz = Class.forName("MyClass");
 
        // 读取类上的注解
        MyAnnotation classAnnotation = clazz.getAnnotation(MyAnnotation.class);
        if (classAnnotation != null) {
            System.out.println("Class Annotation Value: " + classAnnotation.value());
        }
 
        // 获取类的方法
        Method method = clazz.getMethod("myMethod");
        
        // 读取方法上的注解
        MyAnnotation methodAnnotation = method.getAnnotation(MyAnnotation.class);
        if (methodAnnotation != null) {
            System.out.println("Method Annotation Value: " + methodAnnotation.value());
        }
    }
}
 
// 运行结果：
// Class Annotation Value: Hello, Reflect!
// Method Annotation Value: A method annotation

8.Java反射创建对象效率高还是通过new创建对象的效率高？为什么？

Java反射创建对象的效率通常低于通过new关键字直接创建对象。原因如下：

类加载延迟：使用反射时，如果对应的类尚未被加载到JVM中，则需要先触发类加载过程，这包括解析类文件、初始化类信息等步骤，增加了额外的开销。
查找与访问成本：通过反射创建对象时，你需要先获取到Class对象，然后调用newInstance()或其他类似方法来实例化对象。这个过程中涉及到查找类、检查构造函数权限和参数类型等操作，这些都需要额外的时间。
安全性检查：反射API在执行操作时会进行额外的安全检查，例如当访问私有构造函数或字段时，需调用setAccessible(true)并进行权限验证，这也会影响性能。
运行时动态性：反射机制允许在运行时决定具体要实例化的类，这种动态性导致了更多的CPU周期消耗，因为编译器无法对反射操作进行静态优化。
内联优化缺失：编译器在编译期可以对new关键字创建对象的操作进行内联（Inline）等优化，提高执行速度。而反射操作由于其动态特性，无法享受此类编译器优化。

因此，在大多数情况下，直接使用new关键字创建对象更高效。当然，反射作为一种强大的工具，提供了在运行时获取和操作类的能力，这对于一些高级功能如框架设计、动态代理等是必不可少的，但在不需要动态特性的场景下，应避免不必要的反射使用以保证程序性能。

9.jdk7，8，11，17的区别？

JDK（Java Development Kit）是Java编程语言的开发工具包，每个版本都会引入新的特性和改进。以下是JDK 7、8、11和17之间主要的区别：

JDK 7 (2011年发布)
G1垃圾收集器：虽然在JDK 6中作为实验特性引入，但在JDK 7更新中被进一步优化和稳定。
简化try-with-resources语句：支持自动关闭实现了AutoCloseable接口的资源，如FileInputStream等。
switch-on-string：允许switch语句作用于字符串类型。
NIO.2 (JSR 203)：增加了新的文件系统API，增强了对文件、目录和套接字通道的支持。

JDK 8 (2014年发布)
Lambda表达式：引入函数式编程风格，极大地提升了代码简洁性和可读性。
Stream API：提供了对集合对象进行高效、声明式操作的能力，包括过滤、映射、排序和归约等功能。
Optional类：用来表示可能为null的值，鼓励开发者更好地处理空指针异常。
Date-Time API：新增了java.time包，提供更强大、易于使用的日期和时间处理功能。
默认方法与静态方法：扩展了接口的功能，可以在接口中定义默认实现的方法和静态方法。

JDK 11 (2018年发布)
模块化系统（Project Jigsaw：正式引入了模块化系统（JPMS），使得Java平台变得更加灵活和可伸缩。
-HTTP客户端API：新增了标准HTTP客户端API，替代了之前的HttpURLConnection，提供现代HTTP/2支持以及异步非阻塞I/O。
字符串增强：String类增加了isBlank()方法，以及strip(), lines()等新方法。
移除废弃特性：移除了许多已经过时或不推荐使用的API和特性，比如Java EE和CORBA模块不再包含在默认JDK中。

JDK 17 (2021年发布)
Records：作为一种新的轻量级类结构，用于封装不可变数据，简化了数据类的编写。
Sealed Classes（密封类）：限制类子类化的权限，可以指定哪些类可以继承该类。
Pattern Matching for instanceof：增强了instanceof关键字，使其能够直接解构匹配对象，并赋值给变量。
文本块（Text Blocks）：多行字符串文字，用于更轻松地编写和格式化字符串内容，特别适合JSON、XML等格式的数据。
删除了多个已弃用的API：继续精简JDK，移除了一些长期未使用或已过时的API。
ZGC（Z Garbage Collector）：尽管在之前版本可用，但自JDK 11开始逐步完善并在JDK 17中更加成熟，提供低延迟的垃圾回收选项。

每个版本都包含了大量其他性能改进、安全修复以及其他较小的新特性。从JDK 11开始，Oracle采用了每六个月发布一个新版本的模式，并且每三年发布一个长期支持（LTS）版本，其中JDK 17就是一个LTS版本。

10.springboot2 与springboot3的区别？

Spring Boot 2 和 Spring Boot 3 目前为止的主要区别基于截至2024年2月25日的公开信息：

1. 依赖的Java版本：
- Spring Boot 2 最低要求Java 8，并且支持Java 9及以上版本。
- Spring Boot 3 需要至少Java 17作为最低版本，并且可能支持到Java 19。

2. 依赖的Spring Framework版本：
- Spring Boot 2 基于Spring Framework 5开发。
- Spring Boot 3 构建在Spring Framework 6之上，这意味着它包含了Spring框架新版本的所有更新和改进。

3. 模块化与依赖管理：
- Spring Boot 3 可能进一步优化了对模块化的支持，使得构建更小、更专注的应用成为可能，从而减少运行时依赖并提高启动速度。

4. 新特性与改进：
- Spring Boot 3 很可能会引入更多针对性能、安全性和开发者体验方面的改进，包括但不限于WebFlux的支持增强、新的自动配置选项、以及对云原生环境更好的适应性等。

5. 工具链集成：
- 对于构建工具（如Maven或Gradle）、IDE（如IntelliJ IDEA）以及其他相关工具链的集成方面，Spring Boot 3会提供更好的支持和新功能。

请注意，随着Spring Boot 3的发布，具体的差异还会包括对最新技术标准和最佳实践的支持，例如HTTP/3、容器化部署的优化、响应式编程模型的扩展等。由于实际版本特性的详细信息需要根据Spring Boot官方发布的具体文档为准，请查阅最新的官方文档以获取最准确的区别列表。

11、ArrayList 和 linkedList 的区别？

ArrayList 和 LinkedList 是Java集合框架中两种不同的List实现类，它们都实现了List接口，提供了增删查改等操作，但其底层数据结构和性能特点不同：

1. **数据结构**：
- `ArrayList`：基于动态数组实现。它在内存中是一段连续的存储空间，通过索引可以直接访问元素。
- `LinkedList`：基于双向链表实现。它的每个元素（节点）包含指向前后节点的引用，不是连续存储。

2. **随机访问性能**：
- `ArrayList`：由于是数组结构，支持快速的随机访问（通过索引直接获取或设置元素），时间复杂度为O(1)。
- `LinkedList`：对于链表结构，随机访问需要从头或尾部开始遍历到指定位置，因此随机访问的时间复杂度为O(n)。

3. **插入与删除操作性能**：
- `ArrayList`：在列表中间进行插入和删除时，为了保持数组的连续性，可能需要移动大量元素，插入和删除操作的时间复杂度通常为O(n)。
- `LinkedList`：在链表中的插入和删除操作只需要修改相邻节点之间的引用关系，所以在列表中间进行插入和删除时，时间复杂度通常是O(1)（不考虑链表头部和尾部的情况，那里的操作时间复杂度也是O(1)）。

4. **内存占用**：
- `ArrayList`：由于存储空间相对紧凑，对内存要求更稳定，但可能会有一定程度的空间浪费（如扩容后未使用的空间）。
- `LinkedList`：每个节点都需要额外的指针存储空间，所以如果元素数量很大，整体上可能比ArrayList占用更多内存。

总结来说，在大部分情况下，如果你的应用场景主要涉及大量的随机访问操作并且元素总数相对固定或变化不大，ArrayList可能是更好的选择。相反，如果经常执行列表中间的插入和删除操作，并且不需要频繁的随机访问，LinkedList将提供更好的性能。

12、HashMap 扩容机制？

在Java中，HashMap的扩容机制是指当其内部存储数据的数量超过一定阈值时，为了维持哈希表性能（尤其是查询效率），HashMap会自动将现有容量调整为一个更大的值。具体流程如下：

1. **初始容量与加载因子**：
- HashMap在创建时可以指定初始容量，默认容量是16。
- 加载因子（默认0.75）决定了何时进行扩容。即：当HashMap中的元素个数超过了容量（capacity）与加载因子的乘积时，就会触发扩容。

2. **扩容过程**：
- 扩容操作是一个重新分配内部数组的过程，并将所有已存元素从旧数组迁移到新数组中。新容量通常是旧容量的两倍加一，这样可以保证新容量始终是2的幂次方，便于索引计算。

```java
// 伪代码表示扩容
int newCapacity = oldCapacity * 2 + 1;
```

3. **迁移元素**：
- 在扩容过程中，HashMap会创建一个新的数组，并遍历原数组中的每个链表或红黑树节点。
- 对于JDK 1.8及以后版本，对于桶中的链表结构，需要重新计算节点在新数组中的位置，并将其插入到新数组对应的位置上。这个过程涉及到对链表的拆分和重组，以确保元素均匀分布在新的buckets中。
- 对于JDK 1.8引入的新特性，当链表长度达到阈值（默认8）时，链表会被转换为红黑树存储，此时扩容也会相应地处理红黑树节点的迁移。

4. **线程安全性**：
- 在多线程环境下，如果多个线程同时尝试修改HashMap可能会导致数据不一致、死锁等问题。因此，在并发场景下应使用`ConcurrentHashMap`，它提供了更高的线程安全性；或者在单线程环境中，应在添加元素前通过`synchronized`等手段确保线程安全。

总之，HashMap通过适时的扩容保持了良好的性能，避免了由于哈希冲突过多而导致的链表过长影响查询效率的问题。然而，扩容是一个相对耗时的操作，因为它涉及到了数组复制以及元素迁移，所以在设计时应合理预估初始容量以减少不必要的扩容次数。

13、Collection 与 Collections 的区别？

**Java中的Collection与Collections的区别：**

1. **Collection接口**
- Collection是Java集合框架的顶层接口，它代表一组对象，提供了对集合进行添加、删除、查询等基本操作的方法。所有实现了Collection接口的类（如List、Set）都继承了这些方法。
- 实际上，Java集合框架包括两种主要类型的集合接口：List和Set，它们都是Collection接口的直接或间接子接口。此外还有Queue和Deque等其他接口。

2. **Collections工具类**
- Collections则是Java提供的一个帮助类，它包含了大量静态方法，用于对实现Collection接口的对象进行诸如排序、查找、填充、替换元素以及线程安全操作等高级功能。
- 例如，你可以使用Collections类的静态方法对List进行排序：
```java
List<String> list = new ArrayList<>();
// ... 添加元素到list
Collections.sort(list);
```
- 或者可以调用`Collections.unmodifiableList()`来创建一个不可修改的视图：
```java
List<String> unmodifiableList = Collections.unmodifiableList(originalList);
```

简而言之，Collection是一个接口，定义了集合的基本行为；而Collections是一个工具类，提供了一系列与集合操作相关的实用方法。

14、说说 List,Set,Map 三者的区别？

**List、Set和Map是Java集合框架中的三种主要接口，它们各自代表不同的数据结构和操作特点：**

1. **List（列表）**
- `java.util.List`是一个有序的元素序列，允许重复元素。
- 实现类包括ArrayList、LinkedList等。
- 特点：
- 元素存储在索引位置上，可以通过索引访问元素，支持随机访问。
- 支持按索引插入和删除元素，并保持元素的顺序不变。
- 允许有相同的元素。

2. **Set（集）**
- `java.util.Set`是一个不允许包含重复元素的集合。
- 实现类包括HashSet、TreeSet等。
- 特点：
- 集合内的元素没有特定的顺序，除非像TreeSet那样实现了SortedSet接口的实现类。
- 添加元素时自动检查并拒绝重复元素。
- 不支持通过索引访问元素。

3. **Map（映射）**
- `java.util.Map`是一个将键与值关联起来的数据结构，每个键必须唯一，可以对应一个值。
- 实现类包括HashMap、TreeMap、LinkedHashMap等。
- 特点：
- 键值对的形式存储数据，键不可重复，但值可以重复。
- 提供了根据键查找值、添加/修改键值对、删除键值对以及判断键是否存在等功能。
- 可以通过键直接访问关联的值，不支持索引访问。

总结来说，List适用于需要维护元素顺序且可能包含重复项的情况；Set适用于需要去重且顺序无关紧要的情况；而Map则用于处理键值关系，适合用来管理具有关联性的数据。

15、ConcurrentHashMap 、 Hashtable、HashMap 的区别?

1. **ConcurrentHashMap（并发哈希表）**：
- **线程安全性**：ConcurrentHashMap是线程安全的，它使用了锁分段技术来保证在高并发环境下的性能。相比于Hashtable采用的全局锁，ConcurrentHashMap将数据分成多个段（Segment），每个段有自己的锁，因此可以同时在不同的段上进行读写操作。
- **效率**：由于采用了更细粒度的锁，所以在并发环境下，ConcurrentHashMap的性能通常优于Hashtable和非线程安全的HashMap。
- **迭代器**：ConcurrentHashMap提供了弱一致性的迭代器，这意味着在迭代期间对映射结构的修改可能不会反映在迭代结果中。

2. **Hashtable**：
- **线程安全性**：Hashtable也是线程安全的，但它通过在所有方法上都加synchronized关键字实现同步，即整个哈希表在任何时刻只能有一个线程对其进行访问（独占锁）。
- **效率**：由于其采用的是全局锁机制，在多线程环境下，如果多个线程需要同时读写，可能会导致性能瓶颈，因为即使只是读操作也需要等待锁释放。
- **迭代器**：Hashtable同样提供线程安全的迭代器，但迭代过程中若发生修改，则会抛出`ConcurrentModificationException`异常。

3. **HashMap**：
- **线程安全性**：HashMap不是线程安全的，在多线程环境下不保证其内部数据的一致性，如果多个线程同时读写HashMap，可能导致数据不一致或抛出异常。
- **效率**：单线程环境下，HashMap由于没有线程安全相关的开销，所以它的插入、删除和查找等操作通常比前两者更快。
- **迭代器**：HashMap提供的迭代器是非线程安全的，当迭代过程中其他线程修改了HashMap，也可能导致`ConcurrentModificationException`异常。

总结来说，如果你的应用场景需要线程安全且重视并发性能，选择ConcurrentHashMap；如果只需要简单的线程安全集合且不需要高并发支持，可以选择Hashtable；而如果是在单线程环境下并且不需要线程安全控制，HashMap则是最佳选择。自Java 5以后，一般推荐优先考虑使用ConcurrentHashMap代替Hashtable，因为它在并发处理上的性能更好。

16、poll()方法和 remove()方法的区别？

在Java的集合框架中，特别是在Queue接口和其实现类如LinkedList、ArrayDeque等中，`poll()`方法和`remove()`方法都用于从队列中移除并返回第一个元素（即队头元素），但它们在处理空队列时的行为不同：

1. `poll()`
- 功能：移除并返回此队列的头元素。如果此队列为空，则返回`null`。
- 示例：
```java
Queue<String> queue = new LinkedList<>();
// 如果queue为空
String removedElement = queue.poll(); // 返回null
```

2. `remove()`
- 功能：移除并返回此队列的头元素。**如果此队列为空，则抛出NoSuchElementException异常**。
- 示例：
```java
Queue<String> queue = new LinkedList<>();
try {
String removedElement = queue.remove(); // 抛出NoSuchElementException
} catch (NoSuchElementException e) {
System.out.println("Queue was empty");
}
```

总结起来，当你不确定队列是否为空且希望安全地尝试获取并移除元素时，使用`poll()`方法更好，因为它不会抛出异常。而如果你确定队列非空或者需要捕获可能发生的异常来处理队列为空的情况，可以选择使用`remove()`方法。

17、什么是Java泛型？泛型在Java的作用？

Java泛型（Generics）是一种在编译时进行类型检查的机制，允许开发者定义类、接口或方法时使用一个或多个类型的占位符，这些占位符在实际使用时可以用具体的类型来替代。这样可以在不丧失类型安全的前提下，编写更通用、可重用的代码。

**Java泛型的作用：**

1. **类型安全性**：
泛型的主要作用是在编译时期确保类型安全，即程序员可以指定容器或其他组件能够存储和操作的数据类型，并且编译器会在编译阶段检查类型兼容性。如果试图将错误类型的数据放入泛型集合中，编译器会拒绝编译，从而避免了运行时由于类型错误导致的ClassCastException异常。

2. **代码复用与简洁性**：
泛型使得程序可以创建通用的类和方法，无需为每种数据类型重复编写相似的代码。例如，可以创建一个`List<T>`泛型类，用于存储任意类型T的对象，而不是分别为String、Integer等每种类型创建单独的List类。

3. **设计灵活性**：
泛型提供了更高的抽象层次，让API设计者可以创建更加灵活和强大的库。使用者可以根据自己的需求指定类型参数，使得代码更具可扩展性和适应性。

4. **增强IDE工具支持**：
泛型还增强了IDE的智能提示和自动补全功能，因为IDE能够在编译时期识别出泛型类型，提供更准确的代码辅助。

举个例子：


 
// 定义一个泛型类
public class Box<T> {
    private T t;
 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
 
// 使用泛型类
Box<String> stringBox = new Box<>();
stringBox.set("Hello, World");
String value = stringBox.get();  // 类型安全地获取String对象
 
Box<Integer> intBox = new Box<>();
intBox.set(42);
int intValue = intBox.get();  // 类型安全地获取Integer对象

在这个例子中，`Box<T>`是一个泛型类，通过传入不同的类型参数（如String或Integer），我们可以创建不同类型的盒子实例。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/523388