java基础知识面试题

"=="用于比较基本数据类型和引用类型变量的地址值是否相等。对于基本数据类型，比较的是它们的实际值；对于引用类型，比较的是它们所引用的对象的地址值。
"equals()"方法用于比较两个对象的内容是否相等。默认情况下，它与"=="的作用相同，比较的是对象的地址值。但是，可以根据具体的类重写该方法，以实现自定义的比较逻辑。

需要注意以下几点：

对于基本数据类型，使用"=="进行比较更加直接和高效。
对于引用类型，使用"equals()"进行比较更加准确和灵活，但需要注意重写"equals()"方法，以满足自定义的比较需求。

总结起来，"=="比较的是变量的值或引用的地址值，而"equals()"比较的是对象的内容。

final，finally，finalize的区别

在Java中，final、finally和finalize是三个不同的关键字，它们具有不同的作用和用法。

1.final：

final是一个修饰符，可以用于修饰类、方法和变量。

用于修饰类时，表示该类不能被继承，即为最终类。
用于修饰方法时，表示该方法不能被子类重写。
用于修饰变量时，表示该变量是一个常量，其值不能被修改。

2.finally：

finally是一个关键字，用于定义一个代码块，通常与try-catch结构一起使用。
finally块中的代码无论是否抛出异常，都会被执行。
finally块通常用于释放资源、关闭连接或执行必要的清理操作。

3.finalize：

finalize是Object类中的一个方法，被用于垃圾回收机制。
finalize方法在对象被垃圾回收之前被调用，用于进行资源释放或其他清理操作。
通常情况下，我们不需要显式地调用finalize方法，而是交由垃圾回收器自动调用。

总结：

final是修饰符，用于限定类、方法和变量的性质。
finally是一个关键字，用于定义一个代码块，在异常处理中用于确保特定代码无论如何都会被执行。
finalize是一个Object类中的方法，用于对象的垃圾回收前的清理操作。

请注意，finalize方法已被废弃，不推荐使用。在现代Java中，可以使用try-with-resources语句或手动释放资源的方式来替代finalize方法的功能。

两个对象 hashCode（）相同，则equals（）否也一定为true？

不一定。

根据Java的规范，如果两个对象的hashCode()返回值相同，那么它们可能相等，但并不保证一定相等。在某些情况下，两个不同的对象可能会产生相同的哈希码，这就是所谓的哈希冲突。因此，在判断两个对象是否相等时，还需要使用equals()方法进行进一步比较。

equals()方法用于比较两个对象的内容是否相等，而hashCode()方法用于获取对象的哈希码。根据Java规范，如果两个对象相等（通过equals()方法比较），它们的哈希码必须相等。但是对于哈希码相等的对象，它们的相等性仍然需要通过equals()方法进行详细比较确认。

为了确保正确的相等性判断，通常需要同时重写equals()和hashCode()方法。在重写equals()方法时，需要定义满足等价关系的比较规则，包括自反性、对称性、传递性和一致性。同时，重写hashCode()方法时，需要保证如果两个对象相等，则它们的哈希码必须相等，以避免哈希冲突。

总结：

两个对象的hashCode()方法返回相同的值，并不能保证它们的equals()方法一定返回true，因此在比较对象的相等性时，需要同时使用equals()方法和hashCode()方法。

抽象类和接口有什么区别

抽象类和接口是Java中的两种机制，用于实现类之间的继承和多态性。它们有以下几点区别：

定义和设计：抽象类是使用abstract关键字定义的类，可以包含抽象方法和非抽象方法，可以有实例变量和构造方法；接口通过interface关键字定义，只能包含抽象方法、默认方法和静态方法，不包含实例变量或构造方法。
继承关系：一个类只能继承自一个抽象类，但可以实现多个接口。继承抽象类体现的是"is-a"关系，而实现接口体现的是"can-do"关系。
构造方法：抽象类可以有构造方法，子类可以通过super()调用父类的构造方法；接口没有构造方法。
默认实现：抽象类可以包含非抽象方法，子类可以直接使用；接口可以包含默认方法，提供通用实现，子类可以选择重写或者使用默认实现。
设计目的：抽象类的设计目的是提供类的继承机制，实现代码复用，适用于拥有相似行为和属性的类；接口的设计目的是定义一组规范或契约，实现类遵循特定的行为和功能，适用于不同类之间的解耦和多态性实现。

总之，抽象类和接口是实现继承和多态性的两种机制。抽象类和接口的设计目的、定义和使用方法等方面都有所区别，需要根据实际情况选择合适的方式进行设计和使用。

BIO、NIO、AIO有什么区别

他们三者都是Java中常用的I/O模型，我们从以下三个维度进行对比：

1.阻塞与非阻塞：

BIO是阻塞式I/O模型，线程会一直被阻塞等待操作完成。
NIO是非阻塞式I/O模型，线程可以去做其他任务，当I/O操作完成时得到通知。
AIO也是非阻塞式I/O模型，不需要用户线程关注I/O事件，由操作系统通过回调机制处理。

2.缓冲区：

BIO使用传统的字节流和字符流，需要为输入输出流分别创建缓冲区。
NIO引入了基于通道和缓冲区的I/O方式，使用一个缓冲区完成数据读写操作。
AIO则不需要缓冲区，使用异步回调方式进行操作。

3.线程模型：

BIO采用一个线程处理一个请求方式，面对高并发时线程数量急剧增加，容易导致系统崩溃。
NIO采用多路复用器来监听多个客户端请求，使用一个线程处理，减少线程数量，提高系统性能。
AIO依靠操作系统完成I/O操作，不需要额外的线程池或多路复用器。

综上所述，BIO、NIO、AIO的区别主要在于阻塞与非阻塞、缓冲区和线程模型等方面。根据具体应用场景选择合适的I/O模型可以提高程序的性能和可扩展性。

String，Stringbuffer，StringBuilder的区别

三者均是Java中用来处理字符串的类，它们之间的主要区别如下：

1.可变性：

String是不可变的类，一旦创建就不能被修改。每次对String进行操作时，都会创建一个新的String对象。
StringBuffer和StringBuilder是可变的类，可以动态修改字符串内容。

2.线程安全性：

String是线程安全的，因为它是不可变的。多个线程可以同时访问同一个String对象而无需担心数据的修改问题。
StringBuffer是线程安全的，它的方法使用了synchronized关键字进行同步，保证在多线程环境下的安全性。
StringBuilder是非线程安全的，不使用synchronized关键字，所以在多线程环境下使用时需要手动进行同步控制。

3.性能：

由于String是不可变的，每次对String进行操作都会创建一个新的String对象，频繁的字符串拼接会导致大量的对象创建和内存消耗。
StringBuffer是可变的，对字符串的修改是在原有对象上进行，不会创建新的对象，因此在频繁的字符串拼接场景下比String更高效。
StringBuilder与StringBuffer类似，但不保证线程安全性，因此在单线程环境下性能更高。

综上，如果在单线程环境下进行字符串操作，且不需要频繁修改字符串，推荐使用String；如果在多线程环境下进行字符串操作，或者需要频繁修改字符串，优先考虑使用StringBuffer；如果在单线程环境下进行频繁的字符串拼接和修改，推荐使用StringBuilder以获取更好的性能。

Java中的基本数据类型有哪些？它们的大小是多少？

在Java中，基本数据类型有以下几种：

1.整数类型：

byte：1字节，在内存中范围为-128到127
short：2字节，在内存中范围为-32768到32767
int：4字节，在内存中范围为约-21亿到21亿
long：8字节，在内存中范围为约-922亿亿到922亿亿

