企业面试笔试题总汇v1.6.docx
企业面试笔试题总汇v1.6.docx
企业面试题总汇(13-51)
Java基础部分
1、 请列举至少 3 个 JDK 安装目录下的可执行程序(javac)，并列举几个常用的命令行参
数
1、 javac 将 Java 源
代码换成字节代
javac <选项><源文件> 可能的选项包括：
-g 生成所有调试信息
-g:none 生成无调试信息
-g:{lines,vars,source} 生成只有部分调试信息
-O 优化；可能妨碍调试或者增大类文件
-nowarn 生成无警告
-verbose 输出关于编译器正在做的信息
-deprecation 输出使用了不鼓励使用的API的源程序位置
-classpath <路径> 指定用户类文件的位置
-sourcepath <路径> 指定输入源文件的位置
-bootclasspath <路径> 覆盖自举类文件的位置
-extdirs <目录(多个)> 覆盖安装的扩展类的位置
-d <目录> 指定输出类文件的位置
用法：
2.jar 打架包，查看
jar包
jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...选
项：
-c 创建新的存档
-t 列出存档内容的列表
-x 展开存档中的命名的（或所有的）文件
-u 更新已存在的存档
-v 生成详细输出到标准输出上
-f 指定存档文件名
-m 包含来自标明文件的标明信息
-0 只存储方式；未用ZIP压缩格式
-M 不产生所有项的清单（manifest）文件
-i 为指定的jar文件产生索引信息
用法：
3.javadoc：根据 Java
源代码及其说明语句
生成的HTML文档
javadoc [options] [packagenames] [sourcefiles] [classnames]
[@files] -overview<file>读取 HTML 格式的概述文档
-public 仅显示 public 类和成员
-protected 显示 protected/public 类和成员（缺省）
-package 显示 package/protected/public 类和成员
-private 显示所有类和成员
-help 显示命令行选项
-doclet <class> 通过候选 doclet 生成输出
-docletpath <path> 指定 doclet 类文件的查找位置
-sourcepath <pathlist> 指定源文件的查找位置
-classpath <pathlist> 指定用户类文件的查找位置
用法：
4.javah：产生可以调
用 Java 过程的 C 过程，
或建立能被 Java 程序
调用的 C 过程的头文
件
javah [options] <classes> 其中 [options] 包括：
-help 打印该帮助信息 -classpath <path> 类的加载路径
-bootclasspath <path> 自举类的加载路径
-d <dir> 输出目录
-o <file> 输出文件（仅能使用 -d 或 -o 之一）
-jni 生成 JNI 风格的头文件（缺省）
-old 生成 JDK1.0 风格的头文件
-stubs 生成 stubs 文件
-version 打印版本信息
-verbose 输出有关本命令所做工作的信息
-force 始终写输出文件
用法：
2、 请分析命题：“Java 采用自动垃圾回收技术（GC），因此不会出现内存泄露”
对象的建立和放置都是在内存堆栈上面进行的。程序或者其他的对象可以锁定一
块堆栈地址来进行其他对象的引用。
当一个对象没有任何引用的时候，Java 的自动垃圾回收机制就发挥作用，自动
删除这个对象所占用的空间，释放内存以避免内存泄漏。但是内存泄漏并不是就此而完全避免了，当程序
员疏忽大意地忘记解除一个对象不应该有的引用的时候，内存泄漏仍然不可避免，不过发生的几率要比不
启用垃圾回收机制的 C++程序少很多。但总体来讲，自动垃圾回收机制要安全和简单许多。
3、 简单描述单子模式(单例模式)的各种不同实现方式，极其各自优缺点。请列举至少 2
种其他的设计模式及应用场景。
1、 /*单例设计模式主要有 2种实现方式：懒汉式、饿汉式。
2、他们分别有如下实现：
3、饿汉式：
4、 //饿汉式单例类.在类初始化时，已经自行实例化 */
5、 public class Singleton1 {
6、 //私有的默认构造子
7、 private Singleton1() {}
8、 //已经自行实例化
9、 private static final Singleton1 single = new Singleton1();
10、 //静态工厂方法
11、 public static Singleton1 getInstance() {
12、 return single;
13、 }
14、 }
15、 懒汉式：
16、 //懒汉式单例类.在第一次调用的时候实例化
17、 public class Singleton2 {
18、 //私有的默认构造子
19、 private Singleton2() {}
20、 //注意，这里没有 final
21、 private static Singleton2 single=null;
22、 //静态工厂方法
23、 public synchronized static Singleton2 getInstance() {
24、 if (single == null) {
25、 single = new Singleton2();
26、 }
27、 return single;
28、 }
29、 }
30、 /*其他设计模式：
31、 1.适配器模式
32、 应用场景：比如说在朋友聚会上遇到一个德国人 sarsh，可以我不会德语，她不会中文，我只
好求助于我的朋友 mary了，他作为我和 sarsh之间的 adapt，让我和 sarsh可以交流了。
33、 2.装饰模式
34、 应用场景：想要自己做礼物送给朋友，拿出去年在华山顶上的照片，在背面写上“最好的礼
物”再到街上礼品店买个相框，在找隔壁学美术的朋友设计一个漂亮的盒子装起来，我们都是
Decorator。*/
4、 输出结果
1. public static void main(String[] args)throws Exception{
2. String str = "中国";
3. System.out.println(str.getBytes("UTF-8").length);
4. System.out.println(str.getBytes("GBK").length);
5. System.out.println(str.getBytes("ISO-8859-1").length);
6. System.out.println(new String(str.getBytes("ISO-8859-1"),("ISO-8859-
1"));
7. System.out.println(new String(str.getBytes("UTF-8"),("UTF-8"));
8. System.out.println(new String(str.getBytes("GBK"),("GBK"));
9. }
10. 输出结果：
11. 6
12. 4
13. 2
14. ??
15. 中国
16. 中国
5、 使用二分查找法找字符串数组{"a","b","c","d","e","f","g","h"}中"g"元素
5、 public class Query4Half {
6、 static int bsearch( String[] a, String v ) {
7、 int l, r;
8、 l = 0; r = a.length-1;
9、 while ( l <= r ) {
10、 int m = (l+r)/2;
11、 if ( a[m].compareTo(v)==0 ) return m; else
12、 if ( a[m].compareTo(v)>0 ) r = m-1; else
13、 if ( a[m].compareTo(v)<0 ) l = m+1;
14、 }
15、 return -1;
16、 }
17、 public static void main(String[] args) {
18、 String str[] = {"a","b","c","d","e","f","g","h"};
19、 int bsearch = bsearch(str, "g");
20、 System.out.println(bsearch);
21、 }
6、 Java 代码实现一个链表结构
6、 public class MyList<AnyType> {
7、 private class Node<AnyType>{
8、 public Node<AnyType> pre;
9、 public Node<AnyType> next;
10、 public AnyType data;
11、 public Node(AnyType d, Node<AnyType>p, Node<AnyType> n){}
12、 public Node(){}
13、 }
14、 private int theSize;
15、 private Node<AnyType> Header;
16、 private Node<AnyType> Tail;
17、 public MyList(){}
18、 public void add(AnyType item){}
19、 public boolean isEmpty(){}
20、 public int size(){}
21、 public AnyType get( int idx){}
22、 public void print(){}
23、 }
24、 /*Node<AnyType>类定义了双向链表中节点的结构，它是一个私有类，而其属性和构造函数都
是公有的，这样，其父类可以直接访问其属性，而外部类根本不知道 Node类的存在。Data是节点
中的数据与，pre指向前一个 Node节点，next指向后一个 Node节点。其构造函数的实现如下，
不解释：
25、 View Code*/
26、 public Node(AnyType d, Node<AnyType>p, Node<AnyType> n){
27、 this.data = d;
28、 this.pre = p;
29、 this.next = n;
30、 }
31、 public Node(){
32、 this.data = null;
33、 this.pre = null;
34、 this.next = null;
35、 }
36、 /*下面我们看一下链表的构造函数实现：
37、 View Code*/
38、 public MyList(){
39、 theSize = 0;
40、 Header = new Node<AnyType>(null,null,null);
41、 Tail = new Node<AnyType>(null,Header,null);
42、 Header.next = Tail;
43、 }
44、 /*我们构造了一个带有头、尾节点的双向链表，头节点的 Next指向尾节点，为节点的 pre指
向头节点。链表长度起始为 0。
45、 继续贴上链表类其它方法的实现，不解释了，应该比较清楚：*/
46、 //View Code
47、 public void add(AnyType item){
48、 Node<AnyType> aNode = new Node<AnyType>(item,null,null);
49、 Tail.pre.next = aNode;
50、 aNode.pre = Tail.pre;
51、 aNode.next = Tail;
52、 Tail.pre = aNode;
53、 theSize++;
54、 }
55、 public boolean isEmpty(){
56、 return ( theSize == 0);
57、 }
58、 public int size(){
59、 return theSize;
60、 }
61、 public AnyType get( int idx){
62、 if(idx > theSize-1 || idx < 0)
63、 throw new IndexOutOfBoundsException();
64、 Node<AnyType> current = new Node<AnyType>(null,Header,null);
65、 for(int i = 0; i<idx; i++)
66、 current = current.next;
67、 return current.data;
68、 }
69、 public void print(){
70、 Node<AnyType> current = Header.next;
71、 while(current.next != null){
72、 //如果 AnyType是你自己定义 //的数据类型，那么请务必提供
73、 //一个 toString方法，要么就不
74、 //要在链表里实现 print方法。
75、 System.out.println(current.data.toString());
76、 current = current.next;
77、 }
78、 }
...
