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

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
    //...其他内容省略
}

3.String类可以被继承吗？

答案：不能！！！ String类在声明时使用final关键字修饰，被final关键字修饰的类无法被继承。

● 为什么Java语言的开发者，把String类定义为final的呢？

因为只有当字符串是不可变的，字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间，因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的，那么String interning将不能实现，因为这样的话，如果变量改变了它的值，那么其它指向这个值的变量的值也会一起改变。如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。

因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。

因为字符串是不可变的，所以在它创建的时候HashCode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

（上面这一段话好像喷的有点高大上。。。说白了就是：为了安全和高效的考虑，如果不是final的话，传参和内部指令调用时，它的值被改变了的话可能会引起不可预知的系统崩溃问题，且传参的时候需要重新拷贝一个新值，性能上会有一定损失！）

● final关键字除了修饰类之外，还有哪些用法呢？

final修饰的变量，一旦赋值，不可重新赋值；

final修饰的方法无法被覆盖；

final修饰的实例变量，必须手动赋值，不能采用系统默认值；

final修饰的实例变量，一般和static联用，用来声明常量；

注意：final不能和abstract关键字联合使用。

总之，final表示最终的、不可变的。

4.String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容变了没有？

答案：没有！！！

因为 String被设计成不可变类，所以它的所有对象都是不可变对象。（说白了，就是 final 关键字在起作用）

在这段代码中，s原先指向一个 String 对象，内容是 "Hello"，然后我们对 s 进行了“+”操作，那么 s 所指向的那个对象是否发生了改变呢？

答案是没有。这时s不指向原来那个对象了，而指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是 s 这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用 String 来代表字符串的话会引起很大的内存开销。因为 String 对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个 String 对象来表示。这时，应该考虑使用 StringBuffer/StringBuilder类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都 new 一个 String。

5.String 类常用方法

方法	解释说明
char charAt(int index)	返回指定索引处的 char 值。
boolean contains(CharSequence s)	当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean endsWith(String suffix)	测试此字符串是否以指定的后缀结束。
boolean equals(Object anObject)	将此字符串与指定的对象比较。
boolean equalsIgnoreCase(String anotherString)	将此 String 与另一个 String 比较，不考虑大小写。
byte[] getBytes()	使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
int indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引。
int lastIndexOf(String str)	返回指定子字符串在此字符串中最右边出现处的索引。
int length()	返回此字符串的长度。
String replaceAll(String regex, String replacement)	使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String[] split(String regex)	根据给定正则表达式的匹配拆分此字符串。
boolean startsWith(String prefix)	测试此字符串是否以指定的前缀开始。
String substring(int beginIndex)	返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex)	返回一个新字符串，它是此字符串的一个子字符串。
char[] toCharArray()	将此字符串转换为一个新的字符数组。
String toLowerCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String toUpperCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String trim()	返回字符串的副本，忽略前导空白和尾部空白。

6.String、StringBuffer、StringBuilder的区别？

● 可变不可变

String：字符串常量，在修改时不会改变自身；若修改，等于重新生成新的字符串对象。

StringBuffer：在修改时会改变对象自身，每次操作都是对 StringBuffer 对象本身进行修改，不是生成新的对象；使用场景：对字符串经常改变情况下，主要方法：append()，insert()等。

● 线程是否安全

String：对象定义后不可变，线程安全。

StringBuffer：是线程安全的（对调用方法加入同步锁），执行效率较慢，适用于多线程下操作字符串缓冲区大量数据。

StringBuilder：是线程不安全的，适用于单线程下操作字符串缓冲区大量数据。

● 共同点

StringBuilder与StringBuffer有公共父类 AbstractStringBuilder(抽象类)。

StringBuilder、StringBuffer 的方法都会调用 AbstractStringBuilder 中的公共方法，如 super.append(...)。只是 StringBuffer 会在方法上加 synchronized 关键字，进行同步。最后，如果程序不是多线程的，那么使用StringBuilder 效率高于 StringBuffer。

可以在源码中看到StringBuilder与StringBuffer：

7.short s1 = 1; s1 = s1 + 1; 有错吗?short s1 = 1; s1 += 1 有错吗？

答案：前者错！后者对！

对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。（int → short 向下转型）

