Java 基础面试题——常见类

╰+攻爆jí腚メ 2023-10-08 00:25 67阅读 0赞

#### 目录 ####

*  1.String
 *   *  1.1.String 为什么是不可变的？
     *  1.2.如果想要改变一个 String 的值，但又不想把它重新指向其他对象的话，应该怎么办呢？
     *  1.3.字符串拼接用 “+” 和 StringBuilder 有什么区别?
     *  1.4.String、StringBuffer 和 StringBuilder 的区别是什么?
     *  1.5.✨String s1 = new String("hello"); 这段代码创建了几个字符串对象？
     *  1.6.✨执行下面的这三行代码时，JVM 分别做了什么事情？
     *  1.7.一段有关字符串拼接的代码如下，请问其运行结果是什么？
     *  1.8.两个未赋值的字符串 s1 和 s2 （用 static 修饰）的拼接结果是什么？
     *  1.9.String 中的 equals() 和 Object 中的 equals() 有何区别？
     *  1.10.String 中类常用的方法有哪些？
 *  2.Object 类有哪些常用的方法？
 *  3.如何获取当前系统的剩余内存、总内存及最大堆内存？
 *  4.LocalDateTime & Calendar
 *   *  4.1.如何取当前的年、月、日、时、分、秒、毫秒？
     *  4.2.如何获取从 1970 年 1 月 1 日 0 时 0 分 0 秒到现在的毫秒数？
     *  4.3.如何获取某年某月的最后一天？
     *  4.4.如何打印昨天的当前时刻？
     *  4.5.如何格式化日期？

## 1.String ##

### 1.1.String 为什么是不可变的？ ###

（1）String 类中**使用 final 关键字修饰的字符数组**来保存字符串，如下面的代码所示：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
        
    
        /** The value is used for character storage. */
        private final char value[];
    	
    	...
    }

（2）我们知道被 final 关键字修饰的类**不能被继承**，**修饰的方法不能被重写**，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。因此，final 关键字修饰的数组保存字符串并不是 String 不可变的根本原因，因为这个数组保存的字符串是可变的（final 修饰引用类型变量的情况）。

（3）String 真正不可变的原因如下：

*  保存字符串的数组**被 final 修饰且为私有的**，并且String 类**没有提供/暴露修改这个字符串的方法**。
 *  String 类被 final 修饰导致其不能被继承，进而避免了子类破坏 String 的不可变性。

### 1.2.如果想要改变一个 String 的值，但又不想把它重新指向其他对象的话，应该怎么办呢？ ###

该问题的本质就是如何破坏 String 的不可变性，我们可以**利用反射修改 char 数组的值**，即在运行时动态地修改一个 String 对象的值。这可以通过 `String.class.getDeclaredField` 方法来获取 String 类中的 `char[]` 字段，然后修改 `char[]` 数组中的值，从而改变 String 对象的值。具体代码如下所示：

import java.lang.reflect.Field;
    
    public class Main {
        
        public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        
            String str = "Hello World";
            System.out.println("Before reflection, str = " + str + ", str's hashCode is: " + str.hashCode());
    
            Field field = String.class.getDeclaredField("value");
            //关闭 JDK 的安全检查来提升反射速度
            field.setAccessible(true);
            char[] value = (char[]) field.get(str);
            value[6] = '_';
    
            System.out.println("After reflection, str = " + str + ", str's hashCode is: " + str.hashCode());
        }
    }

输出结果如下所示：

Before reflection, str = Hello World, str's hashCode is: -862545276
    After reflection, str = Hello _orld, str's hashCode is: -862545276

> 有关反射的知识点可以参考 [Java 基础——反射][Java]这篇文章。

### 1.3.字符串拼接用 “+” 和 StringBuilder 有什么区别? ###

（1）Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的运算符。

public static void main(String[] args) {
        
        String str1 = "he";
        String str2 = "llo";
        String str3 = "world";
        String str4 = str1 + str2 + str3;
    }

上述代码对应的字节码如下：

![在这里插入图片描述][829147752a9e4b13a33ec9efe3be8ecd.png]

可以看出，字符串对象通过 “+” 的字符串拼接方式，实际上是由 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象。不过在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：**编译器不会创建单个 StringBuilder 以复用，会导致创建过多的 StringBuilder 对象，从而比较占用内存空间，并且效率较低**。

public static void main(String[] args) {
        
        String[] arr = {
        "he", "llo", "world"};
        String s = "";
        for (int i = 0; i < arr.length; i++) {
        
            s += arr[i];
        }
        System.out.println(s);
    }

