Java——10个关于Java数据类型的面试题-阿里云开发者社区

文章目录：

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

方法	解释说明
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 型。

而 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——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.数据类型之间如何进行转换？

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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.数据类型之间如何进行转换？

热门文章

最新文章

相关课程

相关电子书

相关实验场景