而 short s1 = 1; s1 += 1;可以正确编译，因为 s1+= 1; 相当于 s1 = (short)(s1 + 1); 其中有隐含的强制类型转换。

short s1=1;
s1= (short) (s1+1);
        
short s2=1;
s2+=1;

8.int和Integer有什么区别？

java 是一个完全面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java 为每一个基本数据类型都引入了对应的包装类型（wrapper class），int 的包装类就是Integer，从 Java 5 开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

java 为每个原始类型提供了包装类型：（再说一遍！！！）

● 基本数据类型: boolean，char，byte，short，int，long，float，double

● 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

package com.szh.java01;

/**
 * byte short int long float double char boolean
 */
public class Test01 {

    public static void main(String[] args) {
        /**
         * 900是基本数据类型int
         * x是Integer包装类型
         * 基本数据类型  --->  包装类型（自动转换，自动装箱机制）
         */
        Integer x=500;
        System.out.println(x);

        /**
         * x是Integer包装类型
         * y是基本数据类型int
         * 包装类型  --->  基本数据类型（自动转换，自动拆箱机制）
         */
        int y=x;
        System.out.println(y);

        /**
         * 这里程序正常执行不报错，是因为自动拆箱机制
         * + 号两边要求是基本数据类型，z是包装类，所以这里为进行自动拆箱机制进行自动转换
         */
        Integer z=1000;
        System.out.println(z+1);
    }

}

9.下面 Integer 类型的数值比较输出的结果为？

public class Test{
    public static void main(String[] args) {
        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
        System.out.println(f1 == f2);
        System.out.println(f3 == f4);
    }
}

答案：第一行输出 true，第二行输出 false。

首先需要注意的是 f1、f2、f3、f4 四个变量都是 Integer 对象引用，所以下面的==运算比较的不是值而是引用。这里就要提到自动装箱机制了，那么自动装箱的本质是什么呢？当我们给一个Integer 对象赋一个 int 值的时候，会调用 Integer 类的静态方法 valueOf，如果看看valueOf的源代码就知道发生了什么。

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

IntegerCache 是 Integer 的内部类，其代码如下所示：

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer[] cache;
        static Integer[] archivedCache;

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    h = Math.max(parseInt(integerCacheHighPropValue), 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            // Load IntegerCache.archivedCache from archive, if possible
            VM.initializeFromArchive(IntegerCache.class);
            int size = (high - low) + 1;

            // Use the archived cache if it exists and is large enough
            if (archivedCache == null || size > archivedCache.length) {
                Integer[] c = new Integer[size];
                int j = low;
                for(int i = 0; i < c.length; i++) {
                    c[i] = new Integer(j++);
                }
                archivedCache = c;
            }
            cache = archivedCache;
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

这一大堆源码简单地说就是：如果整型字面量的值在-128 到 127 之间，那么不会 new 新的 Integer 对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是 true，而f3==f4 的结果是false。

10.数据类型之间如何进行转换？

● 字符串如何转基本数据类型？

调用基本数据类型对应的包装类中的方法 parseXXX(String)或valueOf(String)即可返回相应基本类型。

● 基本数据类型如何转字符串？

一种方法是将基本数据类型与空字符串（""）连接（+）即可获得其所对应的字符串；另一种方法是调用 String类中的 valueOf()方法返回相应字符串。

public class IntegerAndString {

    public static void main(String[] args) {
        // String ---> int
        String s1="100";
        int i1=Integer.parseInt(s1);
        System.out.println("String ---> int " + i1);

        // int ---> String
        String s2=i1 + "";
        System.out.println("int ---> String " + s2 + 1);

        // int ---> Integer (自动装箱)
        Integer x=1000;
        System.out.println("x = " + x);

        // Integer ---> int (自动拆箱)
        int y=x;
        System.out.println("y = " + y);

        // String ---> Integer
        Integer k=Integer.valueOf("123");
        System.out.println("String ---> Integer " + k);

        // Integer ---> String
        String str=String.valueOf(k);
        System.out.println("Integer ---> String " + str);
    }
}

以上是关于Java——关于Java数据类型的面试题的主要内容，如果未能解决你的问题，请参考以下文章

通俗易懂---关于java基础语法面试题

Java数据类型扩展及面试题讲解

Java面试 | 关于Redis 的面试题

Java数据类型Java面试题

JAVA基础面试题