Java 基础面试300题（171- 200）

171.什么是同步？

当多个线程试图同时访问共享资源时，那么他们需要以某种方式让资源一次只能由一个线程访问。实现这一目标的过程被称为同步。Java提供了一个名为synchronized的关键字实现这一目标。

172.执行以下代码时会发生什么？

class TestMyRunnable implements Runnable {
public void run() {
System.out.println(“Inside Run Method..”);
System.out.println(“Name of thread is– “:Thread.currentThread().getName());
}
}
class TestMyThread {
public static void main(String argument[]) {
TestMyRunnable runnable = new TestMyRunnable();
Thread thread = new Thread(runnable);
Thread.setName(“My Thread”); //Line 1
thread.start(); //Line 2
}
}

上述代码编译没有问题。执行第1行时，将线程的名称设置为My Thread，执行第2行时，会生成一个新的线程，并执行run()方法中的代码，该方法在控制台上打印如下一些信息：

Inside Run Method.
Name of thread is: My Thread

173. 下面代码首先打印“Thread 1”1000次，然后打印“Thread 2” 1000次，是否正确？

class TestMyRunnable implements Runnable {
public void run() {
for (int iValue = 0; iValue < 1000; iValue++)
System.out.println(“Name of thread is: “+Thread.currentThread().getName());
}
public static void main (String argument[]) {
TestMyRunnable runnable = new TestMyRunnable();
Thread threadC = new Thread(runnable);
Thread threadD = new Thread(runnable);
threadC.setName(“Thread 1”);
threadD.setName(“Thread 2”);
threadC.start();
threadD.start();
}
}

不正确。执行上述代码时，不会如问题所说述，首先打印Thread 11000次，然后 Thread 2 1000次。线程执行的顺序取决于线程调度器。因此，尽管最终两个线程都会打印1000次名称，但它们打印的顺序是不确定的，有可能是交错打印。

174.如何使线程暂停十分钟？

为了使线程暂停十分钟，需要在run()方法中调用sleep()方法。这个方法接受一个长整形参数，其值表示线程以毫秒为单位的睡眠时间。如下代码所示：

try {
Thread.sleep(10 * 60 * 1000)
}
catch(InterruptedException exp) {
}

175. 当调用同步方法时会发生什么？

每当执行同步方法时，调用该方法的线程都会获取一个锁，并将锁一直保持到在方法结束。然后释放锁。因此，其他线程可以再次获取锁并执行该方法。因此，同步（synchronized）关键字可防止多个线程在同步方法中同时执行代码。

176.执行以下代码时会发生什么？

File myFile = new File(“CoreJava.txt”);

执行上述代码时，JVM在内存中会创建一个名为myFile的Java 文件对象，但并不会文件系统上实际创建文件。为了实际创建文件，需要调用myFile.createNewFile()方法。

177.如何创建路径为`/usr/test.txt`文件？

下面代码将在/usr/目录中创建一个文件test.txt：

try {
File txtFile = new File(“/usr/test.txt”); // Line 1
txtFile.createNewFile(); // Line 2
} catch (IOException exp) {
}

在上述代码中，执行第1行时，在内存中创建一个文件对象txtFile，执行第2行时，在文件夹/usr/中创建文件test.txt

178.用代码示例解释`FileWriter`类。

FileWriter类用于将字符或字符串写入文件，而无需将其转换为字节数组。它们是PrintWriter或BufferedWriter的包装类，因而能提供更好的性能和更多的数据写入方法。以下代码演示了FileWriter：

try {
File txtFile = new File(“/usr/CoreJava.txt”);
FileWriter myFileWriter = new FileWriter(txtFile);
myFileWriter.write(“Line 1 \n Line 2 \n”); // Line 1
myFileWriter.flush();
myFileWriter.close();
} catch (IOException exp) {
}

在上述代码中，当执行第1行时，write()方法将内容写入文件CoreJava.txt

179.如何使用`FileReader`读取文件`/usr/CoreJava.txt`中的内容，并在控制台上输出？

下面代码演示了如何使用FileReader读取指定文件中的内容，并在控制台上输出：

try {
File txtFile = new File(“F:/CoreJava.txt”);
char [] totalChar = new char[1000];
FileReader myFileReader = new FileReader(txtFile);
myFileReader.read(totalChar); //Line 1
for(char readChar: totalChar) {//Line 2
System.out.print(readChar);
}
myFileReader.close();
}
catch (IOException exp) {
}

执行第1行时，read()方法将文件内容读取到totalChararray中。第2行开始的for循环将数组的内容打印到控制台

