Java基础面试题（七）

1. 字节和字符的区别？

在Java中，字节（Byte）和字符（Character）是两种不同的数据类型，它们具有不同的特性和用途。以下是它们之间的主要区别：

1. 定义与用途：

   • 字节：字节是计算机中用于表示数据的最小单位，通常由一个8位的二进制数组成。在Java中，字节类型（byte）用于表示整数值，其范围从-128到127。字节常用于处理原始数据、文件I/O操作或网络通信等场景。
   • 字符：字符用于表示文本信息中的单个符号或字母。在Java中，字符类型（char）用于表示单个Unicode字符。字符是用户与程序交互时使用的基础单位，如文本输入、输出和字符串处理等。

2. 存储大小：

   • 字节类型的变量在内存中占用1个字节（8位）的空间。
   • 字符类型的变量在内存中占用2个字节（16位）的空间，因为Java中的字符类型使用UTF-16编码，可以表示大多数Unicode字符。

3. 表示范围：

   • 字节类型的表示范围是从-128到127（有符号）或从0到255（无符号）。
   • 字符类型的表示范围则涵盖了Unicode字符集中的所有字符，包括拉丁字母、中文字符、特殊符号等。

4. 编码方式：

   • 字节通常用于表示二进制数据，不直接涉及特定的字符编码。
   • 字符则与字符编码密切相关。在Java中，字符使用UTF-16编码，这是一种可变长度的Unicode编码方式。

5. 转换关系：

   • 在Java中，可以使用字符串类（String）的字节表示和字符表示之间进行转换。例如，可以使用String类的构造函数或getBytes()方法将字符串转换为字节数组，也可以使用String类的valueOf()方法将字符数组或字节数组转换为字符串。

6. 操作方式：

   • 对于字节类型的变量，通常进行位运算、算术运算或字节级别的数据处理。
   • 对于字符类型的变量，则进行字符串拼接、比较、查找等文本处理操作。

综上所述，字节和字符在Java中具有不同的定义、用途、存储大小、表示范围、编码方式、转换关系以及操作方式。

2. String 为什么要设计为不可变类？

Java中的String类被设计为不可变类，主要有以下几个原因：

1. 安全性：不可变性确保了字符串的值在创建后不会被修改。这种特性对于保护敏感信息，如账号、密码、网络路径、文件处理等场景至关重要。如果字符串是可变的，那么它们就容易被篡改，无法保证在使用字符串进行操作时的安全性。例如，防止SQL注入、防止访问危险文件等操作都得益于String的不可变性。
2. 线程安全：在多线程环境中，不可变的对象是线程安全的。因为不会有线程能够修改一个不可变对象的值，所以多个线程可以同时访问同一个String对象，而不会产生线程安全问题。这避免了同步操作的需要，提高了程序的效率。
3. 缓存有效性：由于String的hashcode属性在对象创建后不会变更，这保证了String的唯一性，使得诸如HashMap、HashSet等容器能够基于String的hashcode进行有效的缓存操作。如果String是可变的，那么其hashcode值也可能随之变化，这将破坏这些容器的正常工作。
4. 性能优化：字符串拼接操作在Java中非常常见。如果String是可变的，那么每次拼接都会修改原字符串，这可能导致大量的内存分配和复制操作，从而降低性能。而由于String是不可变的，Java提供了诸如StringBuilder和StringBuffer这样的可变字符序列类，用于高效的字符串拼接操作。

综上所述，Java将String设计为不可变类，主要是出于安全性、线程安全性、缓存有效性以及性能优化的考虑。

3. String、StringBuilder、StringBuffer 的区别？

1. 可变性与不可变性：

   • String：是不可变的，即一旦创建了一个String对象，就不能修改它的内容。对String对象的任何修改操作，如拼接、替换等，实际上都会创建新的String对象。这种设计有助于保证字符串的不可变性和线程安全性，但也意味着在某些需要频繁修改字符串的场景下，性能可能不是最优的。
   • StringBuilder 和StringBuffer：都是可变的字符串类，可以在原有的字符串基础上进行修改，而不需要创建新的对象。这使得它们在处理大量字符串拼接操作时具有更高的性能。

2. 线程安全性：

   • StringBuilder：是非线程安全的，这意味着在多线程环境下，如果有多个线程同时修改同一个StringBuilder对象，可能会导致数据不一致或其他线程安全问题。但由于其非线程安全的特性，它在单线程环境下的性能通常优于StringBuffer。
   • StringBuffer：是线程安全的，它通过内部同步机制（如使用synchronized关键字）来保证在多线程环境下对字符串的操作是安全的。这使得StringBuffer在多线程环境中更加可靠，但也可能带来一定的性能开销。

