java面试题-Java基础部分-基础语法 31-40

今天药忘吃喽~ 2022-01-22 15:09 266阅读 0赞

**基础语法 31-40**

31、String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？

32、是否可以继承 String 类?

33、String s = new String("xyz");创建了几个 String Object?二者之间有什么 区别？

34、String 和 StringBuffer 的区别

35、如何把一段逗号分割的字符串转换成一个数组?

36、数组有没有 length()这个方法? String有没有 length()这个方法？

37、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";

38、try \{\}里有一个return 语句，那么紧跟在这个 try后的 finally \{\}里的 code 会不会被执行，什么时候被执行，在 return 前还是后?

39、下面的程序代码输出的结果是多少？

40、final, finally, finalize 的区别。

--------------------

### 31、String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？  ###

没有。因为 String 被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在 这段代码中，s 原先指向一个 String 对象，内容是 "Hello"，然后我们对 s 进行了+操作，那 么 s 所指向的那个对象是否发生了改变呢？答案是没有。这时，s 不指向原来那个对象了， 而指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只 是 s 这个引用变量不再指向它了。   
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或 者说，不可预见的修改，那么使用 String 来代表字符串的话会引起很大的内存开销。因为 String 对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个 String 对象来 表示。

这时，应该考虑使用 StringBuffer类，它允许修改，而不是每个不同的字符串都要生 成一个新的对象。并且，这两种类的对象转换十分容易。

同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都 new 一个 String。例 如我们要在构造器中对一个名叫 s 的 String 引用变量进行初始化，把它设置为初始值，应当这样做：

public class Demo { 
        private String s; 
        ... 
        public Demo { 
            s = "Initial Value"; 
        } 
        ... 
    } 
    
    而非 
    s = new String("Initial Value");

后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为 String 对象不可改变，所以对于内容相同的字符串，只要一个 String 对象来表示就可以了。也就 说，多次调用上面的构造器创建多个对象，他们的 String 类型属性 s 都指向同一个对象。 上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java 认为它们代表同 一个 String 对象。而用关键字 new 调用构造器，总是会创建一个新的对象，无论内容是否 相同。

至于为什么要把 String 类设计成不可变类，是它的用途决定的。其实不只 String，很多 Java 标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的 状态都要一个对象来代表，可能会造成性能上的问题。所以 Java 标准类库还提供了一个可 变版本，即 StringBuffer。

###    32、是否可以继承 String 类?  ###

String 类是 final 类故不可以继承。

### 33、String s = new String("xyz");创建了几个 String Object?二者之间有什么 区别？  ###

两个或一个，

”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多 少遍，都是缓冲区中的那一个。

New String 每写一遍，就创建一个新的对象，它一句那个 常量”xyz”对象的内容来创建出一个新 String 对象。

如果以前就用过’xyz’，这句代表就不会 创建”xyz”自己了，直接从缓冲区拿。

###    34、String 和 StringBuffer 的区别  ###

JAVA 平台提供了两个类：String 和 StringBuffer，它们可以储存和操作字符串，即包含多个 字符的字符数据。

这个 String 类提供了数值不可改变的字符串。

而这个 StringBuffer 类提供 的字符串进行修改。当你知道字符数据要改变的时候你就可以使用 StringBuffer。

典型地， 你可以使用 StringBuffers 来动态构造字符数据。