2.浮点数类型：

float：4字节，在内存中约范围为±3.40282347E+38F（有效位数为6-7位）
double：8字节，在内存中约范围为±1.79769313486231570E+308（有效位数为15位）

3.字符类型：

char：2字节，在内存中范围为0到65535，表示一个Unicode字符

3.布尔类型：

boolean：1位，在内存中只能表示true或false

上述大小是Java语言规范中定义的标准大小，表示它们在内存中占用的字节数。请注意，不同的编译器和平台可能会略有差异，但通常情况下这些标准大小是适用的。

Java内部类

Java 类中不仅可以定义变量和方法，还可以定义类，这样定义在类内部的类就被称为内部类。根

据定义的方式不同，内部类分为静态内部类，成员内部类，局部内部类，匿名内部类四种。

静态内部类

定义在类内部的静态类，就是静态内部类

public class Out {
 private static int a;
 private int b;
 public static class Inner {
 public void print() {
 System.out.println(a);
 }
 }
}

静态内部类可以访问外部类所有的静态变量和方法，即使是 private 的也一样。
静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。
其它类使用静态内部类需要使用“外部类.静态内部类”方式，如下所示：Out.Inner inner = new Out.Inner();inner.print();
Java集合类HashMap内部就有一个静态内部类Entry。Entry是HashMap存放元素的抽象， HashMap 内部维护 Entry 数组用了存放元素，但是 Entry 对使用者是透明的。像这种和外部类关系密切的，且不依赖外部类实例的，都可以使用静态内部类。

成员内部类

定义在类内部的非静态类，就是成员内部类。成员内部类不能定义静态方法和变量（final 修饰的

除外）。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内

部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的

public class Out {
 
 
private static int a;
private int b;
public class Inner {
 
public void print() {
System.out.println(a);
System.out.println(b);
}
}
}

局部内部类

定义在方法中的类，就是局部类。如果一个类只在某个方法中使用，则可以考虑使用局部类。

 public class Out {
 private static int a;
 private int b;
 public void test(final int c) {
 final int d = 1;
 class Inner {
 public void print() {
 System.out.println(c);
 }
 }
 }
}

匿名内部类

匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一

个接口。同时它也是没有 class 关键字，这是因为匿名内部类是直接使用 new 来生成一个对象的引用。

 public abstract class Bird {
 private String name;
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public abstract int fly();
}
public class Test {
 public void test(Bird bird){
 System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
 }
 public static void main(String[] args) {
 Test test = new Test();
 test.test(new Bird() {
 public int fly() {
 return 10000;
 }
 public String getName() {
 return "大雁";
 }
 });
 }
}

Comparator与Comparable有什么区别

Comparator和Comparable都是Java中用于对象排序的接口，它们之间有一些关键的区别。

Comparable接口是在对象自身的类中实现的，它定义了对象的自然排序方式。一个类实现了Comparable接口后，可以使用compareTo方法来比较当前对象和其他对象的大小关系。这个接口只能在对象自身的类中实现，不需要额外的比较器。

Comparator接口是一个独立的比较器，它可以用于对不同类的对象进行排序。Comparator接口允许在对象类之外创建一个单独的比较器类或匿名类，并使用它来定义对象的排序规则。比较器通过实现compare方法来比较两个对象的大小关系。

因此，主要区别如下：

Comparable接口是在对象自身的类中实现，定义了对象的自然排序方式。
Comparator接口是一个单独的比较器，定义了用于排序的规则，可以用于不同类的对象排序。
Comparable是内部排序，对象的类必须实现Comparable接口才能进行排序。
Comparator是外部排序，可以独立定义排序规则，并与任何类的对象一起使用。

在使用时，如果需要对对象的默认排序进行操作，可以实现Comparable接口。如果需要对不同类的对象进行排序，或者需要定义多种不同的排序规则，可以使用Comparator接口。

String类能被继承吗，为什么

在Java中，String类是被final关键字修饰的，即不可继承。final关键字表示一个类不允许被其他类继承，也就是说，String类不能被任何其他类继承。

这是因为String类具有不可变性和安全性，这些特性可以防止一些潜在的问题，如字符串池中的重用和安全性漏洞。

如果String类能被继承，子类有可能修改原字符串的值，这将破坏字符串对象的不可变性。此外，String类的方法和变量都被设计成private、final和static的，这说明它们不能被重写或隐藏。如果String类可以被继承，这些设计决策将被打破，可能产生更多的问题。

因此，尽管我们不能从String类派生出新的子类，但我们可以使用String类提供的方法来操作和处理字符串。例如，我们可以使用String类的concat()方法连接两个字符串，或使用indexOf()方法查找子串在字符串中的位置等。String类已经包含了大量的方法，可以满足大多数字符串操作的需求。

Java中变量和常量有什么区别

在Java中，变量和常量是两个不同的概念，它们有以下几点区别：

1.可变性：

变量是可以被修改的，其值可以在程序的执行过程中改变。
常量是不可被修改的，其值在定义后不能再被改变。

2.声明与赋值：

变量需要先声明，并可以在声明后进行赋值。声明时需要指定变量的类型
常量在定义时需要使用final关键字进行修饰

3.内存空间：

变量在内存中占用一块存储空间，可以改变这个存储空间中的值。
常量通常会被编译器在编译时直接替换为对应的值，所以在内存中不会为常量分配额外的存储空间，而是直接使用常量的值。

4.使用场景：

变量用于存储会发生变化的数据，例如计数器、临时结果等，在程序的执行过程中可以根据需要改变其值。
常量用于表示不可变的数据，例如数学常数、配置项等，在程序中通常希望保持其固定的值，避免误操作导致值的变化。

总结来说，变量是可变的并且需要先声明后赋值，而常量是不可变的并且需要在定义时进行初始化赋值。变量占用内存空间且值可以改变，而常量通常会被编译器直接替换为对应的值，不占用额外的内存空间。变量用于存储会发生变化的数据，常量用于表示不可变的数据。

int和Integer的区别

int和Integer之间的区别主要在以下几个方面：

数据类型：int是Java的基本数据类型，而Integer是int的包装类，属于引用类型。
可空性：int是基本数据类型，它不能为null。而Integer是一个对象，可以为null。
自动装箱与拆箱：int可以直接赋值给Integer，这个过程称为自动装箱；而Integer也可以直接赋值给int，这个过程称为自动拆箱。
性能和内存开销：由于int是基本数据类型，它的值直接存储在栈内存中，占用的空间较小且访问速度快。而Integer是对象，它的值存储在堆内存中，占用的空间相对较大，并且访问速度较慢。因此，频繁使用的整数推荐使用int，不需要使用对象特性时可以避免使用Integer。

总的来说，int是基本数据类型，适用于简单的整数运算和存储，没有对象的特性和可空性。而Integer是int的包装类，可以作为对象使用，具有更多的方法和一些方便的功能，如转换、比较等，但相对会带来一些性能和内存开销。

说说你对Integer缓存的理解

在Java中，Integer类对于一定范围的整数值进行了缓存。该范围默认是从-128到127。这意味着当创建一个Integer对象并赋值为在此范围内的整数时，会直接从缓存中返回该数字对应的Integer对象，而不会每次都创建新的对象。

这种缓存的设计主要是出于性能和内存优化的考虑。由于整数在编程中经常被使用，通过缓存重用Integer对象可以减少频繁创建和销毁对象带来的开销，同时节省了内存空间。因为缓存中的对象是提前创建好的，所以可以直接复用，不需要每次创建新的对象。