3. 性能：

   • 在字符串操作较少的场景下，String类的性能通常是可以接受的。但在需要频繁修改字符串的场景下，如大量拼接、替换等操作，StringBuilder和StringBuffer的性能通常优于String，因为它们可以在原地修改字符串，避免了频繁创建新对象带来的开销。
   • 在单线程环境下，StringBuilder通常比StringBuffer具有更高的性能，因为它没有线程安全的开销。但在多线程环境下，为了保证数据的安全性，可能需要选择StringBuffer。

总的来说，选择使用String、StringBuilder还是StringBuffer取决于具体的应用场景和需求。在不需要修改字符串或线程安全的场景下，可以使用String；在需要频繁修改字符串且单线程的环境下，可以选择StringBuilder；而在多线程环境下，为了保证线程安全，应该选择StringBuffer。

4. String 字符串修改实现的原理？

String类是不可变的（immutable），这意味着一旦一个String对象被创建，它的内容就不能被修改。这种设计决策有多个原因，包括安全性、线程安全性和性能优化。

由于String的不可变性，当你尝试"修改"一个字符串时，实际上并没有修改原始字符串对象的内容。相反，Java会创建一个新的String对象，其中包含修改后的内容。这种机制是通过字符串的拼接、替换、截取等操作实现的。

以下是几种常见的字符串修改操作及其实现的原理：

1. 拼接 ：
   当你使用+操作符或concat()方法拼接两个或多个字符串时，Java会创建一个新的String对象，该对象包含拼接后的结果。原始字符串对象保持不变。

String s1 = "Hello";
String s2 = "World";
String s3 = s1 + " " + s2; // 创建了一个新的String对象s3，内容为"Hello World"

2. 替换 ：
   使用replace()、replaceAll()或replaceFirst()方法替换字符串中的某些字符或子串时，同样会创建一个新的String对象，其中包含了替换后的内容。

String s = "apple";
String replaced = s.replace('a', 'o'); // 创建了一个新的String对象replaced，内容为"opple"

3. 截取 ：
   使用substring()方法截取字符串的一部分时，也会返回一个新的String对象，该对象包含原始字符串的一个子串。

String s = "abcdef";
String substring = s.substring(2, 4); // 创建了一个新的String对象substring，内容为"cd"

4. 使用StringBuilder或StringBuffer ：
   如果你需要频繁修改字符串（例如，在循环中拼接多个字符串），使用StringBuilder或StringBuffer类会更为高效。这些类是可变的，允许你在原地修改字符串内容，而不是每次都创建新的对象。最后，你可以使用toString()方法将StringBuilder或StringBuffer对象转换回String对象。

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString(); // 将StringBuilder对象转换为String对象

由于String的不可变性，Java运行时库能够缓存字符串字面量，并在需要时重用它们，从而提高了性能并减少了内存消耗。此外，不可变性还有助于在多线程环境中保持数据的一致性，避免了潜在的并发问题。然而，这也意味着在某些需要频繁修改字符串的场景下，使用可变字符串类（如StringBuilder和StringBuffer）可能会更为合适。

5. String str = "i" 与 String str = new String("i") 一样吗？

Java中的String str = "i"与String str = new String("i")在初始化字符串时并不完全相同。

对于String str = "i"，这是一种简单的字符串字面量的创建方式。Java会首先检查字符串常量池中是否已存在字符串"i"。如果存在，则不会创建新的对象，而是将变量str指向常量池中已存在的"i"字符串的地址。如果不存在，则会在常量池中创建一个新的字符串对象"i"，并将str指向它。这种方式相对更高效，因为它能够重用字符串常量池中的对象，减少内存占用。

而对于String str = new String("i")，每次执行都会通过构造函数在堆上创建一个新的String对象，即使字符串常量池中已经存在"i"这个字符串。新创建的对象会在堆上分配一个新的内存地址，并且str会指向这个新对象的地址。这意味着，尽管两个字符串的内容都是"i"，但它们在内存中的地址是不同的。这种方式相对更消耗内存，因为它总是在堆上创建新的对象，而不是重用已有的对象。

因此，虽然String str = "i"和String str = new String("i")在初始化时都表示字符串"i"，但它们的存储方式和内存使用是不同的。

6. String 类的常用方法都有那些？

String 类在 Java 中提供了许多常用的方法，用于操作字符串。以下是一些最常用的 String 类方法：

