常见的Java上机面试题

常见的Java上机面试题

在程序员面试中，主要的考试形式分为笔试和上机编程考试两部分。笔试主要考查面试者的基础是否牢固；上机考试主要考查面试者的实际开发能力和技术技巧。

上机编程考试，要求面试者能够根据题目的要求，使用一种编程工具，编写全部代码并调试运行。这主要是考查面试者代码书写和编程的熟练程度。值得注意的是，这类面试题要求能够正确运行，往往要求面试者使用比较原始的JDK编译方式也就是使用DOS命令提示符，而不是提供Eclipse或者JBuilder等快速开发环境。本章将经常出现的上机编程题进行分类，希望能够给读者带来帮助和启示。

17.1 Java基础编程试题（1）

在上机编程类的面试题中，大部分涉及基础编程，例如算法、语法、常用的类等知识点。 面试题1 怎样截取字符串 考题题干

编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如\我ABC\，应该截为\我AB\，输入\我ABC汉DEF\，应该输出\我ABC\，而不是\我ABC+汉的半个\。

试题分析

本面试题容易产生困惑的是中文字符和英文字符，在这里需要考虑汉字和英文字符的占用字节数问题，中文字符占两个字节，英文字符占一个字节，理解了这个，就很容易完成本题了。

参考答案

具体代码实现如下： 1. 2. 3. 4.

package core_java;

