面试Android工程师遇到的面试题

以你之姓@ 2022-08-05 16:23 284阅读 0赞

一：选择题【有四个选项，只有一个选项正确，每道题1.5分，共20道，总计30分】

1：下面的表达式错误的是

A: **float** f=(1.9 + 0.1)/(**int**)1.0

B: **float** f=1.0F

C: **float** f=(**float**)1.0F

D: **float** f=(**int**)(0.73+0.27);

解答：【A】因为小数默认是double类型的，那么float f = (1.9+0.1)/(int)1.0则是double类型的，修改为float f = (1.9f+0.1f)/(int)1.0才正确.

2：设x和y均为**int**型变量,则以下语句:x+=y,y=x-y;x-=y;的功能是

A：把x和y按从大到小排列

B：把x和y按从小到大排列

C：无确定结果

D：交换x和y中的值

解答：【D】直接带两个数字进去进行试验即可

3：请写出下面程序运行的结果（）

**int** x = 0;

**int** y = 1;

**int** a = x++ + ++x;

**int** b = y– – –y;

System.out.println(++a + b++);

A：3 B：4 C：5 D：6

解答：【B】放到程序里运行一次就OK了，结果是4 ；**int** a = x++ + ++x;后a = 2;

**int** b = y– – –y;后b = 0; ++符号在参数之前的是先加了再计算使用，符号在后面的是计算过后再加。

4：选择下列程序运行的结果

**int** total = 0;

