常见的Java上机面试题

1、常见的Java上机面试题在程序员面试中，主要的考试形式分为笔试和上机编程考试两部分。笔试主要考查面试者的基础是否牢固；上机考试主要考查面试者的实际开发能力和技术技巧。上机编程考试，要求面试者能够根据题目的要求，使用一种编程工具，编写全部代码并调试运行。这主要是考查面试者代码书写和编程的熟练程度。值得注意的是，这类面试题要求能够正确运行，往往要求面试者使用比较原始的JDK编译方式也就是使用DOS命令提示符，而不是提供Eclipse或者JBuilder等快速开发环境。本章将经常出现的上机编程题进行分类，希望能够给读者带来帮助和启示。17.1  Java基础编程试题（1）在上机编程类的面试

2、题中，大部分涉及基础编程，例如算法、语法、常用的类等知识点。面试题1  怎样截取字符串考题题干编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"6，应该输出"我ABC"，而不是"我ABC+汉的半个"。试题分析本面试题容易产生困惑的是中文字符和英文字符，在这里需要考虑汉字和英文字符的占用字节数问题，中文字符占两个字节，英文字符占一个字节，理解了这个，就很容易完成本题了。参考

3、答案具体代码实现如下：1. package core_java;  2. import java.util.Scanner;  3. public class InterceptionStr   4.     static String ss;                  

4、    /要进行截取操作的字符串  5.     static int n;                          /截取的字符串的字节数  6.     public

5、 static void main(String args)   7.         System.out.println("请输入字符串：");  8.         Scanner scStr = new Scanner(System.in); /从键盘获取字符串  9. 

6、0;       ss = scStr.next();              /将Scanner对象中的内容以字符串的形式取出来  10.         System.out.println("请输入字节数：");  11.  

7、60;      Scanner scByte = new Scanner(System.in);/从键盘获取字符串  12.         n = scByte.nextInt();              /将Scanner对象中的内容以数值

