一次Java基础测试

题目

1.i += j与i = i + j有什么区别？
2.一个数组如何转换为List？
3.&与&&有什么区别 ? char a=100;int b=260 a&b 等于？
4.如何测试一个数组是否包含指定的值？
5.如何从一个多层嵌套循环中直接跳出？
6.在Java中如何对比String？
7.能否在一个构造器中调用另一个构造器？
8.Java 产生指定范围的随机数？
9.如何遍历map对象？
10.StringBuilder和StringBuffer有哪些区别呢？
11.byte b1 = 3;byte b2 = 4;byte b3 = b1 + b2;有什么问题？
12.Java中char类型可以存储一个汉字吗？
13.int x = 4;int y = (x++)+(++x)+(x*10);y = ？
14.Java找出1~1000中素数的三种方式?

参考答案

1.类似于+=操作符在做不同类型数据运算时会通过编译，而+再=不会通过编译。
官方文档是这么写的：A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T) ((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once.

int i = 1;
long l = 1l;

i += l;//可以通过编译
i = i +l;//无法通过编译
i = (int) (i + l);//+=的本质

顺便说一句JVM在运算期间除了除数不能为0之外不会抛出别的计算异常。
2.通过Arrays.asList()方法可以将一个数组转化为List对象。

String[] arr = {"aa", "bb", "cc"};
List l = Arrays.asList(arr);
System.out.print(l);

但是这样做生成的list，是定长的。也就是说，如果你对它做add或者remove，都会抛UnsupportedOperationException。如果修改数组的值，list中的对应值也会改变！

String[] arr = {"aa", "bb", "cc"};
List l = Arrays.asList(arr);
System.out.print(l);
l.add("dd");
System.out.print(l);

**备注：Arrays.asList() 返回的是Arrays内部静态类，
而不是Java.util.ArrayList的类。这个java.util.Arrays.ArrayList有set(),get(),contains()方法，但是没有任何add() 方法，所以它是固定大小的。**
3.按位与：a&b是把a和b都转换成二进制数然后再进行与的运算；
逻辑与：a&&b就是当且仅当两个操作数均为 true时，其结果才为 true；只要有一个为零，a&&b就为零。另外，如果&&第一个元素为假后面的判断不会进行。如果&&后面的是个方法调用就需要注意它会不会执行。
a&b实际是0000 0000 0110 0100&0000 0001 0000 0100。
其结果为int型0000 0000 000 0100即4
4.

private boolean contains0(String[] arr, String target) {
    for (String s : arr) {
        if (s.equals(target))
            return true;
    }
    return false;
}

private boolean contains1(String[] arr, String target) {
    return Arrays.asList(arr).contains(target);
}

其实第二种方法contains()里面最后用的也是equals()。
5.

        for(int i = 0; i < 10; i++){
            for (int j = 0; j < 10; j++){
                if (i == 5 && j == 5){
                    break;
                } else if (i == 6 && j == 6){
                    return;
                } else {
                    continue;
                }
                System.out.print("test for loop");
            }
        }

这个题是为了考察continue ， break ， return的区别。
continue是结束此次循环，开始下一次循环。
break是结束整个for循环。
return是退出整个方法。
6.这个题是为了考察字符串比较里==与equals()的区别。==比较的是对象的地址，而equals()是Object里的方法，用来比较对象是否内容一样，具体结果看具体对象的类的实现。String里的equlas()比较的是内容，但是第一步也用==做了判断。
7.常见的构造器中调用另一个构造器的情况就是super()与this()。如果你想调用一个特定的父类构造器，而不是本类的构造器，应该使用super，而不是this。请注意，在构造器中，你只能调用一次其他的构造器。并且调用其他构造器的语句，必须是这个构造器的第一个语句。
8.产生随机数的最常使用的方法是Math.random()。它的结果是产生一个[0,1)的随机数（这个是一个伪随机数）。如果想产生特定区间的随机数可以通过如下的公式计算：
int num = min + (int)(Math.random() * (max-min+1));
9.遍历Map的四种方式：
（1）通过entrySet

Map<Integer, Integer> map = new HashMap<>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
    System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}

（2）通过keySet

Map<Integer, Integer> map = new HashMap<>();
// iterating over keys onlyfor (Integer key : map.keySet()) {
    System.out.println("Key = " + key);
    }