import java.util.Scanner; public class InterceptionStr {

static String ss;

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

5. static int n; //截取的字符串的字节数

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

System.out.println(\请输入字符串：\);

Scanner scStr = new Scanner(System.in);

//从键盘获取字符串

9. ss = scStr.next(); //

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

10. System.out.println(\请输入字节数：\);

11. Scanner scByte = new Scanner(System.in); //从键盘获取字符串

12. n = scByte.nextInt();

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

13. Interception(setValue()); //方法与方法间的套用 14. }

15. public static String[] setValue() {

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

16. String[] string = new String[ss.length()]; //创建一个字符数组string

17. for (int i = 0; i < string.length; i++) { 18. string[i] = ss.substring(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 = \;

//汉字的正则表达试

26. System.out.println(\以每\ + n + \字节

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

27. for (int i = 0; i < string.length; 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. System.out.print(string[i]); 36. } else if (count == n) { //如果当前计数器count的值等于n，则输出当前字符

37. System.out.print(string[i]); 38. count = 0;

39. System.out.println(); //内循环结果，则需要换行，起到控制打印格式的作用 40. } else {

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

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 java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;

public class HuHuanDemo {

public static void main(String args[]) {

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(System.in)); 20. /* 给每个缓冲区定义 */

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

23. n = 1;

24. System.out.print(\请输入第\ + (i + 1) + \个整

数:\);

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

27. array[i] = Integer.parseInt (buf[i].readLine());/* 执行串变整数 */ 28. /*

29. * Integer.parseInt(str) - str

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

30. * 从系统输入缓冲区读入字符流给 buf缓冲区并返回字符串

31. */

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

33. {

34. System.out.println(\数据输入 错误请重新输入\);/* 处理异常 */ 35. n = 0;

36. } catch (IOException e) { 37. e.printStackTrace(); 38. }

39. } while (n == 0); 40. }

41. return array; 42. 43. } 44.

45. public static void print() { 46. int[] ary = write(); 47. int s;

48. System.out.println(\你输入的数组是:\); 49. for (int i = 0; i < 10; i++)/* 输出原数组 */ 50. {

51. System.out.print(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. System.out.println(\对换后的数组是:\);

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

63. System.out.print(ary[i] + \); 64. }

65. System.out.println(); 66. } 67. 68. }

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

17.1 Java基础编程试题（3） 面试题3 怎样实现元素排序

考题题干

（1）用Java实现一种排序。（2）Java类实现序列化的方法是什么？（3）在COLLECTION框架中，如果实现自然比较方法，则需要实现什么样的接口？

试题分析

排序是程序员经常遇到的，也是基本的技巧之一，一般的排序方法有插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。下面详细介绍3种排序方法。

1．冒泡排序（Bubble Sort）

最简单的排序方法是冒泡排序法。这种方法的基本思想是，将待排序的元素看作是竖着排列的\气泡\，较小的元素比较轻，从而要往上浮。在冒泡排序算法中要对这个\气泡\序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即\轻\的元素在下面，就交换它们的位置。显然，处理一遍之后，\最轻\的元素就浮到了最高位置；处理两遍之后，\次轻\的元素就浮到了次高位置。在进行第二遍处理时，由于最高位置上的元素已是\最轻\元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排序。

2．选择排序（Selection Sort）

选择排序的基本思想是，对待排序的记录序列进行n-1遍的处理，第1遍处理是将L[1..n]中最小者与L[1]交换位置，第2遍处理是将L[2..n]中最小者与L[2]交换位置，……，第i遍处理是将L[i..n]中最小者与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 java.util.*; class InsertionSort { ArrayList list;

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

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

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

list = new ArrayList(num); Random dom = new Random();

9. System.out.println(\排序之前的数组:\); 10. for (int i = 0; i < num; i++) { 11. list.add(new Integer(Math.abs

(dom.nextInt()) % mod + 1));

12. System.out.println(\ + i

+ \ + list.get(i)); 13. } 14. }

15. public void SortIt() { 16. Integer tempInt; 17. int MaxSize = 1;

18. for (int i = 1; i < list.size(); i++) { 19. tempInt = (Integer) list.remove(i); 20. if (tempInt.intValue() >= ((Integer)

list.get(MaxSize - 1))

21. .intValue()) {

22. list.add(MaxSize, tempInt); 23. MaxSize++; 24. } else {

25. for (int j = 0; j < MaxSize; j++) { 26. if (((Integer) list.get(j))

.intValue() >= tempInt

27. .intValue()) { 28. list.add(j, tempInt); 29. MaxSize++; 30. break; 31. } 32. } 33. } 34. }

35. System.out.println(\排序之后的数组:\); 36. for (int i = 0; i < list.size(); i++) {

37. System.out.println(\ + i + \ + list.get(

i)); 38. } 39. }

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

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

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. }

或者： 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) { System.out.println(\在1~100范围内，

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

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

System.out.println(\在 1~100范围内， 哥德巴赫猜想是正确的。\); 8. } else {

9. System.out.println(\哥德巴赫猜想是错误的\); 10. } 11. 12. } 13.

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. System.out.println(); 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. System.out.print(a + \ + i + \ + (a - i)

+ \);

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

46. return flag; 47. } 48.

49. public static boolean isPrime(int i) {

50. // 判断参数i是否是素数，是则返回true反之则返回false 51. int n;

52. boolean flag = true;

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

55. for (n = 2; n <= i - 1; n++)

/* 判断i是否是素数的一个方法是看2～i-1之间有其因子 （能被2整除），有则不是素数返回false，反之则返回true*/ 56. if (i % n == 0) { 57. flag = false; 58. break; 59. }

60. return flag; 61. } 62. }

程序的输出结果如图17.4所示。 17.1 Java基础编程试题（5） 面试题6 怎样实现金额转换 考题题干

金额转换，阿拉伯数字的金额转换成中国传统的形式如： （￥1011）→（壹仟零壹拾壹元整）输出。 试题分析

金额转换，在开发财务相关软件时会经常用到，也是软件本地化的一个需要。一般开发公司或者团队都有相应的金额转换类或者是模块，配合报表工具，可以实现良好的本地化。这里给出一个简单的金额转换代码，供读者参考。

参考答案

具体代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8. 9.

package programe;

import java.text.NumberFormat; import java.util.HashMap; import java.util.Scanner;

