java面试（一）

Java基础考核点

1. JDK、JRE、JVM三者之间的关系?
   JDK，即Java开发工具包，其中包括编译工具(javac.exe)打包工具(jar.exe)等，也包括JRE。
   JRE，即Java运行环境，包含JVM标准实现（Jvm虚拟机）与Java核心类库。
   JVM，即java虚拟机，是java运行时的环境。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行，这就是Java能够“一次编译，到处运行”的原因。

2. &和&&的区别
   &和&&都是逻辑运算符（and）,&&还有一个短路的功能，即当第一个表达式为false时，不判断第二个表达式。

3. 对于整数i,i++和++i有什么区别?
   i即为整数类型的变量i,赋值时是i的值，i的值不会发生变化
   i++ 返回原来的值，++i 返回加1后的值，执行这两个语句后，i都会加一

4. 简述Java语言的数据类型?对基本数据类型，分别占几个字节?
   java的数据类型分为基本数据类型和引用数据类型，引用数据类型的值为数据所在的地址。
   基本数据类型：byte short int long float double boolean char
   分别占的字节：1,2,4,8,4,8,不确定,2
   boolean占的字节是不确定的，使用boolean数组时，8个boolean占用一个字节。

5. 整数据的默认类型为?浮点数默认类型?
   int,double

6. String与stringBuffer区别?
   String对象一旦创建，其值是不能修改的，如果要修改，会重新开辟内存空间来存储修改之后的对象；而StringBuffer对象的值是可以被修改的；
   StringBuffer几乎所有的方法都使用synchronized实现了同步，线程比较安全，在多线程系统中可以保证数据同步，但是效率比较低

7. String s=new String(““xyz””);创建了几个String对象?
   两个对象，字符串常量池的常量字符串"xyz"，堆中的s对象指向方法区的常量对象。

8. 什么是字符串常量池?
   字符串常量池用于存储所有字符串实例的引用，以及运行时动态添加的引用。字符串常量池是全局的，只有一个。当我们以 String str = "123"形式创建字符串实例时，首先会去判断字符串常量池中是否有引用指向相同内容的实例，如果有则返回该实例。否则在堆中创建 String 对象并将引用驻留在字符串常量池中。

9. StringBuffer和StringBuilder区别?
   StringBuffer几乎所有的方法都使用synchronized实现了同步，线程比较安全，在多线程系统中可以保证数据同步，但是效率比较低；而StringBuilder 没有实现同步，线程不安全，在多线程系统中不能使用 StringBuilder，但是效率比较高。

10. = =和equals的区别?
    ==:对于基本类型，比较的是值是否相等；对于引用类型，比较的是地址是否相等
    equals:比较的是对象是否相等,我们可以重写类equals方法，按照我们的标准来判定两个对象是否相等。

11. final关键字作用？
    修饰类：类不能被继承
    修饰方法：方法不能被重写
    修饰变量：
    - 基本数据类型：值不能修改
    - 引用数据类型：对象不能被修改，对象的属性可以修改
    - 成员变量：必须被初始化（直接赋值或者在实例代码块、所有的构造方法中赋值都可以）
    - 静态变量：必须被初始化（直接赋值或者在静态代码块中赋值）

12. String能被继承吗？
    不能被继承，String类被final关键字修饰，不能被继承。

13. String 类有那些常用方法?【字符串是否熟】

    int length()：返回字符串的长度
    char charAt(int index)：返回指定索引处的字符
    boolean isEmpty()：判断字符串是否为空
    String toLowerCase()：将字符串中的所有字符转换为小写
    String toUpperCase()：将字符串中的所有字符转换为大写
    String trim()：返回字符串的副本，去掉前导空白和尾部空白，中间的空白不会被去掉
    boolean equals(Object obj)：比较字符串的内容是否相同
    boolean equalsIgnoreCase(String anotherString)：忽略大小写，比较字符串的内容是否相同
    String concat(String str)：将指定字符串连接到此字符串的结尾，等价于用“+”
    int compareTo(String anotherString)：比较两个字符串的大小
    String substring(int beginIndex)：返回从beginIndex到末尾的子字符串
    String substring(int beginIndex, int endIndex)：返回从beginIndex到endIndex前一位的子字符串,不包括endIndex
    
    boolean endsWith(String suffix)： 判断字符串是否以指定的后缀结束
    boolean startsWith(String prefix)：判断字符串是否以指定的前缀开始
    boolean startsWith(String prefix, int toffset)：判断字符串在指定索引开始的子字符串是否以指定前缀开始
    boolean contains(CharSequence s)：判断当前字符串中是否包含指定的字符串
    
    int indexOf(String str)：返回指定子字符串在当前字符串中第一次出现处的索引
    int indexOf(String str, int fromIndex)：返回从指定的索引后，指定子字符串在当前字符串中第一次出现处的索引
    int lastIndexOf(String str)：返回指定子字符串在当前字符串中最后一次出现处的索引
    int lastIndexOf(String str, int fromIndex)：返回从指定的索引后，指定子字符串在当前字符串中最后一次出现处的索引
    注：indexOf和lastIndexOf方法如果未查找到指定子字符串时，返回值都为-1。
    
    String replace(char oldChar, char newChar)：替换当前字符串中指定的子字符串
    String[] split(String regex)：根据指定的符号拆分当前字符串，然后返回一个String数组
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26

14. Java程序执行流程|类加载过程
    当Java程序需要使用某个类时，如果该类还未被加载到内存中，JVM会通过加载、连接(验证、准备和解析)、初始化三个步骤来对该类进行初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。

15. 什么是递归?用递归求:1,1,2，3，5,…数数列的第30个数?
    递归，就是在运行的过程中调用自己。

    static int digui(int n ){
        if (n == 1 || n == 2){
            return 1;
        }
        return digui(n - 1) + digui(n - 2);
    }
    
    public static void main(String[] args) {
        digui(30);
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

16. 结束循环的常用方式有哪些?
    break:直接结束整个循环
    contine:不执行下面的语句，直接进入本循环结构的下一次循环操作
    return:通过结束方法的方式结束循环

17. switch语句判断表达式支持的数据类型有哪些?
    byte short int char String 枚举

18. 用冒泡法实现对数组排序【快速排序】
    冒泡

    class Bubble {
        public static void main(String[] args) {
            int arr[] = {1,7,3,9,2};
            bubble(arr);
            System.out.println(Arrays.toString(arr));
        }
        public static void bubble(int[] arr){
            for (int i = 0; i < arr.length - 1; i++){
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }
    //[1, 2, 3, 7, 9]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    快排

    class QuickSort {
        public static void main(String[] args) {
            int arr[] = {1,7,3,9,2};
            quickSort(arr,0,arr.length - 1);
            System.out.println(Arrays.toString(arr));
        }
        public static void quickSort(int arr[],int left,int right){
            int pivot = arr[left];//轴值
            int i = left;//左下标
            int j = right;//右下标
            while (i < j) {
                //在右边找到一个比中值小或者相等的值
                while (i < j && arr[j] > pivot) {
                    j--;
                }
                //在左边找到一个比中值大或者相等的值
                while (i < j && arr[i] < pivot) {
                    i++;
                }
                //在i和j没有相遇时，如果 arr[i] == arr[j] 此时让i+1
                //即让arr[i+1] 与arr[j]进行交换 ，使两个相同的数在一起
                if (arr[i] == arr[j] && i < j) {
                    i++;
                } else {//交换
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
    
            //左半部递归
            if (i-1 > left) {
                quickSort(arr,left,i-1);
            }
            //右半部递归
            if (j+1 < right) {
                quickSort(arr,j+1,right);
            }
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40