另外，String 实现了 equals 方法，new String(“abc”).equals(newString(“abc”)的结果为true,而StringBuffer没有实现equals方法， 所以，new StringBuffer(“abc”).equals(newStringBuffer(“abc”)的结果为 false。

接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。

StringBuffer sbf = new StringBuffer();  
    for(int i=0;i<100;i++) {        
        sbf.append(i); 
    }

上面的代码效率很高，因为只创建了一个 StringBuffer 对象，而下面的代码效率很低，因为 创建了101个对象。

String str = new String();  
    for(int i=0;i<100;i++) {        
        str = str + i; 
    }

在讲两者区别时，应把循环的次数搞成10000，然后用 endTime-beginTime 来比较两者执 行的时间差异，

StringBuilder与 StringBuffer 的区别。

*  StringBuilder是线程非安全的，

String 覆盖了 equals 方法和 hashCode 方法，而 StringBuffer没有覆盖 equals 方法和 hashCode 方法，所以，将 StringBuffer对象存储进 Java集合类中时会出现问题。

### 35、如何把一段逗号分割的字符串转换成一个数组?  ###

我可以说说我的思路：

1 用正则表达式，代码大概为：String \[\] result = orgStr.split(“,”);

2 用 StingTokenizer ,代码为：StringTokenizer  tokener = StringTokenizer(orgStr,”,”);   
String \[\] result =new String\[tokener .countTokens()\];

Int i=0;

while(tokener.hasNext()\{result\[i++\]=toker.nextToken();\}

### 36、数组有没有 length()这个方法? String有没有 length()这个方法？  ###

数组没有 length()这个方法，有 length 的属性。String 有有 length()这个方法。

### 37、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";  ###

String s1 = "a"; 
    String s2 = s1 + "b"; 
    String s3 = "a" + "b"; 
    System.out.println(s2 == "ab"); 
    System.out.println(s3 == "ab");

*  第一条语句打印的结果为 false，
 *  第二条语句打印的结果为 true，

这说明 javac 编译可以对 字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编 译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。

题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，

所以，上面的代码应该只创建了一个 String 对象。

写如下两行代码，

String s ="a" + "b" + "c" + "d";           
    System.out.println(s== "abcd");

最终打印的结果应该为 true。

### 38、try \{\}里有一个return 语句，那么紧跟在这个 try后的 finally \{\}里的 code 会不会被执行，什么时候被执行，在 return 前还是后?  ###

1.  不管有没有异常，finally中的代码都会执行
2.  当try、catch中有return时，finally中的代码依然会继续执行
3.  finally是在return后面的表达式运算之后执行的，此时并没有返回运算之后的值，而是把值保存起来，不管finally对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算之前就确定了的。
4.  如果return的数据是引用数据类型，而在finally中对该引用数据类型的属性值的改变起作用，try中的return语句返回的就是在finally中改变后的该属性的值。
5.  finally代码中最好不要包含return，程序会提前退出，也就是说返回的值不是try或catch中的值

先执行try中的语句，包括return后面的表达式，  
有异常时,先执行catch中的语句，包括return后面的表达式,  
然后执行finally中的语句,如果finally里面有return语句，会提前退出，  
最后执行try中的return，有异常时执行catch中的return。  
在执行try、catch中的return之前一定会执行finally中的代码（如果finally存在），如果finally中有return语句，就会直接执行finally中的return方法，所以finally中的return语句一定会被执行的。编译器把finally中的return语句标识为一个warning.  
  
参考：https://blog.csdn.net/xiangyuenacha/article/details/84234797

public static void main(String[] args) {
    //		System.out.println("return的返回值：" + test());
    //		System.out.println("包含异常return的返回值：" + testWithException());
    		System.out.println("return的返回值：" + testWithObject().age); // 测试返回值类型是对象时
    	}
    
    	// finally是在return后面的表达式运算之后执行的，此时并没有返回运算之后的值
    	// ，而是把值保存起来，不管finally对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。
    	// 也就是说方法的返回值是在finally运算之前就确定了的。
    	static int test() {
    		int x = 1;
    		try {
    			return x++;
    		} catch (Exception e) {
    
    		} finally {
    			System.out.println("finally:" + x);
    			++x;
    			System.out.println("++x:" + x);
    			// finally代码中最好不要包含return，程序会提前退出，
    			// 也就是说返回的值不是try或catch中的值
    			// return x;
    		}
    		return x;
    	}
    
    	static int testWithException() {
    		Integer x = null;
    		try {
    			x.intValue(); // 造个空指针异常
    			return x++;
    		} catch (Exception e) {
    			System.out.println("catch:" + x);
    			x = 1;
    			return x; // 返回1
    //			return ++x; // 返回2
    		} finally {
    			x = 1;
    			System.out.println("finally:" + x);
    			++x;
    			System.out.println("++x:" + x);
    			// finally代码中最好不要包含return，程序会提前退出，
    			// 也就是说返回的值不是try或catch中的值
    //			 return x;
    		}
    	}
    
    	static Num testWithObject() {
    		Num num = new Num();
    		try {
    			return num;
    		} catch (Exception e) {
    
    		} finally {
    			num.age++; // 改变了引用对象的值
    			System.out.println("finally:" + num.age);
    		}
    		return num;
    	}
    
    	static class Num {
    		public int age;
    	}

也许你的答案是在 return 之前，但往更细地说，我的答案是在 return 中间执行。

### 39、下面的程序代码输出的结果是多少？ ###

public class  smallT {        
        public static void  main(String args[]){ 
            smallT  t  = new smallT();              
            int  b =  t.get();              
            System.out.println(b);       
        }               
        public int  get(){               
            try{                      
                Return  1 ;               
            }finally{                      
                Return  2 ;  
            }        
        } 
    }

返回的结果是2。   
我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现， try中的 return 语句调用的函数先于 finally中调用的函数执行，也就是说 return语句先执行， finally 语句后执行，所以，返回的结果是2。Return 并不是让函数马上返回，而是 return 语 句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行 finally语 句后才真正开始返回。 在讲解答案时可以用下面的程序来帮助分析：

public classTest {
    
        public static voidmain(String[] args) {
            System.out.println(newTest().test());;
        }
        int test(){
            try{
                return func1();
            }finally{
                return func2();
            }
        }
        int func1(){
            System.out.println("func1");
            return 1;
        }
        int func2(){
            System.out.println("func2");
            return 2;
        }
    }
    -----------执行结果-----------------
    func1
    func2

结论：finally中的代码比 return 和 break 语句后执行

### 40、final, finally, finalize 的区别。 ###

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

内部类要访问局部变量，局部变量必须定义成 final 类型，例如，一段代码……

finally 是异常处理语句结构的一部分，表示总是执行。

finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM 不保证此方法总被 调用