上述代码对应的字节码如下所示：

![在这里插入图片描述][db24d3f1f6d8451ab19106eed72ee75b.png]

（2）如果直接使用 StringBuilder 对象进行字符串拼接的话，就不会存在这个问题了。

public static void main(String[] args) {
        
        String[] arr = {
        "he", "llo", "world"};
        StringBuilder s = new StringBuilder();
        for (String value : arr) {
        
            s.append(value);
        }
        System.out.println(s);
    }

上述代码对应的字节码如下所示：

![在这里插入图片描述][43c83392911844f9b373fee3e9e5c8c7.png]

如果在 IDEA 中使用 “+” 来拼接字符串的话，会出现建议使用 StringBuilder 的提示，如下图所示：

![在这里插入图片描述][2998ff5c2418453abcf23c28acbc0431.png]

> 查看字节码的方式之一：  
> 在控制台使用命令 javap -v xxx.class 即可，不过在此之前需要先将 xxx.java 进行编译得到 xxx.class 文件才行。

### 1.4.String、StringBuffer 和 StringBuilder 的区别是什么? ###

**（1）底层数据结构**

*  String 是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个被 private final 类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对 String 的操作都会生成新的 String 对象。例如每次拼接操作（即两个字符串相加）： 隐式地在堆上 new 了一个跟原字符串相同的 StringBuilder 对象，再调用 append() 拼接后面的字符。

private final char value[];

*  StringBuffer 和 StringBuilder 都继承了 **AbstractStringBuilder** 抽象类，在 AbstractStringBuilder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰（如下面的代码所示），最关键的是这个 AbstractStringBuilder 类还提供了很多修改字符串的方法，例如 append 方法。所以**在进行频繁的字符串操作时**，建议使用 StringBuffer 和 StringBuilder 来进行操作。

/**
    * The value is used for character storage.
    */
    char[] value;

**（2）线程安全性**

*  String 中的对象是不可变的，也就可以理解为常量，所以是**线程安全**的、
 *  StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是**线程安全**的。
 *  StringBuilder 并没有对方法进行加同步锁，所以是**非线程安全**的。

**（3）性能**

*  每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。
 *  StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。
 *  相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
 *  性能：StringBuilder > StringBuffer > String

**（4）使用场景**

*  操作少量的数据：建议使用 String；
 *  单线程操作字符串缓冲区下操作大量数据: 建议使用 StringBuilder；
 *  多线程操作字符串缓冲区下操作大量数据: 建议使用 StringBuffer;

### 1.5.✨String s1 = new String(“hello”); 这段代码创建了几个字符串对象？ ###

应该分情况讨论：

*  当字符串常量池中没有字符串 “hello” 时，则会先在常量池中创建一个 String 类型的 “hello”，然后将常量池中的 “hello” 复制一份到堆中，并且将堆中的引用指向 s1，因此总共创建了 2 个字符串对象；
 *  当字符串常量池中有字符串 “hello” 时，则将常量池中的 “hello” 复制一份到堆中，并且将堆中的引用指向 s1，因此总共创建了 1 个字符串对象；

### 1.6.✨执行下面的这三行代码时，JVM 分别做了什么事情？ ###

String a = "123";
    String b = new("456");
    String c = a + b;

（1）在执行上面三行代码时，JVM 会做以下操作：

*  `String a = "123";`：JVM 会在字符串常量池中创建一个字符串 “123”，并将其赋值给变量 `a`。如果字符串常量池中已经存在相同内容的字符串，则直接返回引用。需要注意的是，字符串常量池是存储字符串字面值的特殊内存区域，它位于堆内存之外。
 *  `String b = new String("456");`：
    
     *  JVM 会在堆内存中创建一个新的字符串对象，内容为 “456”。
     *  `new String("456")` 创建的是一个新的字符串对象，而不是从字符串常量池中获取引用。
     *  将堆内存中的新字符串对象的引用赋值给变量 `b`。
 *  `String c = a + b;`：
    
     *  在进行字符串拼接 `a + b` 的过程中，JVM 会创建一个新的字符串对象。
     *  JVM 会先检查拼接操作涉及的字符串是否存在于字符串常量池中，如果存在则直接使用，如果不存在则会在字符串常量池中创建新的字符串并返回引用。
     *  注意：由于字符串是不可变的，每次进行字符串拼接操作时，都会创建一个新的字符串对象。

（2）需要注意的是，上述代码中的字符串常量和字符串对象在内存中的存储方式是不同的，字符串常量池中的字符串是共享的，而堆内存中的字符串对象是独立的。

