来源: 笔试记录一
垃圾回收机制
具体请参照垃圾回收机制
数组的定义
数组元素类型是基本类型中的整数类型(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
执行步骤:
判断 a++ > 0,结果是 false,因为是首先 a 与 0 比较,再自增;
当 && 的前面一部分已经判断为 false 时,不会再判断后面的真假,直接跳出 if;
所以最后 a 的值为 1,b 的值为 0。
当 if 语句改为 if(++a > 0 && ++b > 0)
时,最后 a 的值为 3,b 的值为2;
执行步骤:
++a > 0 && ++b > 0
结果为 true,a = 1,b = 1,进入 if 中;a = ++a + 1;
a 先自增,再加一,a 的值变为 3;b = b++ + 1;
b 只加一,b 的值变为 2;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 出来的对象总不会相等,因为内存地址不一样;
抛出异常
抛出异常有三种形式:
- 系统自动抛出异常
当程序语句出现一些逻辑错误或类型转换等错误时,如:
System.out.println(5/0);
//系统抛出 java.lang.ArithmeticException: / by zero 异常
System.out.println(Double.parseDouble("abc"));
//系统抛出 java.lang.NumberFormatException 异常
- throw
throw 是在方法中抛出一个异常,当程序出现某种逻辑错误时程序员主动抛出某类异常;如:
String s = "abc";
if(s.equals("abc")) {
throw new NumberFormatException();
} else {
System.out.println(s);
}
//运行时,抛出 java.lang.NumberFormatException 异常
- 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