java华为面试题 讨论

Question

1，给一个整数，如123，进行反转，即地位转高位，输出321。请写个函数 
2，选择题,如下程序，gc什么时候执行 
   public void tMethod() 
   { 
  1， String s = new String("abc"); 
  2,  String b = s; 
  3,  s = null; 
  4,  System.out.println(); 
   } 
  A,gc在3，之后执行 
  B,gc在4，之后执行 
  C,gc在函数体运行时间内不会执行

Answer 1

1,我大概这样写的，同志们有没有优化的写法阿，据说这样写性能不好，欢迎拍砖讨论
              public void reverseInt(int inta) 
{ char chrInta[] = String.valueOf(inta).toCharArray(); 
StringBuilder strbInta = new StringBuilder(""); 
int intb = 0; 
int intLength = chrInta.length; 
for(int i = intLength-1 ;i >-1; i-- ) 
{ 
strbInta.append(chrInta[i]); 
} if(strbInta.indexOf("-")==-1) 
{ 
intb = Integer.parseInt(strbInta.toString()); 
} 
else 
{ 
intb = -(Integer.valueOf(strbInta.substring(0, intLength-1)).intValue()); 
} 
System.out.println(intb); 
}
2,我选c 
觉得gc线程优先级很低，不会立即执行。 
还有就是原本s指向的那块内存被b指向了，应该没有什么垃圾可收集把

Answer 2

呵呵，不研究算法很久了，Java虽然不能操作内存地址，但是还是可以对整数进行有符号和无符号移位的
所以考虑性能的话应该直接对整数进行移位操作完成反转借助>>和>>>这两个操作符至于第2题的话：虚拟机内部对每个对象统一存在在堆区，然后引用是通过指针来指向堆区的对象的，只有当没有任何指针指向这个对象，垃圾收集线程一旦获得时间片就会回收这个对象的，所以这个题目似乎有些问题，如果没有引用指向"abc"对象，就会导致垃圾收集器回收它的，至少如果是我的话，我会去掉String b = c这一行，那么回收就会出现在s = null这个地方。这也告诉我们数据库Connection或者Socket这样的对象，不但要关闭，最好还加上一句connection=null和socket=null，这是良好的习惯，引用关系也不要乱传递。

Answer 3

to Ant_Yan:
String   b   =   s;   
所以已经有引用指向"abc" 了，所以应该没有垃圾可收了吧

Answer 4

十进制  ； 二进制
123; 00000000 01111011
321; 00000001 00100001用移位 操做符号 可以？？ 开玩笑的吧至于 gc 调用完全不是 程序调用 垃圾就会回收的 我觉得应该选c
System.gc();描叙：只能提示jvm尽可能快的回收 而不是马上回收

Answer 5

第一题
public int reverseInt(int value){
        int tmp=value;
        int m=0,q=0;
        int result=0;
        while(tmp!=0){
                m=tmp%10;
                tmp/=10;
                result*=10;
                result+=m;
        }
        return result;
}第二题
选C
gc在整个运行中都不会执行，除非你在程序中调用它，或者系统确实认为应该进行gc操作。以上为本人答案，仅供参考^^

Answer 6

其实第一题没有那么复杂，简单说说思路。首先获得这个int，然后藉由String转成char[]。之后再声明一个同样长度的char数组，将整个数组内容反向输入，然后通过一个StringBuffer来append完成一个新的String。
  public String reverse(int a){
char[] temp = String.valueOf(a).toCharArray();
int t = temp.length;
char[] temp2 = new char[t];
for (int j = 0;j < t;j++){
temp2[j] = temp[t - 1 - j];
}
return String.valueOf(temp2);
  }后面一个问题主要牵涉到了一个gc的执行机制，小生浅薄，在这里给大家简单说说gc的执行机制。首先gc是一个所谓的精灵函数，主要由JVM负责调用。gc的执行时机之所以大家觉得高深莫测，主要是因为gc的执行机制比较复杂的原因。首先内存被gc分为四块，成为supervisor1和supervisor2，称为s1和s2好了。还有就是young generation和old generation。声明内存的时候，首先放到s1中。s1满了以后自动将所有的内容复制到s2中，并将所有的新的声明要求放在s1中。当s1再次填满以后，gc将进行一次 次要垃圾收集。这个时候进行的工作主要是检测所有s1和s2中的变量是否存活，并将存活的内容丢到young generation中去，s1，s2清空。这时候gc依然“接受”声明请求。当s1，s2再次被填满以后，由于此时young generation中也已经填满内容，将进行一次 次主要垃圾收集，将所有存活的内容进行整理，放在old generation中。继续前述过程。如果四个都填满，那么gc只有进行主要垃圾收集。这应该就是大家平时所说的“垃圾收集”了，这个收集比较消耗时间。结合上述文字，可以看到，单一的将变量或某对象的实例置null不一定能触发垃圾收集器。根据你的题目来看，出题者的意思应该是考察变量的生命周期。如果给我选择，我会选择最后一项。因为只是这样的声明不会造成s1和s2的满载。但是这个题目本省存在一定问题，不够严谨。

Answer 7

可以用API写算法题？不是把，不然直接用String的reverse方法岂不更快

Answer 8

String有这个方法？至少我在我的JDK1.6里面没有查到。