需要注意的是，虽然缓存的范围可以通过参数进行调整，但这个范围是有限制的，超出范围的整数仍然会创建新的Integer对象。因此，在使用==比较Integer对象时，推荐使用.equals()方法进行值的比较，以避免因为缓存机制而产生的意外结果。

java异常分类及处理

java异常体系

Throwable 是 Java 语言中所有错误或异常的超类。下一层分为 Error 和 Exception

Error

Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果

出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。

Exception （ RuntimeException、CheckedException ）

Exception 又有两个分支，一个是运行时异常 RuntimeException ，一个是

检查异常CheckedException。

RuntimeException 如： NullPointerException 、 ClassCastException ；一个是检查异常

CheckedException，如 I/O 错误导致的 IOException、SQLException。 RuntimeException 是

那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。如果出现 RuntimeException，那么一

定是程序员的错误.

以下是常见的运行时异常：

空指针异常：当应用程序尝试使用 null 对象时抛出。
数组越界异常：当应用程序尝试访问数组元素的时候，数组下标超出了数组的范围。
类转换异常：当应用程序尝试将一个对象强制转换为不是其实例的子类时抛出。
非法参数异常：当应用程序传递了一个无效或不合法的参数时抛出。
非法状态异常：当应用程序调用了一个不合适的方法或处于不正确的状态时抛出。

检查异常 CheckedException ：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强

制程序去捕获此类异常，我们现在使用的编译器都比较智能，一般在代码编写的时候就会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一般包括几个方面：

试图在文件尾部读取数据
试图打开一个错误格式的 URL
试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在

异常的捕获处理方式

Java中的异常处理机制通过使用try-catch-finally语句块来捕获和处理异常。具体的处理过程如下：

使用try块包裹可能会抛出异常的代码块。一旦在try块中发生了异常，程序的控制流会立即跳转到与之对应的catch块。
在catch块中，可以指定捕获特定类型的异常，并提供相应的处理逻辑。如果发生了指定类型的异常，程序会跳转到相应的catch块进行处理。一个try块可以有多个catch块，分别处理不同类型的异常。
如果某个catch块成功处理了异常，程序将继续执行catch块之后的代码。
在catch块中，可以通过throw语句重新抛出异常，将异常交给上一级的调用者处理。
可以使用finally块来定义无论是否发生异常都需要执行的代码。finally块中的代码始终会被执行，无论异常是否被捕获。

抛出异常有三种形式，一是 throw,一个 throws，还有一种系统自动抛异常。

public static void main(String[] args) { 
 String s = "abc"; 
 if(s.equals("abc")) { 
 throw new NumberFormatException(); 
 } else { 
 System.out.println(s); 
 } 
} 
int div(int a,int b) throws Exception{
return a/b;}

Throw 和 throws 的区别

位置不同

throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的是异常对象。

功能不同：

throws 用来声明异常，让调用者只知道该功能可能出现的问题，可以给出预先的处理方式；throw 抛出具体的问题对象，执行到 throw，功能就已经结束了，跳转到调用者，并将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语句，因为执行不到。
throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常，
执行 throw 则一定抛出了某种异常对象。
4. 两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理

java反射

具体可以看这篇文章：

java中的反射和代理模式-CSDN博客

Java 创建对象有几种方式

在Java中，有以下几种常见的方式来创建对象：

使用new关键字：这是最常见的创建对象的方式。通过调用类的构造函数，使用new关键字可以在内存中分配一个新的对象。
使用反射：Java的反射机制允许在运行时动态地创建对象。通过获取类的Class对象，并调用其构造函数，可以实现对象的创建。
使用newInstance()方法：某些类提供了newInstance()方法来创建对象，这种方式只适用于具有默认无参构造函数的类。
使用clone()方法：如果类实现了Cloneable接口，就可以使用clone()方法创建对象的副本。
使用对象的反序列化：通过将对象序列化到一个字节流中，然后再进行反序列化，可以创建对象的副本。

其中，使用new关键字是最常见和推荐的创建对象的方式。其他方式通常在特定场景下使用，如需要动态创建对象或创建对象的副本等情况。

如何实现线程的同步

这里只是简要的回答，详细解答可以看这篇博客

线程的同步是为了保证多个线程按照特定的顺序、协调地访问共享资源，避免数据不一致和竞争条件等问题。

在Java中，常见的线程同步方式有以下几种：

使用synchronized关键字：通过在方法或代码块前加上synchronized关键字，确保同一时间只有一个线程可以执行标记为同步的代码。这样可以避免多个线程同时访问共享资源造成的数据不一致问题。
使用ReentrantLock类：它是一个可重入锁，通过调用lock()和unlock()方法获取和释放锁。与synchronized不同，ReentrantLock提供了更灵活的同步控制，例如可实现公平性和试锁等待时间。
使用wait()、notify()和notifyAll()方法：这些方法是Object类的方法，允许线程间进行协作和通信。通过调用wait()方法使线程进入等待状态，然后其他线程可以通过notify()或notifyAll()方法唤醒等待的线程。
使用CountDownLatch和CyclicBarrier：它们是并发工具类，用于线程之间的同步和等待。CountDownLatch可用于等待一组线程完成操作，而CyclicBarrier用于等待一组线程互相达到屏障位置。

选择适合的同步方式会根据具体需求和场景而定。在使用任何同步机制时，需要注意避免死锁和性能问题，合理设计同步范围和粒度。

什么是守护线程？与普通线程的区别

守护线程是在程序运行时在后台提供一种支持性的线程。与普通线程相比，守护线程有以下几个区别：

终止条件：当所有用户线程结束时，守护线程会自动停止。换句话说，守护线程不会阻止程序的终止，即使它们还没有执行完任务。
生命周期：守护线程的生命周期与主线程或其他用户线程无关。当所有的非守护线程都结束时，JVM 将会退出并停止守护线程的执行。
线程优先级：守护线程的优先级默认与普通线程一样。优先级较高的守护线程也不能够保证在其他线程之前执行。
资源回收：守护线程通常被用于执行一些后台任务，例如垃圾回收、日志记录、定时任务等。当只剩下守护线程时，JVM 会自动退出并且不会等待守护线程执行完毕。

需要注意的是，守护线程与普通线程在编写代码时没有太大的区别。可以通过将线程的setDaemon(true)方法设置为 true，将普通线程转换为守护线程。

总结起来，守护线程在程序运行过程中提供了一种支持性的服务，会在所有的用户线程结束时自动停止。

HashMap和Hashtable有什么区别

详细解答请看下面这篇博文

HashMap和Hashtable的区别-CSDN博客

HashMap和Hashtable都是Java集合框架中Map接口的实现类，它们有以下几个区别：

线程安全性：Hashtable是线程安全的，而HashMap是非线程安全的。Hashtable通过在每个方法前加上synchronized关键字来保证线程安全性，而HashMap则没有实现这种机制。
null值：Hashtable不允许键或值为null，否则会抛出NullPointerException异常。而HashMap可以存储key和value为null的元素。
继承和接口实现：Hashtable继承自Dictionary类，而HashMap则继承自AbstractMap类并实现了Map接口。
初始容量和扩容机制：Hashtable在创建时必须指定容量大小，且默认大小为11。而HashMap可以在创建时不指定容量大小，系统会自动分配初始容量，并采用2倍扩容机制。
迭代器：迭代器 Iterator 对 Hashtable 是安全的，而 Iterator 对 HashMap 不是安全的，因为迭代器被设计为工作于一个快照上，如果在迭代过程中其他线程修改了 HashMap，则会抛出并发修改异常。

什么是Java的序列化

