Java面试八股文整理

一、Java基础

1. JRE和JDK的区别

• 定义

  JRE(Java Runtime Enviroment) 是Java的运行环境。面向Java程序的使用者，而不是开发者。如果你仅下载并安装了JRE，那么你的系统只能运行Java程序。JRE是运行Java程序所必须环境的集合，包含JVM标准实现及 Java核心类库。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具(编译器、调试器等)。

  JDK(Java Development Kit) 又称J2SDK(Java2 Software Development Kit)，是Java开发工具包，它提供了Java的开发环境(提供了编译器javac等工具，用于将java文件编译为class文件)和运行环境(提 供了JVM和Runtime辅助包，用于解析class文件使其得到运行)。如果你下载并安装了JDK，那么你不仅可以开发Java程序，也同时拥有了运 行Java程序的平台。JDK是整个Java的核心，包括了Java运行环境(JRE)，一堆Java工具tools.jar和Java标准类库 (rt.jar)。

• 区别

  JRE主要包含：java类库的class文件(都在lib目录下打包成了jar)和虚拟机(jvm.dll)；

  JDK主要包含：java类库的 class文件(都在lib目录下打包成了jar)并自带一个JRE。那么为什么JDK要自带一个JRE呢？而且jdk/jre/bin下的client 和server两个文件夹下都包含jvm.dll(说明JDK自带的JRE有两个虚拟机)。

2. Java中equals()和==的区别

• equals() 是判断两个变量或者实例指向同一个内存空间的值是不是相同
• “==” 是判断两个变量或者实例是不是指向同一个内存空间
• java中的数据类型，可分为两类：
  1. 基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
     他们之间的比较，应用双等号 “==” ,比较的是他们的值。
  2. 复合数据类型(类)
     当他们用 “==” 进行比较的时候，比较的是他们在 内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals() 的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals() 有其自身的实现，而不再是比较类在堆内存中的存放地址了。
     对于复合数据类型之间进行equals() 比较，在没有覆写equals() 方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals() 方法也是用双等号 “==” 进行比较的，所以比较后的结果跟双等号 “==” 的结果相同。

3. 两个对象的hashCode()相同，则equals()也一定为true么

• 首先，答案肯定是不一定。同时反过来equals()为true，hashCode()也不一定相同。
• 类的hashCode()方法和equals()方法都可以重写，返回的值完全在于自己定义。
• hashCode()返回该对象的哈希码值；equals()返回两个对象是否相等。
• 关于hashCode()和equals()方法是有一些常规协定 ：
  1. 两个对象用equals()比较返回true，那么两个对象的hashCode()方法必须返回相同的结果。
  2. 两个对象用equals()比较返回false，不要求hashCode()方法也一定返回不同的值，但是最好返回不同值，以提高哈希表性能。
  3. 重写equals()方法，必须重写hashCode()方法，以保证equals方法相等时两个对象hashcode返回相同的值。

4. java中的final关键字

• final关键字可以用来修饰引用、方法和类。

• 用来修饰一个引用

  1. 如果引用为基本数据类型，则该引用为常量，该值无法修改；
  2. 如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。
  3. 如果引用时类的成员变量，则必须当场赋值，否则编译会报错。

• 用来修饰一个方法

  1. 当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承。

• 用来修饰类

  1. 当用final修改类时，该类成为最终类，无法被继承。简称为“断子绝孙类”。

5. java 中操作字符串都有哪些类？它们之间有什么区别？

主要是一下三种：String、StringBuffer、StringBuilder

String和StringBuilder和StringBuffer的区别

String

StringBuffer

StringBuilder

String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量优先的内存空间

StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量

可变类，速度更快

不可变

可变

可变

线程安全，因为 StringBuffer 的所有公开方法都是 synchronized 修饰的

线程不安全

多线程操作字符串

单线程操作字符串

6. String str = “i” 与 String str = new String(“i”)一样吗？

• 不一样，因为内存的分配方式不一样。
  1. String str = "i"的方式，Java虚拟机会将其分配到常量池中；而String str = new String(“i”)则会被分到堆内存中。
  2. String str=“i”; 因为String 是final类型的，所以“i”应该是在常量池；而new String(“i”);则是新建对象放到堆内存中。

7. Java如何将字符串反转

1. 利用 StringBuffer 或 StringBuilder 的 reverse 成员方法:

     // StringBuffer
     public static String reverse1(String str) {
       return new StringBuilder(str).reverse().toString();
     }
   

2. 利用 String 的 toCharArray 方法先将字符串转化为 char 类型数组，然后将各个字符进行重新拼接:

    // toCharArray
     public static String reverse2(String str) {
       char[] chars = str.toCharArray();
       String reverse = "";
       for (int i = chars.length - 1; i >= 0; i--) {
         reverse += chars[i];
       }
       return reverse;
     }
   

