常见Java上机面考试

常见的Java上机面试题

在程序员面试中，主要的考试形式分为笔试和上机编程考试两部分。笔试主要考查面试者的

基础是否牢固；上机考试主要考查面试者的实际开发能力和技术技巧。

上机编程考试，要求面试者能够根据题目的要求，使用一种编程工具，编写全部代码并调试

运行。这主要是考查面试者代码书写和编程的熟练程度。值得注意的是，这类面试题要求能够

正确运行，往往要求面试者使用比较原始的JDK编译方式也就是使用DOS命令提示符，而不

是提供Eclipse或者JBuilder等快速开发环境。本章将经常出现的上机编程题进行分类，希望能

够给读者带来帮助和启示。

17.1 Java基础编程试题（1）

在上机编程类的面试题中，大部分涉及基础编程，例如算法、语法、常用的类等知识点。

面试题1 怎样截取字符串

考题题干

编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但

是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"6，应该

输出"我ABC"，而不是"我ABC+汉的半个"。

试题分析

本面试题容易产生困惑的是中文字符和英文字符，在这里需要考虑汉字和英文字符的占用字

节数问题，中文字符占两个字节，英文字符占一个字节，理解了这个，就很容易完成本题了。

参考答案

具体代码实现如下：

1.

2.

3.

4.

package core_java;

import r;