1. charAt(int index)

   • 返回指定索引处的 char 值。索引范围从 0 到 length() - 1。

2. length()

   • 返回字符串的长度。

3. concat(String str)

   • 将指定字符串连接到此字符串的结尾。

4. indexOf(int ch)

   • 返回指定字符在此字符串中第一次出现处的索引。

5. indexOf(String str)

   • 返回指定子字符串在此字符串中第一次出现处的索引。

6. lastIndexOf(int ch)

   • 返回指定字符在此字符串中最后一次出现处的索引。

7. lastIndexOf(String str)

   • 返回指定子字符串在此字符串中最后一次出现处的索引。

8. substring(int beginIndex)

   • 返回一个新的字符串，它是此字符串的一个子字符串。子字符串从指定的 beginIndex 开始，直到此字符串的末尾。

9. substring(int beginIndex, int endIndex)

   • 返回一个新字符串，它是此字符串的一个子字符串。子字符串从指定的 beginIndex 开始，直到索引 endIndex - 1 的字符。

10. replace(char oldChar, char newChar)

    • 返回一个新的字符串，其中的所有 oldChar 字符都被替换为 newChar。

11. replace(CharSequence target, CharSequence replacement)

    • 使用指定的字面值替换序列替换此字符串中所有匹配字面值目标序列的子字符串。

12. replaceFirst(String regex, String replacement)

    • 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

13. replaceAll(String regex, String replacement)

    • 使用给定的 replacement 替换此字符串中匹配给定正则表达式的所有子字符串。

14. split(String regex)

    • 根据给定正则表达式的匹配拆分此字符串。

15. toLowerCase()

    • 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

16. toUpperCase()

    • 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

17. trim()

    • 返回字符串的副本，忽略前导空白和尾部空白。

18. startsWith(String prefix)

    • 测试此字符串是否以指定的前缀开始。

19. endsWith(String suffix)

    • 测试此字符串是否以指定的后缀结束。

20. equals(Object anObject)

    • 比较此字符串与指定的对象。当且仅当该参数不是 null 而是表示与此对象相同的字符序列的 String 对象时，结果才为 true。

21. equalsIgnoreCase(String anotherString)

    • 比较此 String 与另一个 String，不考虑大小写。

22. compareTo(String anotherString)

    • 按字典顺序比较两个字符串。

23. compareToIgnoreCase(String str)

    • 按字典顺序比较两个字符串，不考虑大小写。

24. matches(String regex)

    • 告知此字符串是否匹配给定的正则表达式。

25. contains(CharSequence s)

    • 当且仅当此字符串包含指定的 char 值序列时，返回 true。

26. isEmpty()

    • 当且仅当长度为零时返回 true。

27. valueOf(各种类型)

    • 返回表示指定数据类型的 String。例如，String.valueOf(int i) 或 String.valueOf(Object obj)。

这只是 String 类提供的方法的一个简短列表。实际上，String 类还提供了许多其他方法，用于执行更复杂的字符串操作和转换。在使用时，建议查阅 Java 官方文档以获取完整的方法和详细描述。

7. final 修饰 StringBuffer 后还可以 append 吗？

final关键字用于修饰一个变量，表示这个变量的引用不能被重新赋值。换句话说，一旦一个变量被final修饰，那么这个变量只能指向初始化时指定的对象，不能再指向其他对象。

然而，final修饰的变量所指向的对象的内容是可以改变的。这意味着，即使一个StringBuffer对象被final修饰，你仍然可以调用它的append方法来改变其内容。final只是保证了这个StringBuffer的引用不会改变，而不是它的内容。

例如：

final StringBuffer sb = new StringBuffer("Hello");
sb.append(" World"); // 这是允许的，因为sb的引用没有改变，只是修改了其内容

例子中，sb是一个final变量，指向一个StringBuffer对象。尽管sb是final的，但我们仍然可以调用append方法来修改其内容。因此，输出将会是"Hello World"。

总结一下，final修饰的StringBuffer对象是可以调用append方法来改变其内容的。

8. Java 中的 IO 流的分类？说出几个你熟悉的实现类？

Java中的IO流主要可以分为以下几类：

1. 字节流（Byte Streams） ：字节流以字节为单位处理输入/输出，主要用于处理二进制数据。其中，InputStream和OutputStream是所有字节输入/输出流的抽象基类。常见的实现类包括：

   • FileInputStream：从文件系统中的某个文件中获取输入字节。
   • FileOutputStream：用于写入数据到文件。
   • BufferedInputStream 和 BufferedOutputStream：它们是对字节输入/输出流的缓冲增强，通过内部缓冲区来提高读写效率。