8、的形式取出来  13.         Interception(setValue();         /方法与方法间的套用  14.       15.     public static String setValue()    /此方法的作用

9、是将字符串转换成字符串数组  16.         String string = new Stringss.length();/创建一个字符数组string  17.         for (int i = 0; i < string.length; i+)   18

10、.             stringi = ss.substring(i, i + 1);  19.                           &

11、#160;     /将字符串ss中的第i个字符取出，放入字符数组中string中  20.           21.         return string;                &

12、#160; /将这个字符数组返回  22.       23.     public static void Interception(String string)   24.         int count = 0;  25.       &#

13、160; String m = "u4e00-u9fa5"      /汉字的正则表达试  26.         System.out.println("以每" + n + "字节划分的字符串如下所示：");  27.       

14、60; for (int i = 0; i < string.length; i+)   28.             if (stringi.matches(m)   29.              

15、;                /将字符数组中的每一个元素与表则表达式进行匹配，如果相同则返回true  30.                 count = count + 2;    

16、;  /如果当前字符是汉字，计数器count就加2  31.              else   32.                 count = count + 1;   

17、60;  /如果当前字符不是汉字，计数器count就加1  33.               34.             if (count < n)          

18、0;     /如果当前计数器count的值小于n，则输出当前字符  35.                 System.out.print(stringi);  36.              else if (c

19、ount = n)         /如果当前计数器count的值等于n，则输出当前字符  37.                 System.out.print(stringi);  38.          

20、60;      count = 0;  39.                 System.out.println();      /内循环结果，则需要换行，起到控制打印格式的作用  40.        

21、      else   41.                 count = 0;/如果当前计数器count的值大于n，则计数器count清零，接着执行外部循环  42.              

22、;   System.out.println();  43.               44.           45.       46.  程序的输出结果如图17.1所示。 17.1  Java基础编程试题（2）面试题2  怎样实现元素互换考

23、题题干从键盘上输入10个整数，并将其放入一个一维数组中，然后将其前5个元素与后5个元素对换，即：第1个元素与第10个元素互换，第2个元素与第9个元素互换第5个元素与第6个元素互换。分别输出数组原来各元素的值和对换后各元素的值。试题分析由于本题的要求是实现头尾元素互换，所以可以釆用取利用临时变量的方法来进行元素交换。参考答案具体代码实现如下：1. package programe;  2.  3. import java.io.BufferedReader;  4. import java.io.IOException;  5

24、. import java.io.InputStreamReader;  6.  7. public class HuHuanDemo   8.     public static void main(String args)   9.         print();  10.  11.    &

25、#160;  12.  13.     public static int write()   14.         BufferedReader buf = new BufferedReader10;/* 申请缓冲数组 */ 15.         int

26、 n;/* 开关量 和 中间量 */ 16.         int array = new int10;  17.         for (int i = 0; i < 10; i+)/* 赋值 */ 18.

27、          19.             bufi = new BufferedReader(new InputStreamReader(System.in);  20.              &

28、#160;  /* 给每个缓冲区定义 */ 21.             do/* 判断是否是空串，如是则重新输入 */ 22.               23.         

29、60;       n = 1;  24.                 System.out.print("请输入第" + (i + 1) + "个整数:");  25.     

30、60;           try /* 建立一个异常捕获 */ 26.                   27.              

31、60;      arrayi = Integer.parseInt(bufi.readLine();/* 执行串变整数 */ 28.                     /*  29.        &#

32、160;             * Integer.parseInt(str) - str转成 int型 bufi.readLine() -  30.                     

33、60;* 从系统输入缓冲区读入字符流给buf缓冲区并返回字符串  31.                      */ 32.                  catch (N

34、umberFormatException e)/* 捕获异常 */ 33.                   34.                     System.out.prin

35、tln("数据输入错误请重新输入");/* 处理异常 */ 35.                     n = 0;  36.                

36、0; catch (IOException e)   37.                     e.printStackTrace();  38.                

37、60;  39.              while (n = 0);  40.           41.         return array;  42.  43.    

38、0;  44.  45.     public static void print()   46.         int ary = write();  47.         int s;  48.      

39、60;  System.out.println("n你输入的数组是:");  49.         for (int i = 0; i < 10; i+)/* 输出原数组 */ 50.           51.     

40、        System.out.print(aryi + " ");  52.           53.         for (int i = 0; i < 5; i+)/* 对换&

41、#160;*/ 54.           55.             s = aryi;  56.             aryi = ary9 - i;  57.

42、60;           ary9 - i = s;  58.           59.  60.         System.out.println("n对换后的数组是:");  61.    

43、;     for (int i = 0; i < 10; i+)/* 输出对换后数组 */ 62.           63.             System.out.print(aryi + &

44、quot; ");  64.           65.         System.out.println();  66.       67.  68.  69. 程序输出的结果如图17.2所示。17.1  Java基础编程试题（3）面试题3  怎样实现元素排序考题题干（1）用Java实现一种排

45、序。（2）Java类实现序列化的方法是什么？（3）在COLLECTION框架中，如果实现自然比较方法，则需要实现什么样的接口？试题分析排序是程序员经常遇到的，也是基本的技巧之一，一般的排序方法有插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。下面详细介绍3种排序方法。1冒泡排序（Bubble Sort）最简单的排序方法是冒泡排序法。这种方法的基本思想是，将待排序的元素看作是竖着排列的"气泡"，较小的元素比较轻，从而要往上浮。在冒泡排序算法中要对这个"气泡"序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个

46、序列，并时刻注意两个相邻元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即"轻"的元素在下面，就交换它们的位置。显然，处理一遍之后，"最轻"的元素就浮到了最高位置；处理两遍之后，"次轻"的元素就浮到了次高位置。在进行第二遍处理时，由于最高位置上的元素已是"最轻"元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排序。2选择排序（Selection Sort）选择排序的基本思想是，对待排序的记录序列进行n-1遍的处理，第1遍处理是将L1.n中最小者与L

47、1交换位置，第2遍处理是将L2.n中最小者与L2交换位置，第i遍处理是将Li.n中最小者与Li交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。当然，在实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。3插入排序（Insertion Sort）插入排序的基本思想是，经过i-1遍处理后，L1.i-1已排好序。第i遍处理仅将Li插入L1.i-1的适当位置，使得L1.i还是排好序的序列。要达到这个目的，可以用顺序比较的方法。首先比较Li和Li-1，如果Li-1Li，则L1.i已排好序，第i遍处理就结束了；否则交

48、换Li与Li-1的位置，继续比较Li-1和Li-2，直到找到某一个位置j（1ji-1），使得LjLj+1时为止。简言之，插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。参考答案（1）具体代码实现如下：1. package programe;  2. import java.util.*;  3. class InsertionSort   4.     ArrayList list;  5.   &#

49、160; / num指的是数据的个数，mod指的是可以产生随机数的范围在1mod之间  6.     public InsertionSort(int num, int mod)   7.         list = new ArrayList(num);  8.        

50、; Random dom = new Random();  9.         System.out.println("排序之前的数组:");  10.         for (int i = 0; i < num; i+)   11. &

51、#160;           list.add(new Integer(Math.abs(dom.nextInt() % mod + 1);  12.             System.out.println("list" + i + &quo

52、t;=" + list.get(i);  13.           14.       15.     public void SortIt()   16.         Integer tempInt;  17.  

53、0;      int MaxSize = 1;  18.         for (int i = 1; i < list.size(); i+)   19.             temp

54、Int = (Integer) list.remove(i);  20.             if (tempIValue() >= (Integer) list.get(MaxSize - 1)  21.            

55、0;        .intValue()   22.                 list.add(MaxSize, tempInt);  23.               

56、;  MaxSize+;  24.              else   25.                 for (int j = 0; j < MaxSize; 

57、j+)   26.                     if (Integer) list.get(j).intValue() >= tempInt  27.              &#

58、160;              .intValue()   28.                         list.add(j, tempInt);  29.

59、60;                       MaxSize+;  30.                        &

60、#160;break;  31.                       32.                   33.       

61、0;       34.           35.         System.out.println("排序之后的数组:");  36.         for (int i = 0; i &l

62、t; list.size(); i+)   37.             System.out.println("list" + i + "=" + list.get(i);  38.           39.   

63、    40.     public static void main(String args)   41.         InsertionSort is = new InsertionSort(10, 100);  42.         is

64、.SortIt();  43.       44.  程序的输出结果如图17.3所示。17.1  Java基础编程试题（4）面试题4  怎样实现Singleton模式编程考题题干请编写一个Singleton模式的程序。试题分析Singleton模式的主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收。一般Singleton模式通常的形

65、式为：定义一个类，它的构造函数为private的，它有一个static的private变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用，继而调用其中的方法。参考答案（两种实现方法，取一即可）1. package programe;  2.  3. public class Singleton   4.     private Singleton()   5.      

66、0;6.     / 注意这是private 只供内部调用  7.     private final static Singleton instance = new Singleton();  8.  9.     / 这里提供了一个供外部访问本class的静态方法，可以直接访问  10.     

67、;public static Singleton getInstance()   11.         return instance;  12.           13.      或者：1. package programe;  2.  3. public cl

68、ass Singleton   4.     private static Singleton instance = null;  5.  6.     public static synchronized Singleton getInstance()   7.         

69、;/ 使用时生成实例，提高了效率！  8.         if (instance = null)  9.             instance = new Singleton();  10.         re

70、turn instance;  11.       12.  面试题5  哥德巴赫猜想的近似证明考题题干哥德巴赫猜想是说任何一个大于2的偶数都能表示为两个素数之和。请编写一个Java程序，验证1100内哥德巴赫猜想的正确性，也就是近似证明哥德巴赫猜想。试题分析可以应用枚举的方法列出1100内的所有偶数。然后逐一验证每个偶数是否满足哥德巴赫猜想的论证。如果有一个不符合，就意味着哥德巴赫猜想不成立。一个正偶数m可以表示成m=1+(m-1)，m=2+(m-2)，m=3+(m-3)，m=m/2+m/2。由于m/2

71、的后半部分和前半部分的结果是一样的，只是加数顺序不同，所以可以忽略。参考答案具体代码实现如下：1. package programe;  2.  3. public class Guess   4.     public static void main(String args)   5.         System.out.println(&q

72、uot;在1100范围内，现在开始证实哥德巴赫猜想：");  6.         if (Testify_Guess(1, 100)   7.             System.out.println("在 1100范围内，哥德巴赫猜想是正确的。");  8.   

73、0;      else   9.             System.out.println("哥德巴赫猜想是错误的");  10.           11.  12.       13.  14. &#

74、160;   public static boolean Testify_Guess(int low, int high)       15. / 判断1100范围内的所有偶数是否符合哥德巴赫猜想，符合则返回true，反之则返回false  16.         int i, j = 0;  17

75、.         boolean flag = true;  18.         for (i = low; i <= high; i+)  19.             if 

76、;(i % 2 = 0 && i > 2)        /在1100之间选取大于2的偶数进行猜想测试  20.                 if (isGoldbach(i)   21.   

77、                  j+;                / j用来控制输出格式 ，每行输出5个数据  22.         

78、60;           if (j = 5)   23.                         System.out.println();  24.   &

79、#160;                     j = 0;  25.                       26.   

80、;               else   27.                     flag = false;  28.      

81、0;              break;  29.                   30.  31.         return flag;  32. 

82、0;     33.  34.     public static boolean isGoldbach(int a)    / 判断参数a是否符合哥德巴赫猜想  35.         int i;  36.         b

83、oolean flag = false;  37.         for (i = 1; i <= a / 2; i+)   38.             if (isPrime(i) && i

84、sPrime(a - i)  / 根据试题分析中的表达式，传入相关的两个参数  39.                 flag = true;  40.                 S

85、ystem.out.print(a + "=" + i + "+" + (a - i) + "  ");  41.                 break;      

86、;                      42. / 只要有一个符合条件的就可以退出循环，判断下一个偶数  43.               44.        

87、   45.  46.         return flag;  47.       48.  49.     public static boolean isPrime(int i)            

88、         50. / 判断参数i是否是素数，是则返回true反之则返回false  51.         int n;  52.         boolean flag = true;  53.       

89、  if (1 = i)                     / 1本身不是素数，因此需把这个特殊的数字抛出  54.             flag = false; &#

90、160;55.         for (n = 2; n <= i - 1; n+)        /* 判断i是否是素数的一个方法是看2i-1之间有其因子（能被2整除），有则不是素数返回false，反之则返回true*/ 56.        

91、60;    if (i % n = 0)   57.                 flag = false;  58.               

92、60; break;  59.               60.         return flag;  61.       62.  程序的输出结果如图17.4所示。 17.1  Java基础编程试题（5）面试题6  怎样实现金额转换考题题干金额转换，

93、阿拉伯数字的金额转换成中国传统的形式如：（￥1011）（壹仟零壹拾壹元整）输出。试题分析金额转换，在开发财务相关软件时会经常用到，也是软件本地化的一个需要。一般开发公司或者团队都有相应的金额转换类或者是模块，配合报表工具，可以实现良好的本地化。这里给出一个简单的金额转换代码，供读者参考。参考答案具体代码实现如下：1. package programe;  2. import java.text.NumberFormat;  3. import java.util.HashMap;  4. import java.util.S

94、canner;  5. public class AmountOfConversion   6.     /定义HashMap的value值  7.     public static final String EMPTY = ""  8.     public static final Strin

95、g ZERO = "零"  9.     public static final String ONE = "壹"  10.     public static final String TWO = "贰"  11.     public&

96、#160;static final String THREE = "叁"  12.     public static final String FOUR = "肆"  13.     public static final String FIVE = "伍" 

97、0;14.     public static final String SIX = "陆"  15.     public static final String SEVEN = "柒"  16.     public static final String 

98、;EIGHT = "捌"  17.     public static final String NINE = "玖"  18.     public static final String TEN = "拾"  19.     public

99、0;static final String HUNDRED = "佰"  20.     public static final String THOUSAND = "仟"  21.     public static final String TEN_THOUSAND = "万

100、"  22.     public static final String HUNDRED_MILLION = "亿"  23.     public static final String YUAN = "元"  24.     public static 

101、final String JIAO = "角"  25.     public static final String FEN = "分"  26.     public static final String DOT = "."  27.   &#

102、160; private static AmountOfConversion formatter = null; /创建AmountOfConversion的实例对象  28.      /创建初始化一个HashMap对象  29.     private HashMap NumberMap = new HashMap();  30.   

103、;  private HashMap HighnumberofMoney = new HashMap();  31.    /创建初始化一个NumberFormat对象  32.     private NumberFormat numberFormat = NumberFormat.getInstance();  33.     private&

104、#160;AmountOfConversion()     34.               /在用new创建AmountOfConversion对象时，为HashMap对象进行key-value的映射  35.         numberFormat.setMaximumFractionDigits(4); /设

105、置数据的小数部分的最大位数是4位  36.         numberFormat.setMinimumFractionDigits(2); /设置数据的小数部分的最小位数是2位  37.         numberFormat.setGroupingUsed(false);    /*设置此格式中是不可以使用组。如果设置可以使用组，则数  可

106、能被格式化为 "1,234,567"*/ 38.         NumberMap.put("0", ZERO);  39.         NumberMap.put("1", ONE);  40.         NumberMap.

107、put("2", TWO);  41.         NumberMap.put("3", THREE);  42.         NumberMap.put("4", FOUR);  43.         NumberMap.put

108、("5", FIVE);  44.         NumberMap.put("6", SIX);  45.         NumberMap.put("7", SEVEN);  46.         NumberMap.put(&q

109、uot;8", EIGHT);  47.         NumberMap.put("9", NINE);  48.         NumberMap.put(DOT, DOT);  49.         HighnumberofMoney.put("1

110、", TEN);  50.         HighnumberofMoney.put("2", HUNDRED);  51.         HighnumberofMoney.put("3", THOUSAND);  52.         Hi

111、ghnumberofMoney.put("4", TEN_THOUSAND);  53.         HighnumberofMoney.put("5", TEN);  54.         HighnumberofMoney.put("6", HUNDRED);  55.    &

112、#160;    HighnumberofMoney.put("7", THOUSAND);  56.         HighnumberofMoney.put("8", HUNDRED_MILLION);  57.       58.     public static AmountO

113、fConversion getInstance()  /判断AmountOfConversion对象formatter是否初始化  59.         if (formatter = null)  60.             formatter = new AmountOfConv

114、ersion();  61.         return formatter;  62.       63.     /进行金额转换的多种数据类型  64.     public String format(String moneyStr)   65.    

115、0;    String result = "不能进行金额转换！"  66.         if(isConversion(moneyStr)  67.             result = convertIntegerTochinese(moneyStr); &

116、#160;68.             result = convertPointTochinese(result);  69.           70.         return result;  71.    

117、0;  72.     public String format(double moneyDouble)   73.         return format(numberFormat.format(moneyDouble);  74.       75.     public String

118、60;format(int moneyInt)   76.         return format(numberFormat.format(moneyInt);  77.       78.     public String format(long moneyLong)   79.    &#

119、160;    return format(numberFormat.format(moneyLong);  80.       81.     public String format(Number moneyNum)   82.         return format(numberFormat.for

120、mat(moneyNum);  83.       84.     private String convertIntegerTochinese(String moneyStr)  /将参数中传入的阿拉伯数字转换成中文  85.         String result;  86.     

121、60;   StringBuffer C2CStrBufer = new StringBuffer();  87.         for (int i = 0; i < moneyStr.length(); i+)   88.         

122、0;   C2CStrBufer.append(NumberMap.get(moneyStr.substring(  89.                     i, i + 1);  90.           91. &#

123、160;       / 拾佰仟万亿等都是汉字里面才有的单位，加上它们  92.         int indexOfDot = C2CStrBufer.indexOf(DOT);  93.         int moneyPatternCursor = 1;  9

124、4.         for (int i = indexOfDot - 1; i > 0; i-)   95.             C2CStrBufer.insert(i, HighnumberofMoney.get(EMPTY  96.

125、60;                   + moneyPatternCursor);  97.             moneyPatternCursor = moneyPatternCursor = 8 ?

126、60;1 98.                     : moneyPatternCursor + 1;  99.           100.         String&

127、#160;fractionPart = C2CStrBufer.substring(C2CStrBufer  101.                 .indexOf(".");  102.         C2CStrBufer.delete(C2CStrBufer.indexOf("

128、."),  103.                 C2CStrBufer.length();  104.         while (C2CStrBufer.indexOf("零拾") != -1)   105.    &#

129、160;        C2CStrBufer.replace(C2CStrBufer.indexOf("零拾"),  106.                     C2CStrBufer.indexOf("零拾") + 2, ZERO

130、);  107.           108.         while (C2CStrBufer.indexOf("零佰") != -1)   109.             C2CStrBufer.replace(C2CS

131、trBufer.indexOf("零佰"),  110.                     C2CStrBufer.indexOf("零佰") + 2, ZERO);  111.           112. &#

132、160;       while (C2CStrBufer.indexOf("零仟") != -1)   113.             C2CStrBufer.replace(C2CStrBufer.indexOf("零仟"),  114.      &#

133、160;              C2CStrBufer.indexOf("零仟") + 2, ZERO);  115.           116.         while (C2CStrBufer.indexOf("零万") != -1)   117.             C2CStrBufer.replac