180.如何在文件系统上创建目录？

File类有一个名为mkdir()的方法，用来创建一个与指定文件对象相对应的目录。下面代码使用此方法在文件系统中创建一个目录：

File myDirectory = new File(“/usr/mydir”); //Line 1
myDirectory.mkdir(); //Line 2

第1行创建一个文件对象。第2行调用mkdir()方法来创建实际目录。

181. 编译和执行下面代码时会发生什么？

File myDirectory = new File(“/usr/JavaCodes”);
File myNewFile = new File(“/usr/JavaCodes/CoreJava.txt”); //line 1
myNewFile.createNewFile();

上述代码会抛出IOException。这是因为没有创建目录/usr/JavaCodes/，只创建了与之对应的文件对象myDirectory。为了使代码正常工作，需要在第1行之前添加如下代码：

myDirectory.mkdir();

182. `PrintWriter`类有什么作用？

PrintWriter是Writer类的特定实现，可用于将对象的格式化表示写入到到文件系统。下面代码演示了如何使用PrintWriter来写入字符串：

File myNewFile = new File(“/usr/CoreJava.txt”);
PrintWriter myPrintWriter = new PrintWriter(myNewFile); //Line 1
myPrintWriter.println(“This gets inserted into the File”); //Line 2
myPrintWriter.close(); //Line 3

在上述代码中，执行第1行时，将在文件夹/usr/中创建文件CoreJava.txt。执行第2行时，调用PrinterWriter类的println() 方法将字符串写入文件CoreJava.txt 。执行第3行时，关闭文件。最终内容会被保存到文件中。

183. 如何删除文件？

File类有一个名为delete()的方法，用于删除文件。如下代码示例：

File myNewFile = new File(“/usr/CoreJava.txt”);
boolean success = myNewFile.delete(); //Line 1

在上述代码中，执行第1行时，delete()方法会删除指定的文件。它返回一个布尔值，表示文件删除是否成功。

184. 如何重命名文件或目录？

File 类有一个名为renameTo()的方法，用于重命名文件或目录。如下代码示例：

File file1 = new File(“/usr/file1.txt”);
file1.createNewFile();
File file2 = new File(“/usr/file2.txt”);
file1.renameTo(file2); //Line 1

上述代码将文件file1.txt重命名为file2.txt。同样也可以对目录的重命名。下面代码将目录dir1重命名为dir2：

File dir1 = new File(“/usr/dir1”);
dir1.createNewFile();
File dir2 = new File(“/usr/dir2”);
dir1.renameTo(dir2); //Line 1

185.Java的哪些类用于序列化和反序列化对象？

序列化是将对象写入文件系统的过程。java.io.ObjectOutputStream类可用于序列化对象。它有一个writeObject()方法，用来将对象写到文件系统。反序列化是序列化的逆过程，用来从文件系统恢复序列化的对象。 java.io.ObjectInputStream类可用于反序列化。它有一个readObject()方法，可用于实现这一目标。

186. `File`类上有哪一些重要方法？

文件类File封装了文件系统上的文件或目录。File类上的一些重要方法如下：

方法	描述
createNewFile()	创建一个新的空文件。
list()	返回当前目录中的文件/目录数组。
delete()	从文件系统中删除文件。
mkdir()	创建一个目录。
getAbsolutePath()	返回文件的绝对路径。

187. 编译执行下面代码片段时会发生什么？

public class Test {
public static void main(String argument[]) {
int iValue;
System.out.println(iValue);
}
}

上述代码将导致编译错误。这是因为局部变量iValue没有初始化，而直接在Sysout语句中使用。可以通过初始化变量iValue来修复错误，具体如下：

int iValue = 0;
System.out.println(iValue);

188.编译执行下面代码片段时会发生什么？

class Calculate {
float fValue = 10.2f;
public static void main(String argument[]) {
System.out.println(“Float value is: “+fValue);
}
}

上述代码将导致编译错误，因为main方法是静态方法，却试图访问非静态的实例变量fvalue。Java不允许从静态方法访问非静态变量。

189.什么是对称相等合同？

假设有两个对象v1和v2。如果v1.equals(v2)返回true，则v2.equals(v1)也返回true。这个equals（）合同被称为对称相等合同。考虑以下代码,：

Object v1; Object v2;
v1.equals(v2); //Line 1
v2.equals(v1); //Line 2

因此，在对称相等合同的情况下，第1行返回true，当且仅当第2行y也返回true。

190. 下面代码哪项是错误的语句，为什么？