### 1.7.一段有关字符串拼接的代码如下，请问其运行结果是什么？ ###

class Solution {
        
        public static void main(String[] args) {
        
            String s1 = "hello ";
            String s2 = "world";
            String s3 = "hello world";
            String s4 = "hello " + "world";
            System.out.println(s3 == s4);           
            String s5 = s1 + s2;
            System.out.println(s3 == s1 + s2);      
            System.out.println(s3.equals(s1 + s2)); 
            System.out.println(s5 == s4);           
        }
    }

输出结果为：

true
    false
    true
    false

有关字符串拼接的知识可总结如下：

*  字符串如果是变量相加（例如 `String s5 = s1 + s2;`），那么先开辟空间，然后再拼接。
 *  字符串如果是常量相加（例如 `String s4 = "hello " + "world";`），是先将字符串相加，然后去常量池中找，如果找到了，则直接返回（s4 指向常量池中的 “hello, word”）；如果找不到则创建。

### 1.8.两个未赋值的字符串 s1 和 s2 （用 static 修饰）的拼接结果是什么？ ###

class Test1 {
        
        private static String s1;
        private static String s2;
    
        public static void main(String[] args) {
        
            String s = s1 + s2;
            System.out.println(s);
        }
    }

上述代码的输出结果为

nullnull

首先，通过已有知识可知：

*  字符串对象通过 “+” 的字符串拼接方式，实际上是由 `StringBuilder` 调用 `append()` 方法实现的；
 *  字符串对象的初始默认值为 `null`（注意此处的 null 并非上面打印的字符串 “null”）；

所以，我们只需要查看 append 方法的源码即可知道为什么打印结果为 “nullnull”。

public final class StringBuilder
        extends AbstractStringBuilder
        implements java.io.Serializable, CharSequence
    {
        
    	//...
    	@Override
    	public StringBuilder append(String str) {
        
    	    super.append(str);
    	    return this;
    	}
    }

`StringBuilder` 继承自 `AbstractStringBuilder`。通过下面的代码可知，如果 append 方法的参数字符串为 `null`，那么会调用其父类`AbstractStringBuilder` 的 `appendNull` 方法。`appendNull` 方法对 `null` 的字符串进行了特殊处理，即在拼接的过程中如果遇到了 `null` 的字符串，那么就会将其以字符串 “null” 的形式进行拼接，所以我们就可以理解上述代码的输出结果为连个连续 “null” 拼接得到。

abstract class AbstractStringBuilder implements Appendable, CharSequence {
        
    	//...
    	
    	public AbstractStringBuilder append(String str) {
        
    	    if (str == null)
    	        return appendNull();
    	    int len = str.length();
    	    ensureCapacityInternal(count + len);
    	    str.getChars(0, len, value, count);
    	    count += len;
    	    return this;
    	}
    	
    	private AbstractStringBuilder appendNull() {
        
            int c = count;
            ensureCapacityInternal(c + 4);
            // value 是底层用来存储字符的 char 类型数组
            final char[] value = this.value;
            value[c++] = 'n';
            value[c++] = 'u';
            value[c++] = 'l';
            value[c++] = 'l';
            count = c;
            return this;
        }
    }

### 1.9.String 中的 equals() 和 Object 中的 equals() 有何区别？ ###

String 中的 equals 方法是被**重写**过的，比较的是 String 字符串的值是否相等。Object 的 equals 方法是比较的对象的内存地址。

public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
        
    
    	//...
    	
    	// equals 被重写
    	public boolean equals(Object anObject) {
        
            if (this == anObject) {
        
                return true;
            }
            if (anObject instanceof String) {
        
                String anotherString = (String)anObject;
                int n = value.length;
                if (n == anotherString.value.length) {
        
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
        
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }
                    return true;
                }
            }
            return false;
        }
    
    	public int hashCode() {
        
            int h = hash;
            if (h == 0 && value.length > 0) {
        
                char val[] = value;
    
                for (int i = 0; i < value.length; i++) {
        
                    h = 31 * h + val[i];
                }
                hash = h;
            }
            return h;
        }
    }

### 1.10.String 中类常用的方法有哪些？ ###

String 类常用的方法如下：