3. 利用 String 的 CharAt 方法取出字符串中的各个字符:

     // charAt
     public static String reverse3(String str) {
       String reverse = "";
       int length = str.length();
       for (int i = 0; i < length; i++) {
         reverse = str.charAt(i) + reverse;
       }
       return reverse;
     }
   

8. Java-String类的常用方法总结

1. String类
   String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。java把String类声明的final类，不能有类。String类对象创建后不能修改，由0或多个字符组成，包含在一对双引号之间。

2. String类对象的创建
   字符串声明：String stringName;
   字符串创建：stringName = new String(字符串常量);或stringName = 字符串常量;

3. String类构造方法
   1、public String()
   无参构造方法，用来创建空字符串的String对象。

   String str1 = new String(); 
   

   2、public String(String value)
   用已知的字符串value创建一个String对象。

   String str2 = new String("asdf"); 2 String str3 = new String(str2); 
   

   3、public String(char[] value)
   用字符数组value创建一个String对象。

   char[] value = {'a','b','c','d'};
   String str4 = new String(value);//相当于String str4 = new String("abcd");
   

   4、public String(char chars[], int startIndex, int numChars)
   用字符数组chars的startIndex开始的numChars个字符创建一个String对象。

   char[] value = {'a','b','c','d'};
   String str5 = new String(value, 1, 2);//相当于String str5 = new String("bc");
   

   5、public String(byte[] values)
   用比特数组values创建一个String对象。

   byte[] strb = new byte[]{65,66};
   String str6 = new String(strb);//相当于String str6 = new String("AB");
   