ava的序列化是指将Java对象转换为字节流的过程，可以将这些字节流保存到文件中或通过网络传输。反序列化则是指将字节流恢复成对象的过程。

序列化的主要目的是实现对象的持久化存储和传输，让对象可以在不同的计算机或不同的时间点被重建和使用。通过序列化，可以将对象的状态以字节的形式保存下来，并且在需要的时候进行恢复，从而实现了对象的跨平台传输和持久化存储。

在Java中，要使一个类可序列化，需要满足以下条件：

实现java.io.Serializable接口，该接口是一个标记接口，没有任何方法。
所有的非静态、非瞬态的字段都可以被序列化。

使用Java的序列化机制，可以通过ObjectOutputStream将对象转换为字节流并写入文件或网络流中。反之，通过ObjectInputStream可以从字节流中读取数据并还原为对象。

需要注意的是，在进行序列化和反序列化时，对象的类和字段的定义必须保持一致，否则可能会导致序列化版本不匹配或字段丢失的问题。

Transient 关键字阻止该变量被序列化到文件中

1. 在变量声明前加上 Transient 关键字，可以阻止该变量被序列化到文件中，在被反序列

化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

2. 服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串

等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在

客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的

数据安全。

说说你对内部类的理解

内部类是Java中一种特殊的类，它定义在其他类或方法中，并且可以访问外部类的成员，包括私有成员。

内部类分为如下几种:

成员内部类：定义在一个类的内部，并且不是静态的。成员内部类可以访问外部类的所有成员，包括私有成员。在创建内部类对象时，需要先创建外部类对象，然后通过外部类对象来创建内部类对象。
静态内部类：定义在一个类的内部，并且是静态的。与成员内部类不同，静态内部类不能访问外部类的非静态成员，但可以访问外部类的静态成员。在创建静态内部类对象时，不需要先创建外部类对象，可以直接通过类名来创建。
局部内部类：定义在一个方法或作用域块中的类，它的作用域被限定在方法或作用域块中。局部内部类可以访问外部方法或作用域块中的 final 变量和参数。
匿名内部类：没有定义名称的内部类，通常用于创建实现某个接口或继承某个类的对象。匿名内部类会在定义时立即创建对象，因此通常用于简单的情况，而不用于复杂的类结构。

内部类的主要作用是实现更加灵活和封装的设计。需要注意的是，过度使用内部类会增加代码的复杂性，降低可读性和可维护性。因此，在使用内部类时要考虑其是否真正有必要，并且仔细进行设计和命名。

说说你对lambda表达式的理解

Lambda表达式是Java 8引入的一种简洁的语法形式，用于表示匿名函数。它可以作为参数传递给方法或函数接口，并且可以在需要函数式编程特性的地方使用。

Lambda表达式的语法类似于(参数列表) -> 表达式或代码块。参数列表描述了输入参数，可以省略类型，甚至括号。箭头符号将参数列表与表达式或代码块分隔开来。

Lambda表达式具有以下特点：

简洁：相较于传统的匿名内部类，Lambda表达式更加简洁，能用更少的代码实现相同功能。
函数式编程：支持函数作为一等公民进行传递和操作。
闭包：可以访问周围的变量和参数。
方法引用：可以通过引用已存在的方法进一步简化。

Lambda表达式的应用场景包括：

集合操作：对集合元素进行筛选、映射、排序等操作，使代码简洁和可读。
并行编程：利用Lambda表达式简化并发编程的复杂性。
事件驱动模型：作为回调函数响应用户输入或系统事件。

需要注意，Lambda表达式仅适用于函数式接口（只有一个抽象方法的接口），可直接实现该接口的实例，避免编写传统匿名内部类。Lambda表达式在Java编程中提供了更为灵活和简洁的语法，促进了函数式编程的应用。

说说你对泛型的理解

泛型是Java中的一个特性，它允许我们在定义类、接口或方法时使用类型参数，以实现代码的通用性和安全性。泛型的目的是在编译时进行类型检查，并提供编译期间的类型安全。
泛型的理解包括以下几个方面：
首先，泛型提供了代码重用和通用性。通过使用泛型，我们可以编写可重用的代码，可以在不同的数据类型上执行相同的操作。这样，我们可以避免重复编写类似的代码，提高了开发效率。
其次，泛型强调类型安全。编译器可以在编译时进行类型检查，阻止不符合类型约束的操作。这样可以避免在运行时出现类型错误的可能，增加了程序的稳定性和可靠性。
另外，使用泛型可以避免大量的类型转换和强制类型转换操作。在使用泛型集合类时，不需要进行强制类型转换，可以直接获取正确的数据类型，提高了代码的可读性和维护性。
此外，泛型还可以在编译时进行类型检查，提前发现潜在的类型错误。这种类型检查是在编译时进行的，避免了一些常见的运行时类型异常，减少了错误的可能性。
最后，泛型可以增加代码的可读性和可维护性。通过使用泛型，我们可以明确指定数据类型，并在代码中表达清晰，使得其他开发人员更容易理解代码的意图和功能。

notify()和 notifyAll()有什么区别

在Java中，notify()和notifyAll()都属于Object类的方法，用于实现线程间的通信。
notify()方法用于唤醒在当前对象上等待的单个线程。如果有多个线程同时在某个对象上等待（通过调用该对象的wait()方法），则只会唤醒其中一个线程，并使其从等待状态变为可运行状态。具体是哪个线程被唤醒是不确定的，取决于线程调度器的实现。
notifyAll()方法用于唤醒在当前对象上等待的所有线程。如果有多个线程在某个对象上等待，调用notifyAll()方法后，所有等待的线程都会被唤醒并竞争该对象的锁。其中一个线程获得锁后继续执行，其他线程则继续等待。-
需要注意的是，notify()和notifyAll()方法只能在同步代码块或同步方法内部调用，并且必须拥有与该对象关联的锁。否则会抛出IllegalMonitorStateException异常。

静态内部类与非静态内部类有什么区别

在Java中，静态内部类和非静态内部类都是一种嵌套在其他类中的内部类。它们之间有以下几点区别：

实例化方式：静态内部类可以直接通过外部类名来实例化，而非静态内部类必须要通过外部类的实例来实例化。
对外部类的引用：静态内部类不持有对外部类实例的引用，而非静态内部类则会持有对外部类实例的引用。这意味着在静态内部类中不能直接访问外部类的非静态成员（方法或字段），而非静态内部类可以。
生命周期：静态内部类的生命周期与外部类相互独立，即使外部类实例被销毁，静态内部类仍然存在。非静态内部类的生命周期与外部类实例绑定，只有在外部类实例存在时才能创建非静态内部类的实例。
访问权限：静态内部类对外部类的访问权限与其他类一样，根据访问修饰符而定。非静态内部类可以访问外部类的所有成员，包括私有成员。

String 与new String有什么区别

Java中字符串可以通过两种方式创建：使用字符串字面量直接赋值给变量或使用关键字new创建一个新的String对象。它们之间有以下区别：

首先，使用字符串字面量赋值给变量时，Java会使用字符串常量池来管理字符串对象，可以提高性能和节省内存。而使用new String创建的字符串对象则在堆内存中独立分配内存空间，每次调用都会创建一个新的对象，因此内存消耗更大。

其次，使用字符串字面量赋值给变量的字符串是不可变的，即不能改变其内容。而使用new String创建的字符串对象是可变的，可以通过调用方法或者使用赋值运算符修改其内容。

最后，使用字符串字面量赋值给变量的字符串比较时，如果多个变量引用相同的字符串字面量，则它们实际上引用的是同一个对象，因此比较它们的引用时将返回true。而使用new String创建的字符串对象，即使内容相同，它们也是不同的对象，因此比较它们的引用时将返回false。