*  **charAt(int index)**：返回字符串中指定索引处的字符。
 *  **length()**：返回字符串的长度。
 *  **substring(int beginIndex)**：返回从指定索引开始到字符串末尾的子字符串。
 *  **substring(int beginIndex, int endIndex)**：返回从指定索引开始到指定索引结束的子字符串。
 *  **toLowerCase()**：将字符串中的所有字符转换为小写。
 *  **toUpperCase()**：将字符串中的所有字符转换为大写。
 *  **trim()**：返回去除了字符串两端空格的字符串。
 *  **equals(Object anObject)**：比较字符串是否相等。
 *  **startsWith(String prefix)**：测试字符串是否以指定的前缀开始。
 *  **endsWith(String suffix)**：测试字符串是否以指定的后缀结束。

## 2.Object 类有哪些常用的方法？ ##

（1）Object 是所有类的根，是所有类的父类，所有对象包括数组都实现了 Object 的方法。Object 类结构如下图所示：

![在这里插入图片描述][f06c32ab4bae4be2be90e3dd4979f69c.png]

（2）主要方法介绍如下：

*  `clone()`：保护方法，实现对象的浅复制，只有实现了 Cloneable 接口才可以调用该方法，否则抛出 CloneNotSupportedException 异常，深拷贝也需要实现 Cloneable，同时其成员变量为引用类型的也需要实现 Cloneable，然后重写 clone()。
 *  `finalize()`：该方法和**垃圾收集器**有关系，判断一个对象是否可以被回收的最后一步就是判断是否重写了此方法。
 *  `equals()`：该方法使用频率非常高，但是在 Object 中两者是一样的。子类一般都要重写这个方法。
 *  `hashCode()`：该方法用于哈希查找，重写了 equals() 一般都要重写 hashCode()，这个方法在一些具有哈希功能的 Collection 中用到。
 *  `notify()`：配合 synchronized 使用，该方法唤醒在该对象上等待队列中的某个线程（同步队列中的线程是给抢占 CPU 的线程，等待队列中的线程指的是等待唤醒的线程）。
 *  `notifyAll()`：配合 synchronized 使用，该方法唤醒在该对象上等待队列中的所有线程。
 *  `wait()`：配合 synchronized 使用，wait() 就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait() 一直等待，直到获得锁或者被中断。wait(long timeout) 设定一个超时间隔，如果在规定时间内没有获得锁就返回。  
    调用该方法后当前线程进入睡眠状态，直到以下事件发生：
    
     *  其他线程调用了该对象的 notify 方法；
     *  其他线程调用了该对象的 notifyAll 方法；
     *  其他线程调用了 interrupt 中断该线程；
     *  时间间隔到了。此时该线程就可以被调度了，如果是被中断的话就抛出一个 InterruptedException 异常。

## 3.如何获取当前系统的剩余内存、总内存及最大堆内存？ ##

（1）可以通过 `java.lang.Runtime` 类中与内存相关方法来获取剩余的内存、总内存及最大堆内存。通过下面方法可以获取到堆使用的百分比及堆内存的剩余空间。

freeMemory() 方法返回剩余空间的字节数
    totalMemory() 方法总内存的字节数
    maxMemory() 返回最大内存的字节数

（2）示例如下：

class Solution {
        
        public static void main(String[] args) {
        
            System.out.println("JVM 从操纵系统那里挖到的最大的内存 maxMemory : " + Runtime.getRuntime().maxMemory() / 1024 / 1024 + "M");
            System.out.println("JVM 已经从操作系统那里挖过来的内存 totalMemory : " + Runtime.getRuntime().totalMemory() / 1024 / 1024 + "M");
            System.out.println("JVM 从操纵系统挖过来还没用上的内存 freeMemory : " + Runtime.getRuntime().freeMemory() / 1024 / 1024 + "M");
            
            System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            
            byte[] b1 = new byte[3 * 1024 * 1024];
            System.out.println("JVM 从操纵系统那里挖到的最大的内存 maxMemory " + Runtime.getRuntime().maxMemory() / 1024 / 1024 + "M");
            System.out.println("JVM 已经从操作系统那里挖过来的内存 totalMemory : " + Runtime.getRuntime().totalMemory() / 1024 / 1024 + "M");
            System.out.println("JVM 从操纵系统挖过来还没用上的内存 freeMemory : " + Runtime.getRuntime().freeMemory() / 1024 / 1024 + "M");
        }
    }

输出结果如下：

JVM 从操纵系统那里挖到的最大的内存   maxMemory : 3154M
    JVM 已经从操作系统那里挖过来的内存   totalMemory : 213M
    JVM 从操纵系统挖过来还没用上的内存   freeMemory : 208M
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    JVM 从操纵系统那里挖到的最大的内存   maxMemory 3154M
    JVM 已经从操作系统那里挖过来的内存   totalMemory : 213M
    JVM 从操纵系统挖过来还没用上的内存   freeMemory : 205M