4. String类常用方法
   1、求字符串长度
   public int length()//返回该字符串的长度

   String str = new String("asdfzxc");
   int strlength = str.length();//strlength = 7
   

   2、求字符串某一位置字符
   public char charAt(int index)//返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。

   String str = new String("asdfzxc");
   char ch = str.charAt(4);//ch = z
   

   3、提取子串
   用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:

   • public String substring(int beginIndex)//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。

   • public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

     String str1 = new String(“asdfzxc”);
     String str2 = str1.substring(2);//str2 = “dfzxc”
     String str3 = str1.substring(2,5);//str3 = “dfz”

   4、字符串比较

   • public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。

   • public int compareToIgnore(String anotherString)//与compareTo方法相似，但忽略大小写。

   • public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。

   • public boolean equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。

     String str1 = new String(“abc”);
     String str2 = new String(“ABC”);
     int a = str1.compareTo(str2);//a>0
     int b = str1.compareToIgnoreCase(str2);//b=0
     boolean c = str1.equals(str2);//c=false
     boolean d = str1.equalsIgnoreCase(str2);//d=true

   5、字符串连接
   public String concat(String str)//将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。

   String str = "aa".concat("bb").concat("cc");
   相当于String str = "aa"+"bb"+"cc";
   

   6、字符串中单个字符查找

   • public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。

   • public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。

   • public int lastIndexOf(int ch/String str)//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。

   • public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。

     String str = “I am a good student”;
     int a = str.indexOf(‘a’);//a = 2
     int b = str.indexOf(“good”);//b = 7
     int c = str.indexOf(“w”,2);//c = -1
     int d = str.lastIndexOf(“a”);//d = 5
     int e = str.lastIndexOf(“a”,3);//e = 2

   7、字符串中字符的大小写转换

   • public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串

   • public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串

     String str = new String(“asDF”);
     String str1 = str.toLowerCase();//str1 = “asdf”
     String str2 = str.toUpperCase();//str2 = “ASDF”

   8、字符串中字符的替换

   • public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。

   • public String replaceFirst(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。

   • public String replaceAll(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。

     String str = “asdzxcasd”;
     String str1 = str.replace(‘a’,‘g’);//str1 = “gsdzxcgsd”
     String str2 = str.replace(“asd”,“fgh”);//str2 = “fghzxcfgh”
     String str3 = str.replaceFirst(“asd”,“fgh”);//str3 = “fghzxcasd”
     String str4 = str.replaceAll(“asd”,“fgh”);//str4 = “fghzxcfgh”

   9、其他类方法

   • String trim()//截去字符串两端的空格，但对于中间的空格不处理。

     String str = " a sd ";
     String str1 = str.trim();
     int a = str.length();//a = 6
     int b = str1.length();//b = 4

   • boolean statWith(String prefix)或boolean endWith(String suffix)//用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同，重载方法中同时还可以指定比较的开始位置offset。

     String str = “asdfgh”;
     boolean a = str.statWith(“as”);//a = true
     boolean b = str.endWith(“gh”);//b = true

   • regionMatches(boolean b, int firstStart, String other, int otherStart, int length)//从当前字符串的firstStart位置开始比较，取长度为length的一个子字符串，other字符串从otherStart位置开始，指定另外一个长度为length的字符串，两字符串比较，当b为true时字符串不区分大小写。

   • contains(String str)//判断参数s是否被包含在字符串中，并返回一个布尔类型的值。

     String str = “student”;
     str.contains(“stu”);//true
     str.contains(“ok”);//false

   • String[] split(String str)//将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。

     String str = “asd!qwe|zxc#”;
     String[] str1 = str.split(“!|#”);//str1[0] = “asd”;str1[1] = “qwe”;str1[2] = “zxc”;

5. 字符串与基本类型的转换

   1. 字符串转换为基本类型
      java.lang包中有Byte、Short、Integer、Float、Double类的调用方法：

      public static byte parseByte(String s)
      public static short parseShort(String s)
      public static short parseInt(String s)
      public static long parseLong(String s)
      public static float parseFloat(String s)
      public static double parseDouble(String s)
      

      例如：

      int n = Integer.parseInt("12");
      float f = Float.parseFloat("12.34");
      double d = Double.parseDouble("1.124");
      

   2. 基本类型转换为字符串类型
      String类中提供了String valueOf()放法，用作基本类型转换为字符串类型。

      static String valueOf(char data[])
      static String valueOf(char data[], int offset, int count)
      static String valueOf(boolean b)
      static String valueOf(char c)
      static String valueOf(int i)
      static String valueOf(long l)
      static String valueOf(float f)
      static String valueOf(double d)
      

      例如：

      String s1 = String.valueOf(12);
      String s1 = String.valueOf(12.34);
      

   3. 进制转换
      使用Long类中的方法得到整数之间的各种进制转换的方法：

      Long.toBinaryString(long l)
      Long.toOctalString(long l)
      Long.toHexString(long l)
      Long.toString(long l, int p)//p作为任意进制
      

9. 抽象类必须要有抽象方法吗？

• 答：不需要，

  抽象类不一定有抽象方法；但是包含一个抽象方法的类一定是抽象类。（有抽象方法就是抽象类，是抽象类可以没有抽象方法）

• 解释：

  • 抽象方法：

    java中的抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。

  • 抽象方法与抽象类：

    当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为abstract。abstract抽象类不能用new实例化对象，abstract方法只允许声明不能实现。如果一个类中含有abstract方法，那么这个类必须用abstract来修饰，当然abstract类也可以没有abstract方法。 一个抽象类里面没有一个抽象方法可用来禁止产生这种类的对象。

  • Java中的抽象类：

    abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

    在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

10. 普通类和抽象类有哪些区别

• 关键点：abstract修饰符（抽象方法）、具体实现过程、实例化、子类实现父类的抽象方法

  1. 普通类中不可含有抽象方法，可以被实例化；
  2. 抽象类，则抽象类中所有的方法自动被认为是抽象方法，没有实现过程，不可被实例化；
  3. 抽象类的子类，除非也是抽象类，否则必须实现该抽象类声明的方法

11. 抽象类可以使用final修饰吗？

• 当然不可以，通过理解抽象类的作用我们就发现了，抽象类必须要被继承，如果用final修饰抽象类，这个抽象类就无法被继承，自然就无法使用了。

12. java中abstract类和interface的区别

• 相同点

  1. 两者都是抽象类，都不能实例化。
  2. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

• 不同点

  1. interface需要实现，要用implements，而abstract class需要继承，要用extends。
  2. 一个类可以实现多个interface，但一个类只能继承一个abstract class。
  3. interface强调特定功能的实现，而abstractclass强调所属关系。
  4. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。interface中的每一个方法都是抽象方法，都只是声明的(declaration,没有方法体)，实现类必须要实现。而abstract class的子类可以有选择地实现。

13. Java中的IO流

指的是将不同的输入输出源通过流的形式进行输入或输出的操作，流是一种抽象的描述，在程序中指的是数据的一种转移方式。

• IO流的分类：

  1. 按照数据的流向：
     输入流、输出流
  2. 按照流数据的格式：
     字符流、字节流
  3. 按照流数据的包装过程：
     节点流（低级流）、处理流（高级流）

• 最基本的几种进行简单介绍：

  1. InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
  2. OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

• Java文本文件读取的大致过程如下：

  1. 构建文件对象，
  2. 使用文件对象构造Reader对象可以是FileReader、InputStreamReader、RandomAccessFile等
  3. 使用Reader对像构建BufferedReader对象(主要使用其**readLine()**方法，用于按行读取文件)
  4. 按行读取文件，将每行获取到的字符串进行处理。

14. BIO,NIO,AIO 有什么区别

• BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
• NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发。
• AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

15. Files的常用方法有哪些？

• Files.exists() 检测文件路径是否存在
• Files.createFile()创建文件
• Files.createDirectory()创建文件夹
• Files.delete() 删除文件或者目录
• Files.copy() 复制文件
• Files.move() 移动文件
• Files.size（）查看文件个数
• Files.read() 读取文件
• Files.write()写入文件

16. 类加载过程

1. 加载

   加载指的是将类的class文件读入到内存，并为之创建一个java.lang.Class对象，也就是说，当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象。

   类的加载由类加载器完成，类加载器通常由JVM提供，这些类加载器也是前面所有程序运行的基