public class InterceptionStr {

static String ss;

//要进行截取操作的字符串

5. static int n;

//截取的字符串的字节数

6. public static void main(String[] args) {

7.

8.

n("请输入字符串：");

Scanner scStr = new Scanner();

//从键盘获取字符串

9. ss = (); //

将Scanner对象中的内容以字符串的形式取出来

10. n("请输入字节数：");

11. Scanner scByte = new Scanner();

//从键盘获取字符串

12. n = t();

//将Scanner对象中的内容以数值的形式取出来

1 / 19

13. Interception(setValue());

//方法与方法间的套用

14. }

15. public static String[] setValue() {

//此方法的作用是将字符串转换成字符串数组

16. String[] string = new String[()];

//创建一个字符数组string

17. for (int i = 0; i < ; i++) {

18. string[i] = ing(i, i + 1);

19. //将字符串ss中的

第i个字符取出，放入字符数组中string中

20. }

21. return string;

//将这个字符数组返回

22. }

23. public static void Interception(String[] string) {

24. int count = 0;

25. String m = "[u4e00-u9fa5]";

//汉字的正则表达试

26. n("以每" + n + "字节

划分的字符串如下所示：");

27. for (int i = 0; i < ; i++) {

28. if (string[i].matches(m)) {

29. //将字符数组中的每一

个元素与表则表达式进行匹配，如果相同则返回true

30. count = count + 2;

//如果当前字符是汉字，计数器count就加2

31. } else {

32. count = count + 1;

//如果当前字符不是汉字，计数器count就加1

33. }

34. if (count < n) {

//如果当前计数器count的值小于n，则输出当前字符

35. (string[i]);

36. } else if (count == n) {

//如果当前计数器count的值等于n，则输出当前字符

37. (string[i]);

38. count = 0;

39. n();

//内循环结果，则需要换行，起到控制打印格式的作用

40. } else {

41. count = 0;//如果当前计数器count的

值大于n，则计数器count清零，接着执行外部循环

42. n();

2 / 19

43. }

44. }

45. }

46. }

程序的输出结果如图17.1所示。

17.1 Java基础编程试题（2）

面试题2 怎样实现元素互换

考题题干

从键盘上输入10个整数，并将其放入一个一维数组中，然后将其前5个元素与后5个元素

对换，即：第1个元素与第10个元素互换，第2个元素与第9个元素互换…第5个元素与第6

个元素互换。分别输出数组原来各元素的值和对换后各元素的值。

试题分析

由于本题的要求是实现头尾元素互换，所以可以釆用取利用临时变量的方法来进行元素交

换。

参考答案

具体代码实现如下：

1.

2.

3.

4.

5.

6.

7.

8.

package programe;

import edReader;

import ption;

import treamReader;

public class HuHuanDemo {

public static void main(String args[]) {

3 / 19

9. print();

10.

11. }

12.

13. public static int[] write() {

14. BufferedReader[] buf = new

BufferedReader[10];/* 申请缓冲数组 */

15. int n;/* 开关量 和 中间量 */

16. int array[] = new int[10];

17. for (int i = 0; i < 10; i++)/* 赋值 */

18. {

19. buf[i] = new BufferedReader(new

InputStreamReader());

20. /* 给每个缓冲区定义 */

21. do/* 判断是否是空串，如是则重新输入 */

22. {

23. n = 1;

24. ("请输入第" + (i + 1) + "个整

数:");

25. try /* 建立一个异常捕获 */

26. {

27. array[i] = nt

(buf[i].readLine());/* 执行串变整数 */

28. /*

29. * nt(str) - str

转成 int型 buf[i].readLine() -

30. * 从系统输入缓冲区读入字符流给

buf缓冲区并返回字符串

31. */

32. } catch (NumberFormatException e)/* 捕获异

常 */

33. {

34. n("数据输入

错误请重新输入");/* 处理异常 */

35. n = 0;

36. } catch (IOException e) {

37. tackTrace();

38. }

39. } while (n == 0);

40. }

41. return array;

42.

43. }

44.

4 / 19

45. public static void print() {

46. int[] ary = write();

47. int s;

48. n("n你输入的数组是:");

49. for (int i = 0; i < 10; i++)/* 输出原数组 */

50. {

51. (ary[i] + " ");

52. }

53. for (int i = 0; i < 5; i++)/* 对换 */

54. {

55. s = ary[i];

56. ary[i] = ary[9 - i];

57. ary[9 - i] = s;

58. }

59.

60. n("n对换后的数组是:");

61. for (int i = 0; i < 10; i++)/* 输出对换后数组 */

62. {

63. (ary[i] + " ");

64. }

65. n();

66. }

67.

68. }

69. 程序输出的结果如图17.2所示。

17.1 Java基础编程试题（3）

面试题3 怎样实现元素排序

5 / 19

考题题干

（1）用Java实现一种排序。（2）Java类实现序列化的方法是什么？（3）在COLLECTION

框架中，如果实现自然比较方法，则需要实现什么样的接口？

试题分析

排序是程序员经常遇到的，也是基本的技巧之一，一般的排序方法有插入排序、冒泡排序、

选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。下面详细介绍3种排序方

法。

1．冒泡排序（Bubble Sort）

最简单的排序方法是冒泡排序法。这种方法的基本思想是，将待排序的元素看作是竖着排列

的"气泡"，较小的元素比较轻，从而要往上浮。在冒泡排序算法中要对这个"气泡"序列处理若

干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻元素的顺序是否

正确。如果发现两个相邻元素的顺序不对，即"轻"的元素在下面，就交换它们的位置。显然，

处理一遍之后，"最轻"的元素就浮到了最高位置；处理两遍之后，"次轻"的元素就浮到了次高

位置。在进行第二遍处理时，由于最高位置上的元素已是"最轻"元素，所以不必检查。一般地，

第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排

序。

2．选择排序（Selection Sort）

选择排序的基本思想是，对待排序的记录序列进行n-1遍的处理，第1遍处理是将]

中最小者与L[1]交换位置，第2遍处理是将]中最小者与L[2]交换位置，……，第i遍处

理是将]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按

从小到大的顺序排列好了。

当然，在实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换

位置，按从大到小的顺序进行排序处理。

3．插入排序（Insertion Sort）

插入排序的基本思想是，经过i-1遍处理后，L[1..i-1]已排好序。第i遍处理仅将L[i]插入

L[1..i-1]的适当位置，使得L[1..i]还是排好序的序列。要达到这个目的，可以用顺序比较的方法。

首先比较L[i]和L[i-1]，如果L[i-1]≤L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换

L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置（j1≤j≤i-1），使得L[j]≤L[j+1]

时为止。

简言之，插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位

置，直到全部插入完毕。

参考答案

（1）具体代码实现如下：

1.

2.

3.

4.

package programe;

import .*;