## 4.LocalDateTime & Calendar ##

### 4.1.如何取当前的年、月、日、时、分、秒、毫秒？ ###

创建 java.util.Calendar 实例，调用其 get() 传入不同的参数即可获得参数所对应的值。

import java.util.Calendar;
    
    public class TestDateAndTime {
        
        public static void main(String[] args) {
        
            //获取当前的年、月、日、时、分、秒、毫秒
            Calendar calendar = Calendar.getInstance();
            //年
            System.out.println(calendar.get(Calendar.YEAR));
            //月，需要注意的是 Calendar.MONTH 是从 0 开始的
            System.out.println(calendar.get(Calendar.MONTH) + 1);
            //天
            System.out.println(calendar.get(Calendar.DATE));
            //时
            System.out.println(calendar.get(Calendar.HOUR));
            //分
            System.out.println(calendar.get(Calendar.MINUTE));
            //秒
            System.out.println(calendar.get(Calendar.SECOND));
            //毫秒
            System.out.println(calendar.get(Calendar.MILLISECOND));
        }
    }

### 4.2.如何获取从 1970 年 1 月 1 日 0 时 0 分 0 秒到现在的毫秒数？ ###

import java.util.Calendar;
    
    public class TestDateAndTime {
        
        public static void main(String[] args) {
        
            Calendar calendar = Calendar.getInstance();
        	//以下 2 种方法均可以获取从 1970 年 1 月 1 日 0 时 0 分 0 秒到现在的毫秒数
            System.out.println(System.currentTimeMillis());
            System.out.println(Calendar.getInstance().getTimeInMillis());
        }
    }

### 4.3.如何获取某年某月的最后一天？ ###

import java.time.LocalDate;
    import java.util.Calendar;
    
    public class TestDateAndTime {
        
        public static void main(String[] args) {
        
            Calendar calendar = Calendar.getInstance();
            
            //某月最后一天
            //2018-05月最后一天，6月1号往前一天
            calendar.set(Calendar.YEAR, 2018);
            calendar.set(Calendar.MONTH, 5);
            calendar.set(Calendar.DAY_OF_MONTH, 1);
            calendar.add(Calendar.DAY_OF_MONTH, -1);
            System.out.println(calendar.get(Calendar.YEAR) + "-" + (calendar.get(Calendar.MONTH) + 1) + "-" + calendar.get(Calendar.DAY_OF_MONTH));
            
            //JDK 1.8 java.time 包
            LocalDate date = LocalDate.of(2019, 6, 1).minusDays(1);
            System.out.println(date.getYear() + "-" + date.getMonthValue() + "-" + date.getDayOfMonth());
        }
    }

### 4.4.如何打印昨天的当前时刻？ ###

import java.time.LocalDateTime;
    
    public class YesterdayCurrent {
        
        public static void main(String[] args) {
        
            LocalDateTime today = LocalDateTime.now();
            LocalDateTime yesterday = today.minusDays(1);
            System.out.println(yesterday);
        }
    }

或者使用以下方式：

import java.util.Calendar;
    
    public class YesterdayCurrent {
        
        public static void main(String[] args) {
        
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.DATE, -1);
            System.out.println(cal.getTime());
        }
    }

### 4.5.如何格式化日期？ ###

import java.text.SimpleDateFormat;
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;
    
    public class TestDateAndTime {
        
        public static void main(String[] args) {
        
            Date date = new Date();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //格式化日期
            System.out.println(simpleDateFormat.format(date));
            
            //JDK 1.8 java.time 包
            System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        }
    }

[Java]: https://blog.csdn.net/weixin_43004044/article/details/119856638
[829147752a9e4b13a33ec9efe3be8ecd.png]: https://img-blog.csdnimg.cn/829147752a9e4b13a33ec9efe3be8ecd.png
[db24d3f1f6d8451ab19106eed72ee75b.png]: https://img-blog.csdnimg.cn/db24d3f1f6d8451ab19106eed72ee75b.png
[43c83392911844f9b373fee3e9e5c8c7.png]: https://img-blog.csdnimg.cn/43c83392911844f9b373fee3e9e5c8c7.png
[2998ff5c2418453abcf23c28acbc0431.png]: https://img-blog.csdnimg.cn/2998ff5c2418453abcf23c28acbc0431.png
[f06c32ab4bae4be2be90e3dd4979f69c.png]: https://img-blog.csdnimg.cn/f06c32ab4bae4be2be90e3dd4979f69c.png