2. 字符流（Character Streams） ：字符流以字符为单位处理输入/输出，主要用于处理文本数据。Reader和Writer是所有字符输入/输出流的抽象基类。常见的实现类包括：

   • FileReader 和 FileWriter：分别用于从字符文件中读取和写入字符。
   • BufferedReader 和 BufferedWriter：它们是对字符输入/输出流的缓冲增强，同样通过内部缓冲区来提高读写效率。

3. 处理流（Processing Streams） ：处理流是"连接在已存在的流（节点流）之上"，通过对数据的处理为程序提供更为强大的读写功能。例如，ObjectInputStream 和 ObjectOutputStream 允许你以对象的形式读取和写入数据，而不是仅仅处理原始的字节或字符。

此外，根据功能的不同，IO流还可以分为节点流和处理流。节点流是直接从数据源或数据目的地读写数据，如FileInputStream和FileOutputStream；而处理流则是"连接在已存在的流（节点流）之上"，通过对数据的处理为程序提供更为强大的读写功能。

这些IO流类提供了丰富的方法用于读取和写入数据，例如read()、write()、close()等。在使用这些流时，通常需要先创建源（例如打开一个文件），然后选择合适的流进行读写操作，最后记得释放资源（关闭流）。

9. 字节流和字符流有什么区别？

Java中的字节流和字符流在多个方面存在显著的区别。

从组成上来看，字节流是由一系列连续的字节（8位二进制数）的集合组成，它代表了计算机中的原始数据。而字符流则是由字符组成，它在字节流的基础上加上了编码，使得字符的读写更为方便。

从处理方式来看，字节流主要用于处理二进制数据，如图像、视频、音频等，它按字节进行读写。而字符流则主要用于处理字符或字符串，它是按虚拟机的encode来处理，即需要进行字符集的转化，例如，可以直接读取中文而不会乱码。

此外，两者在操作时是否使用缓冲区也存在差异。字符流在操作时需要用到缓冲区，这有助于提高IO效率。而字节流在操作时不会用到缓冲区（内存）。

从使用场景来看，字符流一般用来读取纯文本文件，如TXT文件，因为它可以直接读取中文不会乱码。而字节流则可以读取任何格式的文件，包括图像、视频、音频、PPT、Word等。

综上所述，Java中的字节流和字符流在组成、处理方式、是否使用缓冲区以及使用场景等方面都存在显著的区别。

10. BIO、NIO、AIO 有什么区别？

BIO、NIO和AIO是Java网络编程中的三种I/O模型，它们各自具有不同的特点和应用场景。

BIO，即同步并阻塞的I/O模型，其服务实现模式为一个连接对应一个线程。当客户端发送一个连接请求时，服务端会分配一个线程来处理这个连接。如果连接数过多，而线程数量有限，那么未被处理的连接请求就只能等待，这可能导致阻塞。BIO模式在处理大量并发连接时可能会遇到性能瓶颈，因为每个连接都需要一个独立的线程来处理。

NIO，即New I/O，是Java平台提供的一组新的输入/输出API。它引入了channel、buffer、selector等新的概念和实现方式，相比传统的BIO模型更加高效和灵活。NIO采用IO多路复用技术，一个线程可以同时处理多个连接，有效避免了BIO模型中单线程无法处理大量请求的问题。此外，NIO是面向缓冲区的I/O操作，数据需要先读取到缓冲区中再进行处理，这提高了I/O效率。NIO使用的是事件驱动模式，通过选择器可以实现非阻塞I/O操作。

AIO，即异步非阻塞I/O模型，是Java 7中引入的一种新的I/O处理方式。它使用异步通道（AsynchronousChannel）来实现真正的异步非阻塞的I/O操作。在AIO中，当进行读写操作时，只需要直接调用API的read或write方法即可。这些方法会立即返回，而不会阻塞调用线程。当数据准备好时，或者读写操作完成时，操作系统会通过某种方式通知应用程序。这种方式可以充分利用系统资源，提高并发性能。

BIO、NIO和AIO的主要区别在于它们的处理方式、效率和并发性能。BIO是同步阻塞的，每个连接需要一个线程来处理，可能导致性能瓶颈；NIO是同步非阻塞的，一个线程可以处理多个连接，提高了效率；而AIO则是异步非阻塞的，通过异步通道和回调机制，进一步提高了并发性能。