class InsertionSort {

ArrayList list;

6 / 19

5. // num指的是数据的个数，mod指的是可以

产生随机数的范围在1～mod之间

6. public InsertionSort(int num, int mod) {

7.

8.

list = new ArrayList(num);

Random dom = new Random();

9. n("排序之前的数组:");

10. for (int i = 0; i < num; i++) {

11. (new Integer(

(t()) % mod + 1));

12. n("list[" + i

+ "]=" + (i));

13. }

14. }

15. public void SortIt() {

16. Integer tempInt;

17. int MaxSize = 1;

18. for (int i = 1; i < (); i++) {

19. tempInt = (Integer) (i);

20. if (ue() >= ((Integer)

(MaxSize - 1))

21. .intValue()) {

22. (MaxSize, tempInt);

23. MaxSize++;

24. } else {

25. for (int j = 0; j < MaxSize; j++) {

26. if (((Integer) (j))

.intValue() >= tempInt

27. .intValue()) {

28. (j, tempInt);

29. MaxSize++;

30. break;

31. }

32. }

33. }

34. }

35. n("排序之后的数组:");

36. for (int i = 0; i < (); i++) {

37. n("list[" + i + "]=" + (

i));

38. }

39. }

40. public static void main(String[] args) {

41. InsertionSort is = new InsertionSort(10, 100);

42. ();

7 / 19

43. }

44. }

程序的输出结果如图17.3所示。

17.1 Java基础编程试题（4）

面试题4 怎样实现Singleton模式编程

考题题干

请编写一个Singleton模式的程序。

试题分析

Singleton模式的主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在

很多操作中，比如建立目录数据库连接都需要这样的单线程操作。使用Singleton的好处还在于

可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收。

一般Singleton模式通常的形式为：定义一个类，它的构造函数为private的，它有一个static

的private变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用，

继而调用其中的方法。

参考答案

（两种实现方法，取一即可）

1.

2.

3.

4.

5.

6.

7.

8.

package programe;

public class Singleton {

private Singleton() {

}

// 注意这是private 只供内部调用

private final static Singleton instance = new Singleton()

;

9. // 这里提供了一个供外部访问本class的静态方法，可以直接访问

10. public static Singleton getInstance() {

11. return instance;

12. }

13. }

8 / 19

或者：

1.

2.

3.

4.

5.

6.

7.

8.

9.

package programe;

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

// 使用时生成实例，提高了效率！

if (instance == null)

instance = new Singleton();

10. return instance;

11. }

12. }

面试题5 哥德巴赫猜想的近似证明

考题题干

哥德巴赫猜想是说任何一个大于2的偶数都能表示为两个素数之和。请编写一个Java程序，

验证1～100内哥德巴赫猜想的正确性，也就是近似证明哥德巴赫猜想。

试题分析

可以应用枚举的方法列出1～100内的所有偶数。然后逐一验证每个偶数是否满足哥德巴赫

猜想的论证。如果有一个不符合，就意味着哥德巴赫猜想不成立。

一个正偶数m可以表示成m=1+(m-1)，m=2+(m-2)，m=3+(m-3)，……，m=m/2+m/2。由

于m/2的后半部分和前半部分的结果是一样的，只是加数顺序不同，所以可以忽略。

参考答案

具体代码实现如下：

1.

2.

3.

4.

5.

package programe;

public class Guess {

public static void main(String[] args) {

n("在1~100范围内，

现在开始证实哥德巴赫猜想：");

6. if (Testify_Guess(1, 100)) {

7. n("在 1~100范围内，

哥德巴赫猜想是正确的。");

8. } else {

9. n("哥德巴赫猜想是错误的");

10. }

11.

12. }

13.

9 / 19

14. public static boolean Testify_Guess(int low, int high) {

15. // 判断1～100范围内的所有偶数是否符合哥德巴赫猜想，

符合则返回true，反之则返回false

16. int i, j = 0;

17. boolean flag = true;

18. for (i = low; i <= high; i++)

19. if (i % 2 == 0 && i > 2) //

在1～100之间选取大于2的偶数进行猜想测试

20. if (isGoldbach(i)) {

21. j++; //

j用来控制输出格式 ，每行输出5个数据

22. if (j == 5) {

23. n();

24. j = 0;

25. }

26. } else {

27. flag = false;

28. break;

29. }

30.

31. return flag;

32. }

33.

34. public static boolean isGoldbach(int a) {

// 判断参数a是否符合哥德巴赫猜想

35. int i;

36. boolean flag = false;

37. for (i = 1; i <= a / 2; i++) {

38. if (isPrime(i) && isPrime(a - i)){

// 根据试题分析中的表达式，传入相关的两个参数

39. flag = true;

40. (a + "=" + i + "+" + (a - i)

+ " ");

41. break;

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

43. }

44. }

45.

46. return flag;

47. }

48.

49. public static boolean isPrime(int i) {

10 / 19