Java——10个关于Java数据类型的面试题

文章目录：

1.Java的基本数据类型（及包装类型）都有哪些各占几个字节？

2.String是基本数据类型吗？

3.String类可以被继承吗？

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

5.String 类常用方法

6.String、StringBuffer、StringBuilder的区别？

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

8.int和Integer有什么区别？

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

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

1.Java的基本数据类型（及包装类型）都有哪些各占几个字节？

·       基本数据类型：byte、 short、    int、     long、float、 double、boolean、    char

·       对应包装类型：Byte、Short、Integer、Long、Float、Double、Boolean、Character

·       各自所占字节数：1        2             4            8         4           8              1                2

2.String是基本数据类型吗？

虽然我目前使用的是jdk14，但以主流的jdk1.8来说，Spring类内部实际存储的结构为char数组，源码如下：（所以说String不是Java中的基本数据类型）

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的呢？

因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。因为不可变对象不能更改，它们可以在多个线程之间自由共享。

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

·       从内存角度来看：字符串常量池的要求：创建字符串时，如果该字符串已经存在于池中，则将返回现有字符串的引用，而不是创建新对象。多个String变量引用指向同一个内地地址。如果字符串是可变的，用一个引用更改字符串将导致其他引用的值错误。这是很危险的。

·       缓存Hashcode：字符串的Hashcode在java中经常配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable。不可变的特性保证了hashcode永远是相同的。不用每次使用hashcode就需要计算hashcode。这样更有效率。因为当向集合中插入对象时，是通过hashcode判别在集合中是否已经存在该对象了（不是通过equals方法逐个比较，效率低）。

·       方便其它类使用：其他类的设计基于string不可变，如set存储string，改变该string后set包含了重复值。

·       安全性：String被广泛用作许多java类的参数，例如网络连接、打开文件等。如果对string的某一处改变一不小心就影响了该变量所有引用的表现，则连接或文件将被更改，这可能导致严重的安全威胁。

总结：由于效率和安全性的原因，字符串被设计为不可变。

● 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 类常用方法

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 型。

而 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);
    }
}