反射中，Class.forName和ClassLoader的区别

Class.forName和ClassLoader是Java反射中用于加载类的两种不同方式。
Class.forName是一个静态方法，通过提供类的完全限定名，在运行时加载类。此方法还会执行类的静态初始化块。如果类名不存在或无法访问，将抛出ClassNotFoundException异常。
ClassLoader是一个抽象类，用于加载类的工具。每个Java类都有关联的ClassLoader对象，负责将类文件加载到Java虚拟机中。ClassLoader可以动态加载类，从不同来源加载类文件，如本地文件系统、网络等。
两者区别如下：
●Class.forName方法由java.lang.Class类调用，负责根据类名加载类，并执行静态初始化。
●ClassLoader是抽象类，提供了更灵活的类加载机制，可以自定义类加载过程，从不同来源加载类文件。
一般情况下，推荐使用ClassLoader来加载和使用类，因为它更灵活，并避免执行静态初始化的副作用。Class.forName主要用于特定场景，如加载数据库驱动程序。

JDK动态代理与CGLIB实现的区别

JDK动态代理和CGLIB是Java中常用的两种代理技术，它们在实现原理和使用方式上有一些区别。
●JDK动态代理是基于接口的代理技术，要求目标类必须实现一个或多个接口。它使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来生成代理类和处理代理方法的调用。在运行时，JDK动态代理会动态生成一个代理类，该代理类实现了目标接口，并在方法调用前后插入额外的代码（即代理逻辑）。然而，JDK动态代理只能代理接口，无法代理普通的类。
●CGLIB是基于继承的代理技术，可以代理普通的类，不需要目标类实现接口。它使用字节码生成库，在运行时通过生成目标类的子类来实现代理。CGLIB通过继承目标类创建一个子类，并重写目标方法，以在方法调用前后插入额外的代码（即代理逻辑）。但是，由于继承关系，CGLIB无法代理被标记为final的方法。
总的来说，JDK动态代理适用于基于接口的代理需求，而CGLIB适用于代理普通类的需求。选择使用哪种代理方式取决于具体的需求。如果目标类已经实现了接口且需要基于接口进行代理，可以选择JDK动态代理。而如果目标类没有实现接口，或者需要代理普通类的方法，可以选择CGLIB。

谈谈自定义注解的场景及实现

自定义注解是Java语言的一个强大特性，可以为代码添加元数据信息，提供额外配置或标记。它适用于多种场景。

配置和扩展框架：通过自定义注解，可以为框架提供配置参数或进行扩展。例如，Spring框架中的@Autowired注解用于自动装配依赖项，@RequestMapping注解用于映射请求到控制器方法。
运行时检查：自定义注解可在运行时对代码进行检查，并进行相应处理。例如，JUnit框架的@Test注解标记测试方法，在运行测试时会自动识别并执行这些方法。
规范约束：自定义注解用于规范代码风格和约束。例如，Java代码规范检查工具Checkstyle可使用自定义注解标记违规行为。

实现自定义注解的步骤如下：

使用@interface关键字定义注解。
可在注解中定义属性，并指定默认值。
根据需求，可添加元注解来控制注解的使用方式。
在代码中使用自定义注解。
使用反射机制解析注解信息。

通过合理运用自定义注解，可提高代码的可读性、可维护性和可扩展性。

说说你对设计模式的理解

设计模式是一套经过验证的、被广泛应用于软件开发中的解决特定问题的重复利用的方案集合。它们是在软件开发领域诸多经验的基础上总结出来的，是具有普适性、可重用性和可扩展性的解决方案。
设计模式通过抽象、封装、继承、多态等特性帮助我们设计出高质量、易扩展、易重构的代码，遵循面向对象的设计原则，如单一职责、开闭原则、依赖倒置、里氏替换等，从而提高代码的可维护性、可测试性和可读性。
设计模式的优点在于它们已经被广泛验证，可以避免一些常见的软件开发问题，同时也提供了一种标准化的方案来解决这些问题。使用设计模式可以提高代码的复用性，减少代码的重复编写，增加代码的灵活性和可扩展性。设计模式还能降低项目的风险，提高系统的稳定性。
不过，设计模式不是万能的，对于简单的问题，可能会使代码变得过于复杂，甚至导致反效果。
在使用设计模式时，需要根据具体的问题需求和实际情况来选择合适的模式，避免滥用模式，并保持代码的简洁、清晰和可读性。

设计模式是如何分类的

根据应用目标，设计模式可以分为创建型、结构型和行为型。

创建型模式是关于对象创建过程的总结，包括单例、工厂、抽象工厂、建造者和原型模式。
结构型模式是针对软件设计结构的总结，包括桥接、适配器、装饰者、代理、组合、外观和享元模式。
行为型模式是从类或对象之间交互、职责划分等角度总结的模式，包括策略、解释器、命令、观察者、迭代器、模板方法和访问者模式。

这些模式各自解决特定问题，并在软件开发中得到广泛应用。比如单例模式确保一个类只有一个实例，适配器模式将一个类的接口转换为客户端所期望的另一个接口。装饰者模式动态地给对象添加额外的职责，命令模式将请求封装成一个对象，从而使得可以用不同的请求对客户进行参数化。观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，其依赖者会收到通知并自动更新。
这些设计模式各自具有明确的应用场景和优缺点，在软件开发中的应用可以提高代码的可维护性和复用性，同时也可以减少出错的可能性并提高软件开发效率。

抽象工厂和工厂方法模式的区别

抽象工厂模式和工厂方法模式是两种创建型设计模式，都关注对象的创建，但有一些区别。

抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定具体的类。它适用于需要一次性创建多个相关对象，以形成一个产品族。抽象工厂模式通常由抽象工厂、具体工厂、抽象产品和具体产品组成。通过切换具体工厂实现类，可以改变整个产品族。
工厂方法模式将对象的创建延迟到子类中进行。它定义一个用于创建对象的抽象方法，由子类决定具体实例化哪个类。工厂方法模式适用于需要根据不同条件动态地创建不同类型的对象。它通常由抽象工厂、具体工厂、抽象产品和具体产品组成。通过切换具体工厂子类，可以改变单个产品。

总的来说，抽象工厂模式更关注一系列相关对象的创建，用于创建产品族；工厂方法模式更关注单个对象的创建，用于根据不同条件创建不同类型的对象。

什么是值传递和引用传递

值传递和引用传递是程序中常用的参数传递方式。

值传递是指在函数调用时，将实际参数的值复制一份传递给形式参数，在函数内对形式参数的修改不会影响到实际参数的值。这意味着函数内部对形参的改变不会影响到函数外部的变量。在值传递中，对形参的修改只作用于函数内部。
引用传递是指在函数调用时，将实际参数的引用或地址传递给形式参数，函数内部对形参的修改会影响到实际参数。这意味着函数内部对形参的改变会影响到函数外部的变量。在引用传递中，对形参的修改会直接作用于函数外部的变量。

一般认为,java内的基础类型数据传递都是值传递. java中实例对象的传递是引用传递。

下面是代码示例：

void foo(int value) {
    value = 100;
}
foo(num); // num 没有被改变
StringBuilder sb = new StringBuilder("iphone");
void foo(StringBuilder builder) {
    builder.append("4");
}
foo(sb); // sb 被改变了，变成了"iphone4"。

Java支持多继承么，为什么

Java不直接支持多继承，即一个类不能同时继承多个父类。这是由设计上的考虑和语言特性决定的。
Java中选择了单继承的设计，主要出于以下几个原因：