// iterating over values only
for (Integer value : map.values()) {              
    System.out.println("Value = " + value);
}

（3）通过Iterator

Map<Integer, Integer> map = new HashMap<>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {    
    Map.Entry<Integer, Integer> entry = entries.next();   
    System.out.println("Key = " + entry.getKey() + ", Value= " + entry.getValue());
}

（4）通过keySet再get（key）

Map<Integer, Integer> map = new HashMap<>();
for (Integer key : map.keySet()) {    
    Integer value = map.get(key);
    System.out.println("Key = " + key + ", Value = " + value);
}

第四种方法最为低效。第三种方法中的Iterator是一个接口，包括HashMap在内的很多集合实现了这个接口。这个对我们遍历集合提供了一种非常方便的手段。
10.最主要的区别，StringBuffer的实现用了synchronized（锁），而StringBuilder没有，因此，StringBuilder会比StringBuffer快。StringBuffer线程安全，StringBuilder线程不安全。
使用场景：
①非常非常追求性能（其实这两个都不慢，比直接操作String，要快非常多了）
②不需要考虑线程安全问题,
③JRE是1.5+
可以用StringBuilder,反之，请用StringBuffer。
11.长度比int小的数据类型在运算时都会自动转成int型在进行计算。所以b1 + b2在计算时已经是int型，如果不经过强制转换将结果赋值给一个byte型变量会编译不通过。
12.可以存储，因为Java采用Unicode编码，Unicode中每个字符占两个字节，char的长度是两个字节，所以可以存储。
13.这道题是为了考察x++与++x的区别：(x++)+(++x)+(x*10)
（）的优先级最高，有三个括号，所以从左至右依次计算括号里的值。
第一个括号中x++，意思是计算结束后再将x + 1，所以括号里的值为4，x = 5.第二股括号中++x，意思是先将x + 1再进行后面的计算，此时括号里的值为6，x = 6。第三个括号的值为6 * 10 = 60。括号里的计算结束，剩下的都是加法运算，优先级一样，所以从左到右依次做加法。最后结果为70。
14.素数的含义是只能被1和自己整除。
（1）对每一个在2-1000里的数作如下操作，逐个跟所有在2跟比自己小一个数之间所有的数进行求余运算，如果余数为0，则计算下一个2-1000里的数。

int j;
boolean flag;
for (int i = 2; i < 1000; i++) {
    flag = false;
    for (j = 2; j < i; j++) {
        if (i % j == 0) {
            flag = true;
            break;            
        }        
    }        
    if (!flag) {            
        System.out.print(i + "\n");        
    }    
}

（2）对上面的内层循环做少许改进

int j;
boolean flag;
for (int i = 2; i < 1000; i++) {
    flag = false;
    for (j = 2; j < i / 2; j++) {
        if (i % j == 0) {
            flag = true;
        }
    }
    if (!flag) {     
        System.out.print(i + "\n");        
    }    
}

（3）我们发现其实内层循环只要比到比自己开方之后的值小就可以。

int j;
boolean flag;
for (int i = 2; i < 1000; i++) {
    flag = false;
    for (j = 2; j < Math.sqrt(i); j++) {            
        if (i % j == 0) {                
            flag = true;                
            break;            
        }        
    }        
    if (!flag) {            
        System.out.print(i + "\n");        
    }    
}

（4）上述过程还可以优化，内层循环不需要逐个从2比到自己开方结果小一个，只需要比较2,3,5,7…这些数就可以