笔试记录一

来源: 笔试记录一

垃圾回收机制

具体请参照垃圾回收机制

数组的定义

• 数组元素类型是基本类型中的整数类型（byte、short、int、long），则数组元素的值是 0

• 数组元素类型是基本类型中的浮点类型（float、double），则数组元素的值是 0.0

• 数组元素类型是基本类型中的字符类型（char），则数组元素的值是 ’ ‘

• 数组元素类型是基本类型中的布尔类型（boolean），则数组元素的值是 false

• 数组元素类型是基本类型中的引用类型（类、接口、数组），则数组元素的值是 null

数组定义的三种方式：

    //type[] arrayName; 或 type arrayName[];

    int[] arr1 = new int[10];//动态初始化 [] 中必须指定元素个数

    int[] arr2 = {1,2,3,6};  

    int[] arr3 = new int[]{1,2,3,4,5,6,7,22};//静态初始化 [] 中不能指定元素个数

自增

写出下面代码的运行结果

    int a = 0;
    int b = 0;
    if(a++ > 0 && ++b > 0) {
        a = ++a + 1;
        b = b++ + 1;
    }
    System.out.println(a + " " + b);
    //输出：1 0

执行步骤：

1. 判断 a++ > 0，结果是 false，因为是首先 a 与 0 比较，再自增；

2. 当 && 的前面一部分已经判断为 false 时，不会再判断后面的真假，直接跳出 if；

3. 所以最后 a 的值为 1，b 的值为 0。

当 if 语句改为 if(++a > 0 && ++b > 0) 时，最后 a 的值为 3，b 的值为2；
执行步骤：

1. ++a > 0 && ++b > 0 结果为 true，a = 1，b = 1，进入 if 中；

2. a = ++a + 1; a 先自增，再加一，a 的值变为 3；

3. b = b++ + 1; b 只加一，b 的值变为 2；

4. b = 1 的情况下，b=b++; 还是会输出 1，这是因为原先 b 的值存在了一个暂存区域中，进行完 b++ 的操作后会先将 b++ 的值（也就是2）赋给 b，然后再将暂存区域的值赋给 b，最后 b 的值还是 1；

String 连接符

    String a = "aa";
    String b = "bb";
    String c;
    c = a + b;
    c = a - b;
    c = a || b;
    c = a && b;
    c = a & b;
    //The operator -,||,&,&& is undefined for the argument type(s) java.lang.String, java.lang.String

只有 c = a + b; 不会报错，并且执行之后 c = “aabb”;
其实这是我“大概想”的题目，因为我忘记实际题目是什么了。

Integer and int

    int a = 1;
    Integer b = 1;
    Integer c = new Integer(1);
    System.out.println(a == b);//true，Integer 会自动拆箱为 int
    System.out.println(a == c);//true，同上
    System.out.println(b == c);//false，new 出来的对象在堆中，而非 new 的常量放在常量池(方法区)

    //所以 Integer 和 new Integer 总不会相等，因为内存地址不一样；

    Integer d1 = 127;
    Integer d2 = 127;
    System.out.println(d1 == d2);//true，编译时被翻译成：Integer d1 = Integer.valueOf(127); 

    //valueOf() 函数会对 -128 - 127 之间的数据进行缓存；所以 d1 对 127 进行缓存之后，d2 直接到缓存中去取；

    Integer e1 = 128;
    Integer e2 = 128;
    System.out.println(e1 == e2);//false，128 不在缓存之列；

    Integer f1 = new Integer(127);
    Integer f2 = new Integer(127);
    System.out.println(f1 == f2);//false，两个new 出来的对象总不会相等，因为内存地址不一样；

抛出异常

抛出异常有三种形式：

1. 系统自动抛出异常
   当程序语句出现一些逻辑错误或类型转换等错误时，如：

System.out.println(5/0);
//系统抛出 java.lang.ArithmeticException: / by zero 异常

System.out.println(Double.parseDouble("abc"));
//系统抛出 java.lang.NumberFormatException 异常

1. throw
   throw 是在方法中抛出一个异常，当程序出现某种逻辑错误时程序员主动抛出某类异常；如：

    String s = "abc";   
    if(s.equals("abc")) {   
      throw new NumberFormatException();   
    } else {   
      System.out.println(s);   
    }
    //运行时，抛出 java.lang.NumberFormatException 异常

1. throws
   throws 是方法头声明，表示该方法可能会抛出某类异常，然后交给上层调用它的程序去处理；如：

    public static void function() throws NumberFormatException{   
    String s = "abc";   
    System.out.println(Double.parseDouble(s));   
    }   

    public static void main(String[] args) {   
        try {   
            function();   
        } catch (NumberFormatException e) {   
            System.err.println("非数据类型不能强制类型转换");   
            //e.printStackTrace();   
        }
    }
    //运行时输出：非数据类型不能强制类型转换

总结，throw 和 throws 的区别：

• throws 在函数头声明，throw 在函数体中声明；
• throws 表示可能出现这种异常，并不一定会发生；而 throw 执行则一定抛出了某种异常；

编程习惯：

• 对可能出现的异常要用 try catch 进行处理；
• 在 try 中捕捉了异常之后要在 catch 中进行处理，以便后续的检查或改进；
• 如果是捕捉了 IO 类异常，要记得在 finally 中关闭输入输出流；

爬楼梯

n 阶楼梯上楼问题：一次可以走两阶或一阶，问有多少种上楼方式。(要求采用非递归)
走到第 n 阶时可能是从第 n-1 阶走一步到的，也可能是从 n-2 阶走两阶到的，设 F(n) 为走到 n 阶的种数，则 F(n) = F(n-1) + F(n-2)；
这是一个动态规划的问题，其实就是一个斐波那契数列。

//选用 BigInteger 型来防止溢出
public static void climbStairs(int n) {
    BigInteger t1 = new BigInteger("1");
    BigInteger t2 = new BigInteger("2");
    BigInteger result = new BigInteger("0");
    for (int i = 3; i <= n; i++) {
        result = t1.add(t2); //大整数相加
        t1 = t2;
        t2 = result;
    }
    System.out.println(result);
}

public static void main(String[] args) throws Exception {

    Scanner scan = new Scanner(System.in);
    System.out.println("请输入阶梯数：");
    int n = scan.nextInt(); 
    if(n == 1)
        System.out.println(1);
    else if(n == 2)
        System.out.println(2);
    else if(n > 2)
        climbStairs(n);
    scan.close();
}

和最大连续子串

给出一个无序数组, 找出连续的任意多个元素, 使得其和加起来是最大的, 要求时间复杂度为 O(N)

    public static int findMaxSubStringSum(int[] arr){  
        int Max = arr[0];  
        int sum = 0;  
        for (int i = 0; i < arr.length; i++) {  
            sum += arr[i];  
            if (sum > Max) {  
                Max = sum;  
            }  
            if (arr[i]<0) {  
                sum = 0;  
            }  
        }  
        return Max;  
    } 

扩展

    char ch = 'b' + 1;
    System.out.println(ch);
    //输出：c

    int newindex = 9;
    System.out.println(newindex--); //输出 9
    System.out.println(newindex); //输出 8

    int[][] a = { { 1, 2, 3, 4, 5 }, { 3, 4, 5, 6, 7 } };
    System.out.println(array.length); //输出 2
    System.out.println(array[0].length); //输出 5

public class Test{
    private void test(){ 
       System.out.println(super.getClass().getName()); 
    } 
    public static void main(String[]args){ 
       new Test().test(); 
    } 
}
//输出：basicImprove.Test

参考

https://blog.csdn.net/hjfcgt123/article/details/53349275