Answer 9

刚才查了，是StringBuffer类的方法，谢谢。请严谨。

Answer 10

    public ConvertInt(int intdata) {
       char chardata[] = String.valueOf(intdata).toCharArray();
       int length = chardata.length;
       char reverchardata[] = new char[length];
       for(int i=0,j=0; i<length;i++){
           reverchardata[j] = chardata[length- i-1];
           j++;
       }
       String stringdata = String.copyValueOf(reverchardata);
       int reverint = Integer.parseInt(stringdata);
       System.out.println(chardata);
       System.out.println(length);
       System.out.println(reverchardata);
       System.out.println(reverint);
       
    }

Answer 11

第一个方法很多,我写的肯定没有那些高手写的性能那么好  
第二个肯定是在赋为null之后执行 所以选a

Answer 12

第二题理应先C的吧, 不会调用GC
很明显的亚, 程序        String s = new String("abc ");
        String b = s;
        s = null;只创建了一个string对象, s=null并不是destroy这个"sbc "的对象, 而是赋于为null的引用, b仍然指向"abc "对象, 打印看看, 就能证明了.        System.out.println("b = " + b);
        System.out.println("s = " + s);

Answer 13

 int ms=123;
        String st=Integer.toString(ms);
        StringBuilder sb=new StringBuilder(st);
        sb.reverse();
        System.out.println(sb);

Answer 14

15楼正解！第二题就选Ｃ
第一题代码
static void n(int x){
if (x ==0 ){
return ;
}else{
System.out.println(x % 10);
n(x/10);
}
}
public static void main(String[] args){
String[] str = {"1b","2a","3","4"};

// f(str.length - 1,str);
n(123456789);
}

Answer 15

  String s = new String("abc "); //创建了2个对象 
        String b = s;            // b被指向 s 
        s = null;                //s引用值被摧毁，应该被gc了吧 ，但是"abc"常量对象还是存在的

Answer 16

16楼好像没有考虑负数的情况
                int intb = 0;
StringBuilder strbInta = new StringBuilder(String.valueOf(inta));
strbInta = strbInta.reverse(); if (strbInta.indexOf("-") == -1)
{
intb = Integer.parseInt(strbInta.toString());
} else
{
intb = -(Integer.valueOf(strbInta.substring(0,
strbInta.length() - 1)).intValue());
}
System.out.println(intb);

Answer 17

第一题：public class Test {
/**
 * 将n反转 并返回反转后结果
 * @param n
 * @return
 */
public static int reverse(int n) {
StringBuffer sb = new StringBuffer();//创建空的StringBuffer
sb.append(n).reverse();//将n添加到sb，然后反转。。
return Integer.parseInt(sb.toString());
}

public static void main(String args[]) {
System.out.println(reverse(12345));
}
}
第二题：
C。

Answer 18

看了20楼的提醒了我，需考虑负数：
修改后的代码：：：
public class Test { /**
 * 将n反转 并返回反转后结果
 * 
 * @param n
 * @return
 */
public static int reverse(int n) {
int isNegative = 1;
if (n < 0) {
n = (-n);
isNegative = -1;
}
StringBuffer sb = new StringBuffer();// 创建空的StringBuffer
sb.append(n).reverse();// 将n添加到sb，然后反转。。
return isNegative * Integer.parseInt(sb.toString());
} public static void main(String args[]) {
System.out.println(reverse(654321));
System.out.println(reverse(-123456));
}
}

Answer 19

第一题：用C语言写的
#include <stdio.h>int fun(int n)
{
int num[100];
int i = 0;
int result = 0;
while (n != 0)
{
num[i++] = n % 10;
n /= 10;
}

for (int j = 0; j < i; ++j)
result = result * 10 + num[j];

return result;
}int main()
{
int n;
while (scanf("%d", &n) != -1)
{
printf("%d\n", fun(n));
}
return 0;
}第二题：选C，
因为b指向那块内存。

Answer 20

第一题不说撒,
第二题选b,(很多人都选c,都说15楼的说法对,???真的吗?).String s = new String("abc ");
这句话15楼的说法是创建了一个对象,是一个吗?
应该是创建了2个呀.
所以当这个函数结束后,执行gc.
选择b

Answer 21

1、String hh= new Integer(123).toString();
   StringBuilder sb = new StringBuilder(hh);
   String tt = sb.reverse().toString();
   int h = new Integer(tt).intValue();2、答案为C

Answer 22

第二题应该不确定，有可能根本就没有调用
java 在调用gc是自动的，不是在每一个实例空间引用都为空的时候。

Answer 23

应该是C,看这里:
http://www.5inet.net/Develop/Java/040632.html

Answer 24

Integer.parseInt(Integer(123).toString().reverse())

Answer 25

第一题：
int a=123;
String s=""+a;
StringBuffer sbuf=new StringBuffer(s);
sbuf=sbuf.reverse();
System.out.println(sbuf);
第二题：
          我认为是d;      解释：1.虽然s=null,但是b仍然指向abc，所以对象abc在堆中仍然存在。
             2.调用gc()是JVM的事，何时调用不会确定。即使你人工调用gc()，仍然不一定立即执行，只是提醒一下JVM而已。
 根据以上两种判断，无论考虑那种解释，都应该是d