Java面试系列总结 ：JavaSE基础（4） 数据类型/IO/内部类

**1. Java的基本数据类型都有哪些各占几个字节 **

如下表所示：

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

String是引用类型，底层用char数组实现的。

3. 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);其中有隐含的强制类型转换。

4. 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
  

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

如果不明就里很容易认为两个输出要么都是 true 要么都是 false。首先需要注意的是 f1、f2、f3、f4 四个变量都是 Integer 对象引用，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer 对象赋一个 int 值的时候，会调用 Integer 类的静态方法 valueOf，如果看看 valueOf 的源代码就知道发生了什么。

源码：

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

    /**
    * Cache to support the object identity semantics of autoboxing for values between
    * -128 and 127 (inclusive) as required by JLS.
    *
    * The cache is initialized on first usage.  The size of the cache
    * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
    * During VM initialization, java.lang.Integer.IntegerCache.high property
    * may be set and saved in the private system properties in the
    * sun.misc.VM class.
    */

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

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

           cache = new Integer[(high - low) + 1];
           int j = low;
           for(int k = 0; k < cache.length; k++)
               cache[k] = new Integer(j++);

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

提醒	越是貌似简单的面试题其中的玄机就越多，需要面试者有相当深厚的功力。

6. String类常用方法

7. String、StringBuffer、StringBuilder的区别？

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

（2）线程是否安全
String：对象定义后不可变，线程安全。
StringBuffer：是线程安全的（对调用方法加入同步锁），执行效率较慢，适用于多线程下操作字符串缓冲区大量数据。
StringBuilder：是线程不安全的，适用于单线程下操作字符串缓冲区大量数据。

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

8. 数据类型之间的转换

（1）字符串如何转基本数据类型？
调用基本数据类型对应的包装类中的方法parseXXX(String)或valueOf(String)即可返回相应基本类型。

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

9. Java中有几种类型的流

按照流的方向：输入流（inputStream）和输出流（outputStream）。

按照实现功能分：节点流（可以从或向一个特定的地方（节点）读写数据。如 FileReader）和处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。）

按照处理数据的单位：字节流和字符流。字节流继承于 InputStream 和 OutputStream，字符流继承于
InputStreamReader 和OutputStreamWriter。

10. 字节流如何转为字符流

• 字节输入流转字符输入流通过InputStreamReader实现，该类的构造函数可以传入InputStream对象。
• 字节输出流转字符输出流通过OutputStreamWriter实现，该类的构造函数可以传入OutputStream对象。

11. 如何将一个java对象序列化到文件里

在java中能够被序列化的类必须先实现Serializable接口，该接口没有任何抽象方法只是起到一个标记作用。

//对象输出流 
ObjectOutputStream objectOutputStream =  3. new ObjectOutputStream(new FileOutputStream(new File("D://obj"))); 
objectOutputStream.writeObject(new User("zhangsan", 100)); 
objectOutputStream.close(); 

//对象输入流 
ObjectInputStream objectInputStream =  8. new ObjectInputStream(new FileInputStream(new File("D://obj"))); 
User user = (User)objectInputStream.readObject(); 
System.out.println(user); 
objectInputStream.close(); 

12. 字节流和字符流的区别

• 字节流读取的时候，读到一个字节就返回一个字节； 字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编码表，将查到的字符返回。 字节流可以处理所有类型数据，如：图片，MP3，AVI 视频文件，而字符流只能处理字符数据。只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。字节流主要是操作 byte类型数据，以 byte 数组为准，主要操作类就是OutputStream、InputStream
• 字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点。在程序中一个字符等于两个字节，java提供了Reader、Writer两个专门操作字符流的类。

13. 如何实现对象克隆？

有两种方式。

1). 实现 Cloneable 接口并重写 Object 类中的 clone()方法；

2). 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable; 

public class MyUtil { 

    private MyUtil() { 
        throw new AssertionError(); 
    } 
    
    @SuppressWarnings("unchecked") 
    public static <T extends Serializable> T clone(T obj) throws Exception { 
        ByteArrayOutputStream bout = new ByteArrayOutputStream(); 
        ObjectOutputStream oos = new ObjectOutputStream(bout); 
        oos.writeObject(obj); 
        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); 
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject(); 
        // 说明：调用 ByteArrayInputStream 或 ByteArrayOutputStream 对象的 close 方法没有任何意义 
        // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放 
    } 
}

测试代码：

import java.io.Serializable; 
/** 
 * 人类 
 */ 
class Person implements Serializable { 

    private static final long serialVersionUID = -9102017020286042305L; 
    private String name; // 姓名 
    private int age; // 年龄 
    private Car car; // 座驾 
    
    public Person(String name, int age, Car car) { 
        this.name = name; 
        this.age = age; 
        this.car = car; 
    } 
    
    public String getName() { 
        return name; 
    } 
    public void setName(String name) { 
        this.name = name; 
    } 
    public int getAge() { 
        return age; 
    } 
    public void setAge(int age) { 
        this.age = age; 
    } 
    public Car getCar() { 
        return car; 
    } 
    public void setCar(Car car) { 
        this.car = car; 
    } 
    
    @Override 
    public String toString() { 
        return "Person [name=" + name + ", age=" + age + ", car=" + car + "]"; 
    }
} 

/** 
 * 小汽车类 
 */ 
class Car implements Serializable {

    private static final long serialVersionUID = -5713945027627603702L; 
    private String brand; // 品牌 
    private int maxSpeed; // 最高时速 
    
    public Car(String brand, int maxSpeed) { 
        this.brand = brand; 
        this.maxSpeed = maxSpeed; 
    } 
    
    public String getBrand() { 
        return brand; 
    } 
    public void setBrand(String brand) { 
        this.brand = brand; 
    } 
    public int getMaxSpeed() { 
        return maxSpeed; 
    } 
    public void setMaxSpeed(int maxSpeed) { 
        this.maxSpeed = maxSpeed; 
    } 
    
    @Override 
    public String toString() { 
        return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]"; 
    } 
}

class CloneTest { 

    public static void main(String[] args) { 
        try { 
            Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300)); 
            Person p2 = MyUtil.clone(p1); // 深度克隆 
            p2.getCar().setBrand("BYD"); 
            // 修改克隆的 Person 对象 p2 关联的汽车对象的品牌属性 
            // 原来的 Person 对象 p1 关联的汽车不会受到任何影响 
            // 因为在克隆 Person 对象时其关联的汽车对象也被克隆了 
            System.out.println(p1); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
}

注意	基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object 类的 clone 方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

14. 什么是java序列化，如何实现java序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现 Serializable 接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

原文链接：https://www.cnblogs.com/yangchunze/p/6728086.html

15. 静态嵌套类 (Static Nested Class) 和内部类(Inner Class)的不同？

• 静态嵌套类：Static Nested Class 是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。
• 内部类：需要在外部类实例化后才能实例化，其语法看起来挺诡异的。

16. 下面的代码哪些地方会产生编译错误？

class Outer { 

    class Inner {} 

    public static void foo() { 
        new Inner(); 
    } 

    public void bar() { 
        new Inner(); 
    } 

    public static void main(String[] args) { 
        new Inner(); 
    } 
} 
 

注意	Java 中非静态内部类对象的创建要依赖其外部类对象，上面的面试题中 foo 和 main 方法都是静态方法，静态方法中没有 this，也就是说没有所谓的外部类对象，因此无法创建内部类对象，如果要在静态方法中创建内部类对象

可以这样做

new Outer().new Inner(); 

欢迎关注作者的公众号《Java编程生活》，每日记载Java程序猿工作中遇到的问题