public class AmountOfConversion {

//定义HashMap的value值

public static final String EMPTY = \; public static final String ZERO = \零\; public static final String ONE = \壹\;

10. public static final String TWO = \贰\; 11. public static final String THREE = \叁\; 12. public static final String FOUR = \肆\; 13. public static final String FIVE = \伍\; 14. public static final String SIX = \陆\; 15. public static final String SEVEN = \柒\; 16. public static final String EIGHT = \捌\; 17. public static final String NINE = \玖\; 18. public static final String TEN = \拾\; 19. public static final String HUNDRED = \佰\; 20. public static final String THOUSAND = \仟\; 21. public static final String TEN_THOUSAND = \万\; 22. public static final String HUNDRED_MILLION = \亿\; 23. public static final String YUAN = \元\; 24. public static final String JIAO = \角\; 25. public static final String FEN = \分\; 26. public static final String DOT = \;

27. private static AmountOfConversion formatter = null;

//创建AmountOfConversion的实例对象

28. //创建初始化一个HashMap对象

29. private HashMap NumberMap = new HashMap();

30. private HashMap HighnumberofMoney = new HashMap(); 31. //创建初始化一个NumberFormat对象

32. private NumberFormat numberFormat =

NumberFormat.getInstance();

33. private AmountOfConversion() {

34. //在用new创建AmountOfConversion对象时， 为HashMap对象进行key-value的映射

35. numberFormat.setMaximumFractionDigits(4); //设置数据的小数部分的最大位数是4位

36. numberFormat.setMinimumFractionDigits(2);

//设置数据的小数部分的最小位数是2位

37. numberFormat.setGroupingUsed(false);

/*设置此格式中是不可以使用组。如果设置可以使用组， 则数 1234567 可能被格式化为 \ 38. NumberMap.put(\, ZERO); 39. NumberMap.put(\, ONE); 40. NumberMap.put(\, TWO); 41. NumberMap.put(\, THREE); 42. NumberMap.put(\, FOUR); 43. NumberMap.put(\, FIVE); 44. NumberMap.put(\, SIX); 45. NumberMap.put(\, SEVEN); 46. NumberMap.put(\, EIGHT); 47. NumberMap.put(\, NINE); 48. NumberMap.put(DOT, DOT);

49. HighnumberofMoney.put(\, TEN); 50. HighnumberofMoney.put(\, HUNDRED); 51. HighnumberofMoney.put(\, THOUSAND); 52. HighnumberofMoney.put(\, TEN_THOUSAND); 53. HighnumberofMoney.put(\, TEN); 54. HighnumberofMoney.put(\, HUNDRED); 55. HighnumberofMoney.put(\, THOUSAND);

56. HighnumberofMoney.put(\, HUNDRED_MILLION); 57. }

58. public static AmountOfConversion getInstance() {

//判断AmountOfConversion对象formatter是否初始化 59. if (formatter == null)

60. formatter = new AmountOfConversion(); 61. return formatter; 62. }

63. //进行金额转换的多种数据类型

64. public String format(String moneyStr) { 65. String result = \不能进行金额转换！！\; 66. if(isConversion(moneyStr)){

67. result = convertIntegerTochinese(moneyStr); 68. result = convertPointTochinese(result); 69. }

70. return result; 71. }

72. public String format(double moneyDouble) {

73. return format(numberFormat.format(moneyDouble)); 74. }

75. public String format(int moneyInt) {

76. return format(numberFormat.format(moneyInt));

77. }

78. public String format(long moneyLong) {

79. return format(numberFormat.format(moneyLong)); 80. }

81. public String format(Number moneyNum) {

82. return format(numberFormat.format(moneyNum)); 83. }

84. private String convertIntegerTochinese(String moneyStr) {

//将参数中传入的阿拉伯数字转换成中文 85. String result;

86. StringBuffer C2CStrBufer = new StringBuffer(); 87. for (int i = 0; i < moneyStr.length(); i++) { 88. C2CStrBufer.append(NumberMap.get(moneyStr.substri

ng(

89. i, i + 1))); 90. }

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

94. for (int i = indexOfDot - 1; i > 0; i--) {

95. C2CStrBufer.insert(i, HighnumberofMoney.get(EMPTY

96. + moneyPatternCursor));

97. moneyPatternCursor = moneyPatternCursor == 8 ? 1 98. : moneyPatternCursor + 1; 99. }

100. String fractionPart = C2CStrBufer.substring(C2CStrBuf

er

101. .indexOf(\));

102. C2CStrBufer.delete(C2CStrBufer.indexOf(\), 103. C2CStrBufer.length());

104. while (C2CStrBufer.indexOf(\零拾\) != -1) {

105. C2CStrBufer.replace(C2CStrBufer.indexOf(\零拾\), 106. C2CStrBufer.indexOf(\零拾\) + 2, ZERO); 107. }

108. while (C2CStrBufer.indexOf(\零佰\) != -1) {

109. C2CStrBufer.replace(C2CStrBufer.indexOf(\零佰\), 110. C2CStrBufer.indexOf(\零佰\) + 2, ZERO); 111. }

112. while (C2CStrBufer.indexOf(\零仟\) != -1) {

113. C2CStrBufer.replace(C2CStrBufer.indexOf(\零仟\), 114. C2CStrBufer.indexOf(\零仟\) + 2, ZERO);

115. }

116. while (C2CStrBufer.indexOf(\零万\) != -1) {

117. C2CStrBufer.replace(C2CStrBufer.indexOf(\零万\), 118. C2CStrBufer.indexOf(\零万

\) + 2, TEN_THOUSAND); 119. }

120. while (C2CStrBufer.indexOf(\零亿\) != -1) {

121. C2CStrBufer.replace(C2CStrBufer.indexOf(\零亿\), 122. C2CStrBufer.indexOf(\零亿

\) + 2, HUNDRED_MILLION); 123. }

124. while (C2CStrBufer.indexOf(\零零\) != -1) {

125. C2CStrBufer.replace(C2CStrBufer.indexOf(\零零\), 126. C2CStrBufer.indexOf(\零零\) + 2, ZERO); 127. }

128. if (C2CStrBufer.lastIndexOf(ZERO) == C2CStrBufer.leng

th() - 1)

129. C2CStrBufer.delete(C2CStrBufer.length() - 1, 130. C2CStrBufer.length()); 131. C2CStrBufer.append(fractionPart); 132. result = C2CStrBufer.toString(); 133. return result; 134. }

135. private String convertPointTochinese(String moneyStr) {

//对小数点后面的数字进行汉字处理 136. String result;

137. StringBuffer C2CStrBufer = new StringBuffer(moneyStr)

;

138. int indexOfDot = C2CStrBufer.indexOf(DOT);

139. C2CStrBufer.replace(indexOfDot, indexOfDot + 1, YUAN)

;

140. C2CStrBufer.insert(C2CStrBufer.length() - 1, JIAO); 141. C2CStrBufer.insert(C2CStrBufer.length(), FEN); 142. if (C2CStrBufer.indexOf(\零角零分\) != -1)// 没有零头，加

整

143. C2CStrBufer.replace(C2CStrBufer.indexOf(\零角零分

\), 144. C2CStrBufer.length(), \整\);

145. else if (C2CStrBufer.indexOf(\零分\) != -1)// 没有零分，

加整

146. C2CStrBufer.replace(C2CStrBufer.indexOf(\零分\), 147. C2CStrBufer.length(), \整\); 148. else {

149. if (C2CStrBufer.indexOf(\零角\) != -1)

150. C2CStrBufer.delete(C2CStrBufer.indexOf(\零角

\), 151. C2CStrBufer.indexOf(\零角\) + 2); 152. }

153. result = C2CStrBufer.toString(); 154. return result; 155. }

156. private boolean isConversion(String moneyStr) {

//判断参数传来的数据是否符合进行转换的条件

157. int fractionDigits = moneyStr.length() -

moneyStr.indexOf(DOT) - 1; 158. boolean flag = true; 159. if (fractionDigits > 2){

160. System.out.println(\金额\ + moneyStr + \

的小数位多于两位。\); // 精度不能比分低

161. flag = false; 162. }

163. return flag; 164. 165. }

166. public static void main(String args[]) { 167. System.out.println(\请输入金额数：\);

168. Scanner scanner = new Scanner(System.in); 169. String str = scanner.next();

170. System.out.println(\转换后的金额为：\);

171. System.out.println(getInstance().format(new Double(st

r))); 172. } 173. }

17.1 Java基础编程试题（6） 程序的输出结果如图17.5所示。 图17.5 程序输出结果 面试题7 爱因斯坦的阶梯问题 考题题干

爱因斯坦曾出过这样一道有趣的数学题：有一个长阶梯，每步上2阶，最后剩1阶；若每步上3阶，最后剩2阶；若每步上5阶，最后剩4阶；若每步上6阶，最后剩5阶；只有每步上7阶，最后一阶也不剩。请问该阶梯至少有多少阶。编写一个Java程序解决该问题。

试题分析

从上面的描述中，可以把这个问题用数学方程式的形式表达出来，代码如下： 1. 2. 3. 4. 5.

x%2=1 x%3=2 x%5=4 x%6=5 x%7=0

从上面的表达式中不难看出，此方程x的解应该有无穷个，但这里要求的是那个最小的解。这个解一定是7的倍数，因为x%7=0，因此就用7的倍数依次与2、3、5、6进行取模运算，如果都符合了上面表达式的条件，那么这个数就是本题的答案，沿着这条思路，本题的具体代码如下。

参考答案

具体代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8.

package core_java;

public class StairsFlight {

public static void main(String[] args) { int x = 7, i, res = 0; boolean flag = false;

for (i = 1; i <= 50; i++) { //

将循环次数定为50，表示寻找范围为：7～350之间

9. if ((x % 2 == 1) && (x % 3 == 2)

&& (x % 5 == 4) && (x % 6 == 5)) { 10. res = x; 11. flag = true; 12. break; 13. }

14. x = 7 * (i + 1); 15. }

16. if (true == flag)

17. System.out.println(\关于爱因 斯坦的阶梯问题的答案是：\ + res); 18. else

19. System.out.println(\在7的1～50 倍这个范围内没有结果\); 20. } 21. }

程序的输出结果如下： 1.

关于爱因斯坦的阶梯问题的答案是：119

面试题8 如何判断回文数字 考题题干

有这样一类数字，它们顺着看和倒着看是相同的数，例如：121、656、2332等，这样的数字就称为回文数字。编写一个Java程序，判断从键盘接收的数字是否为回文数字。

试题分析

从回文数字的特点出发，弄清楚其特点是解决本问题的关键。解决方案可以通过将该数字倒置的办法来判断它是否是回文数字，例如：586，它的倒置结果为685，因为586！=685，故586不是回文数字。

参考答案

具体代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8.

package core_java;

import java.util.Scanner;

public class Palindrome {

public static void main(String[] args) { int n;

9. System.out.println(\请输入一个整数：\);

10. Scanner scByte = new Scanner(System.in); 11. n = scByte.nextInt(); 12. if (isPalindrome(n))

13. System.out.println(n + \是回文！\); 14. else

15. System.out.println(n + \不是回文！！\); 16. } 17.

18. public static boolean isPalindrome(int n) { //判断输入的数字是否是回文

19. int m = reverse(n); 20. if (m == n) 21. return true; 22. else

23. return false;

24. } 25.

26. public static int reverse(int i) { 27.

28. //将输入的数字进行倒置 29. int s, j = 0; 30. s = i;

31. while (s != 0) {

32. j = j * 10 + s % 10; 33. s = s / 10; 34. }

35. return j; 36. } 37. }

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

百度搜索“77cn”或“免费范文网”即可找到本站免费阅读全部范文。收藏本站方便下次阅读，免费范文网，提供经典小说综合文库常见的Java上机面试题在线全文阅读。