**for** (**int** i = 0, j = 5; total < 10 || j > 3; ++i, –j) \{

total += (i + j);

System.out.println(total );

A：结果为 5 ，因为一个i自加，一个j自减抵消等于没有自加

B：结果为 10，因为正常运算了

C：有语法错误，不能写多个变量

D：有语法错误，条件表达式不能写多个

解答：【D】条件表达式不能写多个，-j处会报错。

5:请问总共创建了多少个对象？

String aa,b,c;

aa=”bb”;

b=”dd”+aa;

c=”cc”+b+aa;

StringBuffer d = **new** StringBuffer(c);

A: 4 B: 5 C: 7 D: 8

解答：【C】这种问题真够纠结的！！答案我也做不对！（有其他解可以一起讨论）

“bb”创建字符对象 aa创建了引用对象

“dd”创建字符对象 b创建了引用对象

“cc”创建字符对象 c创建了引用对象

加上StringBuffer 对象

6:接口A中有2个方法，接口B中有2个方法，以下正确的是 ( )

A:若接口C继承A,B两个接口，则C一定继承了四个方法

B:若类C实现接口A,B，则C中必须至少实现A、B中各一个方法

C:若类C要继承接口A,B，则必须要定义接口D来继承接口A、B，由类C实现接口D,才能达到目的

D:若抽象的接口C继承了接口A，B；抽象的D类实现C接口，此时必须要实现累加接口中的所有方法

解答：【 】

7：关于类，抽象，接口，继承综合说法错误的是？

A:类与类之间有关联，继承，聚合的关系；

B:抽象类可以继承实例类，抽象类可以实现接口，抽象接口可以继承多个接口

C:抽象类是类和接口的并集与接口继承的补集

D:在应用开发中，功能类的继承是平行结构，实现功能的接口是树型结构

解答：【 】

8:请判断下面程序运行的结果：

public class ParamTest{
    	int num = 1;
    	
    	public void change() {
    	    num = 2;
    	}
    	
    	public void change(int num) {
    	    num = 3;
    	}
    	
    	public void change(ParamTest pt) {
    	    pt.num = 4;
    	}
    	
    	public static void main(String[] args) {
    	 
    		ParamTest pt = new ParamTest();
    		int num = 5;
    		pt.change();
    		System.out.println("1->:" + pt.num);
    		pt.change(num);
    		System.out.println("2->:" + pt.num);
    		pt.change(pt);
    		System.out.println("3->:" + pt.num);
    	}
    }

A: B: C： D：

1->:1 1->:2 1->:2 1->:2

2->:5 2->:5 2->:2 2->:5

3->:4 2->:5 3->:4 3->:4

解答：【C】，该题考查的主要目的是变量的作用域，pt.num 和在主函数中的num不是同一个对象。所以这点要区分清楚。pt.num一直是指ParamTest类中的num的值，一直关注这个值得变化即可得到答案。

9：下面方法不可以共存的是：（）

已知：

class A {
    	public A() {
    		
    	}
    	public void A() {
    		
    	}
    	public void A(int x) {
    		
    	}
    }
    
    class B extends A {
        //填入一个方法
    }

A：public void A()\{\}  
B：public voidA(int x, int y) \{\}  
C：public intA(int x, char y) \{  
return x + y;  
\}  
D：public String A(int x)\{  
return “hello”+x;  
\}

解答： 选D，因为B是继承的父类A，那么A选项是覆盖原来方法，B,C是子类自己新增的方法，D选项错误的原因是，没有办法区分和父类的方法。因为名称和传入的参数都一样，在调用的时候无法区分，不能靠返回值来区别。

10、运行下面程序段：

public class Foo {
    	int value;
    	
    	Foo(int value) {
    		this.value = value;
    	}
    }
    
    Foo[] a1 = { new Foo(1), new Foo(2), newFoo(3) };
    Foo[] a2 = new Foo[a1.length];
    System.arraycopy(a1, 0, a2, 0, a1.length);
    System.out.println((a1 == a2) + "," + (a1[1] == a2[1]));

控制台输出的结果是( )。  
A. **false,false** B. **false,true** C.  **true,true** D. **true,false**

**解答：答案为B，首先要理解System.arraycopy函数的作用，建议参考JDK详细的看一看。这里就简单解释一下，这个函数就是将一个数组赋值到另外一个数组，从0号位置开始，a1.length位置结束。其实这里就是价格a2数组的内容对应复制给a1，好了那么来看看打印，a1==a2，必然是false，因为是两个不同的对象，虽然数组内容是一样的，但是是两个完全不一样的对象，在内存中是两个不同的地址,所以为false.而a1\[1\]==a2\[1\]，因为刚才复制了，他们指向的是同一个值，他们的值是一样的，所以为true。**

11：哪种说话阐明了垃圾收集和终结化机制锁承诺的行为？（）  
A 对象直到没有任何引用指向自己时才会立即被销毁  
B 对一个对象调用的finalize()方法永远不会多于一次  
C 适用于收集的对象会最终由垃圾收集器销毁  
D 对象一但适用于垃圾收集，就再无法由存活线程访问了

解答：这个不晓得

12：下面执行的结果是

static boolean loop(char c) {
    	System.out.print(c);
    	return true;
    }
    public static void main(String[] args) {
    	int i = 0;
    	for (loop('A'); loop('B') && (i < 2); loop('C')) {
    	i++;
    	loop('D');
    }

A. ABDCBDCB

B. ABCDABCD

C. Compilation fails\[编译失败\].

D. An exception is thrown at runtime\[抛出一个运行例外\].

解答：A，运行一遍出结果。主要是了解for循环内的执行顺序即可。

13：下面异常执行的结果是：

try {
    	int x = 0;
    	float y = 0;
    	float z = x / y;
    	System.out.println("11");
    	try {
    		int a[] = new int[3];
    		a[3] = x;
    		System.out.println("22");
    		return;
    	} catch (Exception e) {
    		System.out.println("33");
    		return;
    	} finally {
    		System.out.println("44");
    		System.exit(0);
    		return;
    	}
    } catch (ArithmeticException e) {
    	System.out.println("55");
    	return;
    } finally {
    	System.out.println("66");
    	return;
    }

A: B： C： D：

11 55 11 11

55 66 33 33

66 44 44

解答：答案选C，**int** a\[\] = **new int**\[3\]; a\[3\] = x;这句话就会抛出异常，因为a\[3\]根本就不存在，已经数组越界了。所以打印了11后会到异常打印出33，然后finally是必然会执行的，然后打印44，return，然后结束。

14：阅读下面程序段:  
**byte** a\[\] = \{ ‘a’, 65, ‘\#’, ‘B’ \};

**byte** b\[\] = **new** byte\[a.length\];

System.arraycopy(a, 1, b, 1, 2);

BufferedOutputStream bos;

bos = **new** BufferedOutputStream(**new** FileOutputStream(“C:\\\\file.txt”));

bos.write(b, 1, 2);

bos.flush();

bos.close();

假设file.txt原先不存在，运行该程序段后，文件file.txt的内容为（）。

A. 65 B. 65\# C. A\# D. A

解答：答案为C，很容易选择为B，因为执行了System.arraycopy(a, 1, b, 1, 2);后b\[\] = \{0,65,’\#’,0\},利用系统System打印出来的为其ASCII码，但是写入到文本中的时候则为该ASCII码对应的字符。所以65就被转换成A打印出来了。

15：假设以数组A\[n\]存放循环队列的元素，其头、尾指针分别为head和end。若设定尾指针指向队列中的队尾元素，头指针指向队列中队头元素的前一个位置，则当前存于队列中的元素个数为

A：(end-head-1)%n B：(end-head)%n  
C：(head-end+1)%n D：(end-head+n)%n

解析：我估计选A，但不确保正确

16：对线性链表和线性表分析错误的是（）

A：线性链表分为单链表、双向链表和循环链表

B：线性链表是一种物理存储单元上连续但非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接来实现的

C：线性表插入或删除的运算效率很低。在顺序存储的线性表中，插入或删除数据元素时需要移动大量的数据元素

D：线性表的顺序存储结构不便于对存储空间的动态分配

解析：【B】线性链表是一种物理存储单元上连续，这句话是错误，线性链表是物理存储上是不连续的，但在逻辑结构上是连续的。

17：以下属于java.util包中集合类具体实现类的是？  
A：Map B：Collection C：TreeMap D：SortedMap

解析：答案为C,TreeMap和HashSet是具体的实现类。需要记忆

18：下面对集合不能正确创建实例化是（）

A：List<HashMap<Number, String>> list = new LinkedList<HashMap<Number, String>>();

B：ArrayList<HashSet<String>> list = new ArrayList<HashSet<String>>();

C：TreeSet<Hashtable<String,Integer>> tree=new TreeSet<Hashtable<String,Integer>>();

D：TreeSet<ArrayList<String,Integer>> tree=new TreeSet<ArrayList<String,Integer>>();

解析：答案是D，ArrayList的参数没有这种形式的，一般ArraList的参数是一个对象或者是自己增加的一个类或者类型。这个涉及到泛型的相关知识。

19：下面可以删除list中所有的“java”的代码是：  
ArrayList list = **new** ArrayList();  
list.add(“java”);  
list.add(“aaa”);  
list.add(“java”);  
list.add(“java”);  
list.add(“bbb”);

A：

**for** (**int** i = list.size() – 1; i >= 0; i–) \{

**if** (“java”.equals(list.get(i))) \{

list.remove(i);

B：

**for** (**int** i = 0; i < list.size(); i++) \{

**if** (“java”.equals(list.get(i))) \{

list.remove(i);

C：

Iterator i = list.iterator();

**while** (i.hasNext()) \{

**if** ((i.next().toString()).equals(“java”)) \{

i.removeAll();

D：

Iterator i = list.listIterator();

**while** (i.hasNext()) \{

**if** (((String) i.next()).equals(“Java”))

i.remove();

解析：经过试验ABD,都能够成功的删除java，只有C不可以，原因是Iterator没有removAll方法只有remove方法。

20：题示代码的功能为：将两个有序的ArrayList合并为一个有序的ArrayList。  
对于两个存放Integer对象的ArrayList，  
内容分别为：list1：\{1,3,4,6,8\} 和 list2：\{2,5,9\}  
合并后的list3: \{1,2,3,4,5,6,8,9\}

……  
List<Integer> list3 = **new** ArrayList<Integer>();  
**int** size = list1.size() + list2.size();

**for** (**int** i = 0, j = 0, k = 0; k < size; k++) \{  
< 填入的代码 >  
\}  
System.out.println(list3);  
……

完成该功能应该填入的代码是( )。

A.  
**if** (j >= list2.size() || i > list1.size():&& list1.get(i) < list2.get(j)) \{  
list3.add(list1.get(i++));  
\} **else** \{  
list3.add(list2.get(j++));  
\}  
B.  
**if** (j >= list2.size() || i < list1.size()&& list1.get(i) < list2.get(j)) \{  
list3.add(list1.get(i++));  
\} **else** \{  
list3.add(list2.get(j++));  
\}  
C.  
**if** (j >= list2.size() || i < list1.size()&& list1.get(i) > list2.get(j)) \{  
list3.add(list1.get(i++));  
\} **else** \{  
list3.add(list2.get(j++));  
\}  
D.  
**if** (j >= list2.size() || i < list1.size()|| list1.get(i) < list2.get(j)) \{  
list3.add(list1.get(i++));  
\} **else** \{  
list3.add(list2.get(j++));  
\}

二：简答题【本环节中每道题3分，共5道，总计15分】

1:String 和StringBuffer有什么差别？在什么情况下使用它们？【3分】

答：JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。

2：new一个类对象和使用类名创建一个对象有什么区别？二者使用时应该注意什么？【3分】

答：

存储空间上不同。  
new出来的在堆上  
直接定义的在栈上

当变量个数较少且数量确定时可以直接定义  
当数量较多或变量个数不能确定时用new

如果你有一个对话框类CMyDlg；  
你这样用：CMyDlg dlg;  
 dlg.Create();  
建一非模式对话框，函数一结束，dlg被收回了，这个对话框一闪而过。  
这样用： CMyDlg \*dlg=new CMyDlg;  
 dlg->Create();  
函数结束了，dlg还在。这个非模式对话框还在。

一个由c/C++编译的程序占用的内存分为以下几个部分 
    
    1、栈区（stack）―   由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 
    
    2、堆区（heap） ―   一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 
    
    3、全局区（静态区）（static）―，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    
    4、文字常量区  ―常量字符串就是放在这里的。 程序结束后由系统释放 
    
    5、程序代码区―存放函数体的二进制代码。

3：在异常当中 throw和throws 有什么区别和联系？【3分】

答：

仔细一看就知道了：
      public Test() throws RepletException {
        try {
          System.out.println("Test this Project!")
        }
        catch (Exception e) {
          throw new Exception(e.toString());
        }
      }
    
    throws是用来声明一个方法可能抛出的所有异常信息
    throw则是指抛出的一个具体的异常类型。
    通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个具体的异常信息。
    throws通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；
    throw则需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。

4：LinkList和ArrayList的区别？

如果是在集合的开头插入一个对象，使用哪种效率高些，在集合的末尾插入一个对象，使用哪种效率高些，为什么？【3分】

答：这个有点类似数组和链表的区别。List是借口，LinkList和ArrayList是实现类。ArrayList其实就是类似数组，元素的随机访问效率很高，缺点就是内存占用量较大，插入元素比较以及添加删除元素效率较低。而LinkList相反。在开头插入元素的话设计到，元素的移动，当然是用linklist效率会更好，因为链表不是顺序链接的。但是如果是在最末尾增加一个对象，那么是用ArrayList效率会高一些，因为不涉及移动元素的操作，它定位更加快速。

5：介绍JAVA开发中常用的Collection FrameWork(写出Java集合的框架结构,加上必要的名称注释)? 【3分】

答：　Collection  
　　├List接口  
　　│├LinkedList链表  
　　│├ArrayList动态数组  
　　│└Vector容器  
　　│　└Stack栈  
　　└Set  
　　Map  
　　├Hashtable  
　　├HashMap  
　　└WeakHashMap

三：改错与分析题【本环节中每道题3分，共7道，总计21分】

<第一题>

1.  **interface** A\{
2.  **int** x = 0;
3.  \}
4.  **class** B\{
5.  **int** x =1;
6.  \}
7.  **class** C **extends** B **implements** A \{
8.  **public void** pX()\{
9.  System.out.println(x);
10. \}
11. **public static void** main(String\[\] args) \{
12. **new** C().pX();
13. \}
14. \}

请问哪一行有错？为什么？【3分】

答：9行有错误，因为这里的X分不清楚到底是哪一个X，程序编译会报错，要明确是用哪一个，例如new B().x

< 第二题>

1.  **abstract class** Animal \{
2.  **public void** saySomething() \{
3.  System.out.println(“你想说什么就说吧！”);
4.  \}
5.  \}
6.  **class** Dog **extends** Animal \{
7.  **public void** saySomething() \{
8.  System.out.println(“我现在有了第二职业：捉耗”);
9.  \}
10. \}
11. **public class** Test \{
12. **public static void** main (String\[\] args) \{
13. Animal ani=new Dog();
14. ani.saySomething();
15. \}
16. \}

请问哪一行有错？为什么？【3分】

答：我将程序拷贝到eclipse里面反正没有错误，除了3行和8行的引号有问题以外，程序能正确的使出我现在有了第二职业：捉耗

<第三题>

**public class** Test \{

**private static void** printArray(**int**\[\] arr) \{

**for**(**int** i=0;i< arr.length;i++)

System.out.print(arr\[i\]+”,”);

System.out.println(” “);

**private static void** changeValue(**int** value) \{

value\*=2;

**private static void** changeValue(**int**\[\] arr) \{

**for**(**int** i=0;i<arr.length;i++)

arr\[i\]\*=2;

**public static void** main (String\[\] args) \{

**int**\[\] arr=\{1,2,3,4,5\};

changeValue(arr\[0\]);

printArray(arr);

changeValue(arr);

printArray(arr);

请问结果是什么?并详细解释原因【3分】

答：

1,2,3,4,5

2,4,6,8,10

这个主要是区分方法的重载，方法的重载主要是根据传递的参数不同来选择具体使用哪一个方法，第一个changeValue只是将数组中的第一个元素传递进去做了计算，但是并没有改变数组，以及数组中的元素，所以打印出来的就是1,2,4,5

第二个changeValue是将数组传递进去了，然后做了运算，所以值发生了改变。

<第四题>

**public class** A \{

**static** \{

System.out.println(“11″);

System.out.println(“22″);

**public** A() \{

System.out.println(“33″);

**public** void deal() \{

System.out.println(“44″);

**public class** B **extends** A \{

**static** \{

System.out.println(“55″);

System.out.println(“66″);

**public** B() \{

System.out.println(“77″);

**public void** deal() \{

System.out.println(“88″);

**public class** C \{

**public static void** main(String\[\] args) \{

A b=**new** B();

b.deal();

请问结果是什么？并详细分析原因【3分】

答：

java中的自由块分为静态的自由块和非静态的自由块，这两种的执行是有区别的：

非静态自由块的执行时间是：在执行构造函数之前。

静态自由块的执行时间是：class文件加载时执行。

这里父类中的deal（）方法是被覆盖了，所以是不会执行的

<第五题>

**public class** Test\{

**public static void so**(String\[\] name)\{

String temp=name\[0\];

Name\[0\]=name\[1\];

Name\[1\]=temp;

**public static void so**(String name0,String name1)\{

String temp=name0;

Name0=name1;

Name1=temp;’

**public static void main**(String\[\] wewe)\{

String\[\] name = **new** String\[\]\{“mike”,”Lily”\};

String name0 = “mike”;

String name1=”Lily“;

So(name);

System.out.println(name\[0\]+”,”+name\[1\]);

So(name0,name1);

System.out.println(name0+”,”+name1);

请输出结果？并详细解释为什么？【3分】

答：

Lily,mike

mike,Lily

首先我们看第一个so(name),传递进去的是一个字符串数组那么这个是整个数组被传递进去了，那么在so中的交换实际上也就是对这个数组中元素的交换。

第二个so(name0,name1)的话，就需要理解形参和实参的关系，形参是不可能改变实参的值得，而且形参的作用域也只有那一个函数而已，打印的name0，和name1并不受影响。

<第六题>

**public class** Person \{

**static class** User \{

**int** id;

String name;

**public** User(**int** id, String name) \{

**this**.id = id;

**this**.name = name;

**public int** getId() \{

**return this**.id;

**public** String getName() \{

**return this**.name;

**class** Student \{

**public void** setid(**int** newId) \{

id = newId;

**public void** setName(String newName) \{

name = newName;

**public void** print(**int** id, String name) \{

User user = new User(id, name);

System.out.println(user.getId() + “\\t” + user.getName());

**public static void** main(String\[\] args) \{

//…手写补充代码

要求：先对User进行创建实例化 学号为：1001 姓名为： 张三 之后进行修改 学号为： 1002 姓名为：李四 调用Person类的打印输出方法显示修改后的结果。【3分】

答： User zhang = **new** User(1001,"张三");

User.Student li = zhang.**new** Student();

li.setid(1002);

li.setName("李四");

**new** test1().print(zhang.getId(),zhang.getName());

输出的结果为 1002 李四

<第七题>

列举几个你常去的IT技术型的网站，类型不限，个数不限,写中文名亦可，并解释为什么值得你去？【3分】

答：CSDN ITEYE EOEANDROID

四：编程算法题，将代码下在每道题的下面\[共5道题，第一，二题为5分，第三题为6分，第四题为8分，第五题为10分，总计34分\]

1：请用递归算法写一个方法求出两个数字的最大公约数和最小公倍数【5分】

**publicclass** test1\{

//计算最大公约数使用的是欧几里德算法

**publicstaticint**gcd(**int** a,**int** b)\{

**if**(b==0)

**return** a;

**else**

**return***gcd*(b,a%b);

// 最小公倍数等于两个数的乘积除以最大公约数

**publicstaticint** gbs(**int** x,**int** y)\{

**return** x\*y/*gcd*(x,y);

**publicstaticvoid** main(String args\[\])\{

System.*out*.println(*gcd*(5,16));

System.*out*.println(*gbs*(6,9));

解析，这个题目是比较经典的，最主要的是计算最大公约数，这个就是经典的欧几里德算法，当计算得到了最大公约数后，最小公倍数就是两个数的乘积除以最大公约数

【安徽科大讯飞2012届武汉大学校园招聘试题】

2：请将一个链表反序【5分】

**publicclass** test1 \{

//假设链表的节点定义如下:

**class** Node \{

**int**i;

Node next;

//那么其反转函数为:

**void** reverse(Node l) \{

**if** (l ==**null**)

**return**;

Node p = **null**, q = l, r = l.next;

**while** (r !=**null**) \{

q.next = p;

p = q;

q = r;

r = r.next;

q.next = p;

l = q;

【华为2011届华中科技大学校园招聘试题】

3：现在有一个有趣的游戏：称为杀人游戏！游戏规则是：输入参加的总人数，在输入一个基数，然后每个人依次报数，

当前选手报的数能被基数整除的话，就判为死亡出局，剩下的再继续数数，当数到最后一个时候，再接着从1开始从头数数。。。

一直到活下的人小于基数为止，整个游戏结束，打印最后存活选手的编号；【6分】

例子：总数：6 基数 2

M M M M M M

1 2 3 4 5 6

M X M X M X

1 2 3 4 5 6

M M M

1 2 3

M X M

1 2

M X

存活的人数是：1

存活的编号是：1

【微软，中兴的笔试题，要求不限制语言编写实现】

4：比较两个字符串，要求从字符串的最后一个元素开始逐个向前比较，如果两个字符串的长度不等，则只比较短长度字符串的元素。请编程实现下面给出的比较方法，并返回比较中发现的不相等元素的个数。【8分】

**public int** getDiffNum(**int** len1, String str1,**int**len2, String str2)

例如：len1=3 str1=”acd” len2=5 str2=”zhacd” 函数返回为 0

len1=3 str1=”acd” len2=6 str2=”zhacdv” 函数返回为 3

【华为2012届南京大学校园招聘试题】

5:任何一个自然数m的立方均可写成m个连续奇数之和。【10分】

例如：  
1^3=1  
2^3=3+5  
3^3=7+9+11  
4^3=13+15+17+19  
请编程实现：输入一自然数n，求组成n^3的n个连续奇数，格式必须按照上面进行输出。

【浙江大学研究院2011年笔试题目】

面试Android工程师遇到的面试题

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关爬虫工程师面试题

相关 [Android面试题]--BAT三年面试集锦之Android面试(你一定会遇到)

相关 2015年TCL公司Android工程师面试题

相关移动开发工程师面试题集：Android & iOS

相关面试Android工程师遇到的面试题

相关 Android工程师面试题大全

相关近期面试中遇到的面试题

相关前端工程师面试题

相关今天遇到的面试题

相关 Python工程师面试题