System.out.println(2+2); //line 1
int i= 2+’2’; //line 2
String s= “one”+’two’; //line 3
byte b=256; //line 4

第1行和第2行是有效的语句。

第3行错误。 Java中因为单引号不能用于字符串，它们只能用于字符常量。字符串需要用双引号括起来。

第4行也是错误语句。字节变量b不能分配值256，因为它不在字节类型的范围内。

191.瞬态`transient`关键字的用途是什么？

可以在实例变量上指定transient关键字，表示当对象序列化时，不应保存其值，换句话说，对象序列化时不会序列化 transient的实例变量。考虑以下代码片段：

class Electronics implements Serializable {
transient private int price; //Line 1
private int quantity; //Line 2
}

当序列化Electronics类的实例时，价格字段price将不会序列化，只有数量字段quantity会序列化。

192.什么是Java中的垃圾回收？

垃圾回收是释放分配给不再使用的对象的内存的过程。在Java程序运行期间，当创建对象时，JVM会分配一些内存来保存对象。JVM会定期检查正在使用的对象，并回收那些不再使用的对象的内存。有了垃圾回收，程序员再也不必费心地手动释放内存。

193.内存的哪一部分用于垃圾回收？JVM使用哪种算法进行垃圾回收？

垃圾回收是在堆内存中完成的。JVM在内部使用标记和扫描算法进行垃圾回收。

194.垃圾回收什么时候发生？

JVM（Java虚拟机）控制垃圾回收的过程。因此，JVM决定垃圾回收何时运行。虽然可以通过Java代码调用System.gc()或Runtime.getRuntime().gc()方法显式请求垃圾回收。但并不能保证调用这些方法会运行垃圾回收。

195.如何通过代码触发垃圾回收？

垃圾回收可以通过以下方式之一触发：

方法1: 使用Runtime.gc（）如下：

Runtime runTime = Runtime.getRuntime();
runTime.gc();

方法2: 使用System.gc（）如下：

System.gc();

这两种方法都不能保证垃圾被立即回收，它们只是请求JVM 执行垃圾回收，最终由JVM实际决定何时运行垃圾回收。

196. 哪些对象有资格进行垃圾回收？

如果一个对象不再被引用时，它就有资格进行垃圾收集。下面几个场景中的对象都有资格成为垃圾回收的对象：

场景1-将对象设置为空

String stringValue = “This is a String value”; //Line 1
stringValue = null; //stringValue 有资格被回收

场景2-重新分配变量

String str1 = “Hello”;
String str2 = str1; // str1 有资格被回收

场景3-在方法中创建的对象

public void doSomething(){
String str1 = “Hello”;
}
public void callMethod(){
doSomething();
//doSomething 方法中的str1有资格被回收 
}

197.什么是函数接口？如何创建函数接口？

函数接口是一个只有一个抽象方法的接口。为了创建一个函数接口，只需要简单创建一个只有一个抽象方法的接口，如下所示：

@FunctionalInterface
public interface Multiplier {
public int multiply(int a, int b);
}

上述代码定义了一个名为Multiplier的接口，它只有一个抽象方法multiply（）。并用@FunctionalInterface注解，此注释是可选的，它将接口标记为函数接口。如果向接口添加另一个抽象方法，代码会导致编译错误。

198.解释`java.util.Function` 包。

java.util.function是Java 8新增的包。它有很多内置的函数接口如下：

函数接口	描述
Predicate	用于测试条件。它返回一个布尔值，指示条件是`true`还是`false`。它接受任何数据类型的参数。
Consumer	用于对值进行操作。它接受任何数据类型的参数并对其进行操作。返回`void`。
Function	用于转换输入值。它接受任何数据类型的参数，将其转换为一种新类型并返回。
Supplier	用于产生一个任何数据类型的值。它不接受任何参数。

199. 解释`java.util.function.Consumer`接口。

java.util.function.Consumer是一个内置的函数接口。它是Java 8添加的java.util.function包的一部分。它有一个accept()方法，接受任何数据类型的参数并对其进行操作，也就是消费。因为是函数接口，因此可以通过lambda表达式实现。如下代码所示：

Consumer<String> printStr = val–> System.out.println(val); //Line 1
printStr.accept(“Hello World”); //Line 2

上述代码中，第1行创建一个名为printStr的字符串类型Consumer，并用一个lambda表达式实现其accept()方法，lambda表达式的主体逻辑是在控制台简单打印输入字符串。第2行调用接口的accept方法，传入参数是“Hello World”。因此，代码打印以下输出：