继承的复杂性：多继承会引入菱形继承等复杂性问题。当一个类同时继承自多个父类时，可能会出现命名冲突、方法重复实现等问题，导致代码难以理解和维护。
接口的存在：Java提供了接口（Interface）的概念来解决多继承的问题。接口允许一个类实现多个接口，从而达到类似多继承的效果。接口与类的分离可以降低代码的耦合度，并且使得类的设计更加灵活和可扩展。
单一职责原则：Java鼓励使用组合而非继承的方式，遵循设计原则中的单一职责原则。通过将功能划分为独立的类，然后在需要时进行组合，可以实现更灵活、可复用的代码结构，提高代码的可维护性。

尽管Java不支持直接的多继承，但可以使用接口或抽象类等方式来模拟部分多继承的功能。接口提供了一种更灵活、更安全的多继承方式，允许类实现多个接口并获得各个接口的方法声明，同时避免了多继承的复杂性问题。

构造器是否可被重写

构造器在Java中是一种特殊的方法，用于创建和初始化对象。与其他普通方法不同，构造器的名称必须与类名一致，并且没有返回类型。
在Java中，构造器不能被直接重写。子类无法定义与父类相同名称和参数的构造器。这是因为构造器是用于创建对象并初始化其状态的特殊方法，它与类的实例化密切相关。如果允许子类重写构造器，那么可能会导致对象的创建和初始化过程出现混乱，破坏了类的结构和设计原则。
然而，子类可以通过调用父类的构造器来完成对继承的父类的初始化操作。在子类的构造器中可以使用关键字super来调用父类的构造器，并传递相应的参数。这样可以确保父类的构造器得到正确地执行，从而完成对父类属性的初始化。
总结起来，构造器本身不能被重写，但子类可以通过调用父类的构造器来实现对父类的初始化操作。

char型变量能存贮一个中文汉字吗

在Java中，char类型是用来表示单个字符的数据类型，它采用Unicode编码，可以存储各种字符，包括中文汉字。
由于Unicode编码使用16位来表示一个字符，char类型占用2个字节的内存空间。而中文汉字通常使用UTF-8编码，一个中文字符占用3个字节的存储空间。因此，将一个中文汉字直接赋值给char类型的变量可能会出现问题，因为无法完整地表示一个中文字符。
如果要在char类型中表示一个中文汉字，可以使用Unicode转义序列。\u后面跟着表示字符的四位十六进制值，通过转义序列可以正确地表示一个中文汉字。例如，字符 '中' 的Unicode编码为'\u4e2d'，我们可以使用char类型变量去存储这个中文汉字：char ch = '\u4e2d';。
需要注意的是，对于一个完整的中文字符，建议使用更适合的数据类型，如String类型来存储。 char类型主要用于表示单个字符，而不是用于存储复杂字符集合。

如何实现对象克隆

在Java中，实现对象的克隆有两种方式: 引用拷贝、浅拷贝和深拷贝。

1.引用拷贝

引用拷贝是指两个变量或对象同时引用同一块内存地址，它们共享相同的数据。当一个对象发生改变时，另一个对象也会受到影响。在引用拷贝中，只复制了对象的引用，而没有复制对象本身的内容

public class QuoteCopy {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("riemann", 28);
        Teacher otherTeacher = teacher;
        System.out.println(teacher);
        System.out.println(otherTeacher);
    }
}

class Teacher {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

com.test.Teacher@28a418fc
com.test.Teacher@28a418fc

结果分析：由输出结果可以看出，它们的地址值是相同的，那么它们肯定是同一个对象。teacher和otherTeacher的只是引用而已，他们都指向了一个相同的对象Teacher(“riemann”,28)。这就叫做引用拷贝。

浅拷贝和深拷贝都属于对象拷贝。
2.浅拷贝：浅拷贝是指创建一个新的对象，但是该对象的基本数据类型（如数字、字符串等）会被复制，而引用类型数据（如对象、数组等）只是复制了引用，而不是真正的内容。因此，对于引用类型数据来说，浅拷贝后的对象和原始对象仍然会共享同一块内存地址。

public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("riemann");
        teacher.setAge(28);

        Student student1 = new Student();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student student2 = (Student) student1.clone();
        System.out.println("-------------拷贝后-------------");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());

        System.out.println("-------------修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("jack");
        System.out.println("student1的teacher为： " + student1.getTeacher().getName());
        System.out.println("student2的teacher为： " + student2.getTeacher().getName());

    }
}

class Teacher implements Cloneable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

class Student implements Cloneable {
    private String name;
    private int age;
    private Teacher teacher;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }
}

输出结果：

-------------拷贝后-------------
edgar
18
riemann
28
-------------修改老师的信息后-------------
student1的teacher为： jack
student2的teacher为： jack

结果分析：两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。

Object类中提供了一个clone()方法，clone() 方法用于创建并返回当前对象的一个副本，被称为对象的克隆。但是需要注意的是，clone() 方法是浅拷贝。

要使用 clone() 方法，需要满足以下条件：

被复制的类必须实现 Cloneable 接口，否则在调用 clone() 方法时会抛出 CloneNotSupportedException 异常。
在被复制的类中，需要重写 clone() 方法，并且将访问修饰符改为 public。

3.深拷贝：深拷贝是指创建一个新的对象，并且该对象的所有数据（包括基本数据类型和引用类型）都会被复制，而不是简单地复制引用。深拷贝后的对象是完全独立的，对其进行修改不会影响原始对象。实现深拷贝有以下方式：

使用序列化和反序列化实现深拷贝，要求对象及其引用类型字段实现Serializable接口。

public class jvmtestMain {
    public static <T> T deepClone(T obj) throws IOException, ClassNotFoundException {
        //序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bos);
        out.writeObject(obj);
        out.close();

        //反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream in = new ObjectInputStream(bis);
        T clone = (T) in.readObject();
        in.close();

        return clone;
    }

    public static void main(String[] args) {
        Address originalAddress = new Address("New York");
        Person originalPerson = new Person("Alice", originalAddress);

        try {
            // Perform deep clone using serialization
            Person clonedPerson = deepClone(originalPerson);

            // Modify the cloned object
            clonedPerson.setName("Bob");
            clonedPerson.getAddress().setCity("Los Angeles");

            System.out.println("Original Person: " + originalPerson.getName() + ", " + originalPerson.getAddress().getCity());
            System.out.println("Cloned Person: " + clonedPerson.getName() + ", " + clonedPerson.getAddress().getCity());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class Address implements Serializable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city){
        this.city=city;
    }
}

class Person implements Serializable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }
}

自定义拷贝方法，递归拷贝引用类型字段。
第三方工具

for-each与常规for循环的效率区别

在Java中，for-each循环（也称为增强型for循环）和常规for循环有一些差异，包括它们在执行效率上的区别。下面是它们之间的一些比较：

执行效率：在大多数情况下，常规for循环的执行效率比for-each循环高。这是因为for-each循环需要额外的步骤来获取集合或数组中的元素，而常规for循环可以直接通过索引访问元素，避免了额外的开销。
可变性：常规for循环具有更大的灵活性，可以在循环过程中修改计数器，从而控制循环的行为。而for-each循环是只读的，不能在循环过程中修改集合或数组的元素。
代码简洁性：for-each循环通常比常规for循环更加简洁易读，尤其在遍历集合或数组时。使用for-each循环可以减少迭代器或索引变量的声明和管理，使代码更加清晰。

package com.kjz.nowcoder;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedList;


public class TestForTime {
    public static void main(String[] args) {

        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i < 100000000; i++) {
            arrayList.add(1);
        }
        long startTime;
        long endTime;

        System.out.println("=======对ArrayList操作=======");

        startTime = Calendar.getInstance().getTimeInMillis();
        int size = arrayList.size();
        for (int i = 0; i < size; i++) {

        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("空循环耗时:" + (endTime - startTime)+"ms");

        startTime = Calendar.getInstance().getTimeInMillis();
        int size2 = arrayList.size();
        for (int i = 0; i < size2; i++) {
            int iValue = arrayList.get(i);
        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("普通for循环，使用get()耗时:" + (endTime - startTime)+"ms");

        startTime = Calendar.getInstance().getTimeInMillis();
        for (int iValue : arrayList) {

        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("for-each耗时:" + (endTime - startTime)+"ms");

        startTime = Calendar.getInstance().getTimeInMillis();
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            int iValue = (int) iterator.next();
        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("使用Iterator耗时:" + (endTime - startTime)+"ms");


        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < 100000; i++) {
            linkedList.add(1);
        }

        System.out.println("=======对LinkedList操作=======");

        startTime = Calendar.getInstance().getTimeInMillis();
        int size3 = linkedList.size();
        for (int i = 0; i < size3; i++) {

        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("空循环耗时:" + (endTime - startTime)+"ms");

        startTime = Calendar.getInstance().getTimeInMillis();
        int size4 = linkedList.size();
        for (int i = 0; i < size4; i++) {
            int iValue = linkedList.get(i);
        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("普通for循环，使用get()耗时:" + (endTime - startTime)+"ms");

        startTime = Calendar.getInstance().getTimeInMillis();
        for (int iValue : linkedList) {

        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("for-each耗时:" + (endTime - startTime)+"ms");

        startTime = Calendar.getInstance().getTimeInMillis();
        Iterator iterator2 = linkedList.iterator();
        while (iterator2.hasNext()) {
            int iValue = (int) iterator2.next();
        }
        endTime = Calendar.getInstance().getTimeInMillis();
        System.out.println("使用Iterator耗时:" + (endTime - startTime)+"ms");
    }
}

运行结果如下：

实验中，分别使用了ArrayList和LinkedList作为操作对象，结果如下：

=======对ArrayList操作=======
空循环耗时:27ms
普通for循环，使用get()耗时:126ms
for-each耗时:257ms
使用Iterator耗时:180ms
=======对LinkedList操作=======
空循环耗时:2ms
普通for循环，使用get()耗时:3495ms
for-each耗时:3ms
使用Iterator耗时:3ms


Process finished with exit code 0

由运行结果可以看出，若以ArrayList作为操作对象，for-each的效率比普通for循环低许多，但是若以LinkedList作为操作对象，for-each的效率与普通for循环的效率不在一个量级，原因也是因为对LinkedList使用了get(index)，导致每次访问数据需从链表头开始遍历，耗时增加。

尽管常规for循环在执行效率上可能更高，但在大多数实际情况下，两者之间的性能差异不会对程序性能产生显著影响。因此，根据具体的使用场景和代码可读性的需求，可以选择使用for-each循环或常规for循环。在只需要遍历集合或数组而不修改其中元素的情况下，for-each循环是一个方便且简洁的选择。

说说你对懒汉模式和饿汉模式的理解

懒汉模式和饿汉模式都是单例模式的实现方式，用于确保一个类只有一个实例存在。

懒汉模式：在首次使用时才进行对象的初始化，延迟加载实例。它可以避免不必要的资源消耗，但在多线程环境下需要考虑线程安全和同步开销。
饿汉模式：在类加载时就进行对象的初始化，无论是否需要。它通过类加载机制保证线程安全性，而且获取实例的性能开销较小。但它没有延迟加载的特性，可能浪费一些资源。

选择懒汉模式还是饿汉模式取决于具体需求。如果需要延迟加载且对性能要求不高，可以选择懒汉模式。如果要通过类加载机制保证线程安全且对象创建成本较低，可以选择饿汉模式。也可以结合两种模式的优点，使用双重检查锁、静态内部类等方式实现单例模式，提高线程安全性和性能。

2个不相等的对象有可能具有相同hashCode吗

有可能
两个不相等的对象有可能具有相同的哈希码。哈希码是由对象的哈希函数生成的一个整数值，用于支持快速查找和比较对象。
然而，由于哈希码的范围通常比对象的数量小得多，因此不同的对象可能会产生相同的哈希码。这种情况被称为哈希冲突。
哈希算法设计的目标是将不同的输入均匀分布在哈希码空间中，但无法避免完全消除冲突。因此，当发生哈希冲突时，哈希算法会使用特定的策略（例如链表或树结构）来处理这些冲突，以确保不同的对象可以存储在同一个哈希桶中。
综上所述，虽然不同的对象可能具有相同的哈希码，但哈希码仅用于初步判断对象是否可能相等，最终的相等性检查还需要通过 equals() 方法进行。因此，在重写 equals() 方法时，也应该相应地重写 hashCode() 方法，以尽量减少哈希冲突的发生。

讲讲你对ThreadLocal的理解

ThreadLocal是Java中的一个类，用于在多线程环境下实现线程局部变量存储。它提供了一种让每个线程都拥有独立变量副本的机制，从而避免了多线程之间相互干扰和竞争的问题。
在多线程编程中，共享变量的访问往往需要考虑线程安全性和数据隔离问题。ThreadLocal通过为每个线程创建独立的变量副本来解决这些问题。每个线程可以独立地对自己的变量副本进行操作，而不会影响其他线程的副本。
ThreadLocal的核心思想是以"线程"为作用域，在每个线程内部维护一个变量副本。它使用Thread对象作为Key，在内部的数据结构中查找对应的变量副本。当通过ThreadLocal的get()方法获取变量时，实际上是根据当前线程获取其对应的变量副本；当通过set()方法设置变量时，实际上是将该值与当前线程关联，并存储在内部的数据结构中。
使用ThreadLocal时需要注意以下几点：

内存泄漏：在使用完ThreadLocal后，应及时调用remove()方法清理与当前线程相关的变量副本，避免长时间持有引用导致内存泄漏。
线程安全性：ThreadLocal本身并不解决多线程并发访问共享变量的问题，需要额外的同步机制来保证线程安全性。
数据隔离：ThreadLocal适用于多线程环境下需要保持变量独立性的场景，可以避免使用传统的同步方式对共享变量进行操作，提高并发性能。

ThreadLocal常见的应用场景包括线程池、Web开发中的请求上下文信息管理、数据库连接管理和日志记录等。通过合理使用ThreadLocal，可以简化多线程编程，并提高程序的性能和可维护性。

想要详细了解可以去阅读下面这篇博客

ThreadLocal从使用到实现原理与源码详解-CSDN博客

ThreadLocal有哪些应用场景

ThreadLocal是Java中的一个类，它提供了一种在多线程环境下实现线程局部变量存储的机制。
它的应用场景包括线程池、Web开发中的请求上下文信息管理、数据库连接管理和日志记录等等。
在线程池中，可以使用ThreadLocal为每个线程维护独立的上下文信息，避免线程间互相干扰。
在Web开发中，可以使用ThreadLocal存储当前请求的上下文信息，避免参数传递的复杂性。
在数据库连接管理中，ThreadLocal可以为每个线程保持独立的数据库连接，提高并发性能。
在日志记录中，ThreadLocal可以将日志记录与当前线程关联起来，方便追踪和排查问题。
此外，ThreadLocal还可以用于在线程之间传递全局的上下文信息。
在使用ThreadLocal时需要注意内存泄漏问题和线程安全性，及时清理不再需要的变量副本，并采取适当的同步措施保证线程安全。通过合理使用ThreadLocal，可以简化多线程编程，提高程序的性能和可维护性。

讲讲你对CountDownLatch的理解

CountDownLatch是Java中用于多线程协作的辅助类，它可以让一个或多个线程等待其他线程完成某个任务后再继续执行。
CountDownLatch通过一个计数器来实现，计数器的初始值可以设置为等待的线程数量。每个线程在完成任务后都会调用countDown()方法来减少计数器的值。当计数器的值减至0时，等待在CountDownLatch上的线程就会被唤醒，可以继续执行后续的操作。
CountDownLatch的主要作用是协调多个线程的执行顺序，使得某个线程（或多个线程）必须等待其他线程完成后才能继续执行。它常用于以下场景：

主线程等待多个子线程完成任务：主线程可以使用await()方法等待所有子线程完成，然后进行结果的汇总或其他操作。
多个线程等待外部事件的发生：多个线程可以同时等待某个共同的事件发生，比如等待某个资源准备就绪或者等待某个信号的触发。
控制并发任务的同时开始：在某些并发场景中，需要等待所有线程都准备就绪后才能同时开始执行任务，CountDownLatch提供了一种便捷的方式来实现这一需求。

需要注意的是，CountDownLatch的计数器是不能被重置的，也就是说它是一次性的。一旦计数器减至0，它将无法再次使用。如果需要多次使用可重置的计数器，则可以考虑使用CyclicBarrier。

讲讲你对CyclicBarrier的理解

CyclicBarrier是Java中的一个多线程协作工具，它可以让多个线程在一个屏障点等待，并在所有线程都到达后一起继续执行。与CountDownLatch不同，CyclicBarrier可以重复使用，并且可以指定屏障点后执行的额外动作。
CyclicBarrier的主要特点有三个。

首先，它可以重复使用，这意味着当所有线程都到达屏障点后，屏障会自动重置，可以用来处理多次需要等待的任务。
其次，CyclicBarrier可以协调多个线程同时开始执行，这在分阶段任务和并发游戏等场景中非常有用。
最后，CyclicBarrier还提供了可选的动作，在所有线程到达屏障点时执行，可以实现额外的逻辑。

需要注意的是，在创建CyclicBarrier时需要指定参与线程的数量。一旦所有参与线程都到达屏障点后，CyclicBarrier解除阻塞，所有线程可以继续执行后续操作。

JDK、JRE、JVM有什么联系

JDK（Java Development Kit）：
- JDK是Java开发工具包，它包含了所有必要的工具和库，用于开发、编译、调试和运行Java应用程序。
- 它包含JRE，并提供了额外的开发工具，如编译器（javac）、打包工具（jar）、文档生成工具（javadoc）等。
JRE（Java Runtime Environment）：
- JRE是Java运行时环境，它提供了运行Java应用程序所需的库和JVM。
- 它不包含开发工具，只包含运行Java应用程序所需的组件。
JVM（Java Virtual Machine）：
- JVM是Java虚拟机，它是Java平台的核心。它负责执行Java字节码，并且为Java应用程序提供了一个与底层操作系统和硬件无关的运行环境。
- JVM由JRE提供，它是Java应用程序运行的基础。

JDK包含JRE：JDK包含了JRE，因此它包含了JVM。这意味着JDK可以用来开发和运行Java应用程序。
JRE包含JVM：JRE是JVM的实现，它为Java应用程序提供了一个运行环境。JRE不包含开发工具，只包含运行时所需的库和JVM。
JVM运行在JRE中：JVM是JRE的一部分，它负责执行Java字节码。JRE提供了JVM运行所需的库和其他资源。

java中的注解

4 种标准元注解

元注解的作用是负责注解其他注解。 Java5.0 定义了 4 个标准的 meta-annotation 类型，它们被

用来提供对其它 annotation 类型作说明。

@Target 修饰的对象范围

@Target说明了Annotation所修饰的对象范围： Annotation 可被用于 packages、types（类、

接口、枚举、Annotation 类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch 参数）。在 Annotation 类型的声明中使用了 target 可更加明晰其修饰的目标

例如：

/**
 * 自定义Log注解
 */
@Target({ElementType.METHOD})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

@Retention 定义被保留的时间长短

Retention 定义了该 Annotation 被保留的时间长短：表示需要在什么级别保存注解信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效），取值（RetentionPoicy）由：

SOURCE:在源文件中有效（即源文件保留）
CLASS:在 class 文件中有效（即 class 保留）
RUNTIME:在运行时有效（即运行时保留）

@Documented 描述 -javadoc

@ Documented 用于描述其它类型的 annotation 应该被作为被标注的程序成员的公共 API，因此可以被例如 javadoc 此类的工具文档化。

@Inherited 阐述了某个被标注的类型是被继承的

@Inherited 元注解是一个标记注解， @Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的 annotation 类型被用于一个 class，则这个 annotation 将被用于该 class 的子类。

注解处理器

如果没有用来读取注解的方法和工作，那么注解也就不会比注释更有用处了。使用注解的过程中，

很重要的一部分就是创建于使用注解处理器。Java SE5 扩展了反射机制的 API，以帮助程序员快速的构造自定义注解处理器。下面实现一个注解处理器

首先自定义一个注解：

 /1：*** 定义注解*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitProvider {
 /**供应商编号*/
public int id() default -1;
/*** 供应商名称*/
 public String name() default ""；
 /** * 供应商地址*/
 public String address() default "";
}

使用注解：

public class Apple {
 @FruitProvider(id = 1, name = "陕西红富士集团", address = "陕西省西安市延安路")
 private String appleProvider;
 public void setAppleProvider(String appleProvider) {
 this.appleProvider = appleProvider;
          }
 public String getAppleProvider() {
 return appleProvider;
        }
}

注解处理器：

public class FruitInfoUtil {
 public static void getFruitInfo(Class<?> clazz) {
 String strFruitProvicer = "供应商信息：";
 Field[] fields = clazz.getDeclaredFields();//通过反射获取处理注解
 for (Field field : fields) {
 if (field.isAnnotationPresent(FruitProvider.class)) {
 FruitProvider fruitProvider = (FruitProvider) field.getAnnotation(FruitProvider.class);
//注解信息的处理地方 
strFruitProvicer = " 供应商编号：" + fruitProvider.id() + " 供应商名称："
 + fruitProvider.name() + " 供应商地址："+ fruitProvider.address();
 System.out.println(strFruitProvicer);
    }
   }
  }
}

测试：

public class FruitRun {
 public static void main(String[] args) {
 FruitInfoUtil.getFruitInfo(Apple.class);
/***********输出结果***************/
// 供应商编号：1 供应商名称：陕西红富士集团 供应商地址：陕西省西安市延
       }
}

编程小猹

关注

11
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
java基础知识面试题

守护线程是在程序运行时在后台提供一种支持性的线程。当所有用户线程结束时，守护线程会自动停止。换句话说，守护线程不会阻止程序的终止，即使它们还没有执行完任务。守护线程的生命周期与主线程或其他用户线程无关。当所有的非守护线程都结束时，JVM 将会退出并停止守护线程的执行。守护线程的优先级默认与普通线程一样。优先级较高的守护线程也不能够保证在其他线程之前执行。守护线程通常被用于执行一些后台任务，例如垃圾回收、日志记录、定时任务等。当只剩下守护线程时，JVM 会自动退出并且不会等待守护线程执行完毕。
复制链接

扫一扫