黑马程序员-十道测试题

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

     在决定报名黑马之前，自己已经自学了一部分java知识，根据自己情况和认识，决定通过实践找出自己的不知，为此十道测试题成为练兵的开始。

     黑马的十道测试题要求如下：

     第一题：求斐波那契数列第n项，n<30，斐波那契数列前10项为 1,1,2,3,5,8,13,21,34,55

     第2题：定义一个二维int数组，编写代码获取最小元素。

     第3题：请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。

     第4题：从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。

    

     第5题：使用带缓冲功能的字节流复制文件。

     第6题：编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72

     第7题：编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：原始字符串是"abc"，打印得到下列所有组合情况："a" "b" "c"

   "ab" "bc" "ca" "ba" "cb" "ac"  "abc" "acb" "bac" "bca" "cab" "cba"

     第8题： 写出以下代码执行结果，分析为什么？(没有分析结果不得分)

     第9题: 写一个正则表达式，可以匹配尾号5连的手机号。

     第10题： 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。

     在此，我将附上自己写的代码，水平有限，供大家交流，共同进步。

     

      

[java]  view plain copy

1. package com.itheima;  
2.   
3. import java.util.Scanner;  
4.   
5. /** 
6.  *第一题：求斐波那契数列第n项，n<30，斐波那契数列前10项为 1,1,2,3,5,8,13,21,34,55 
7.  * 
8.  * */  
9.   
10. public class Test1 {  
11.   
12.     private static Scanner input;  
13.     public static void main(String[] args) {  
14.           
15.         input = new Scanner(System.in);  
16.         System.out.println("请输入一个0~30之内的正整数，程序将计算出裴波那契的相应项之值。");  
17.         //接收用户输入的数值并进行存储  
18.         int come = input.nextInt();  
19.         //对用户输入的值进行条件判断,如果输入有误讲提示并推出  
20.         if((come<0)||(come>=30)){  
21.             System.out.println("输入有误，程序结束");  
22.             return;  
23.         }  
24.         System.out.println("您输入的值为"+come);  
25.         int dispose = fun(come);  
26.         System.out.println("运行结果为"+dispose);  
27.     }  
28.     //斐波那契数列，又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、……在数学上，  
29.     //斐波纳契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*）  
30.     public static int fun(int come){  
31.         if(come<=1){  
32.             return 1;  
33.         }  
34.         return fun(come-1)+fun(come-2);  
35.     }  
36. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. /** 
4.  * 第2题：定义一个二维int数组，编写代码获取最小元素。 
5.  * */  
6.   
7. public class Test2 {  
8.   
9.     public static void main(String[] args) {  
10.         //随意定义一个二维数组  
11.         int[][] array = {{3,2,1},{5,8,9,10},{15,64,185,38,79,85}};  
12.         //存储最大值  
13.         int temp = array[0][0];  
14.           
15.         //运用循环比较最大值  
16.         for (int i = 0; i < array.length; i++) {  
17.             for (int j = 0; j < array.length; j++) {  
18.                 if(array[i][j]<temp){  
19.                     temp = array[i][j];  
20.                 }  
21.             }  
22.         }  
23.         System.out.println("二维数组的最小元素为:"+temp);  
24.     }  
25.   
26. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. /** 
4.  * 第3题：请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。 
5.  *  
6.  * */  
7.   
8. public class Test3 {  
9.   
10.     public static void main(String[] args) {  
11.           
12.         //随意定义一个一维数组  
13.         int[] array = {9,8,6,7,5,3,4,2,1,10,42,75,53,86,91};  
14.         System.out.print("所定义数组为: ");  
15.         for (int i : array) {  
16.             System.out.print(i+" ");  
17.         }  
18.         System.out.println();  
19.         first(array);  
20.         second(array);  
21.     }  
22.       
23.     //冒泡法  
24.     public static void first(int[] a){  
25.           
26.         for (int i = 0; i < a.length; i++) {  
27.             for (int j = 0; j < a.length-i-1; j++) {  
28.                 if(a[j]>a[j+1]){  
29.                     int temp = a[j];  
30.                     a[j] = a[j+1];  
31.                     a[j+1] = temp;  
32.                 }  
33.             }  
34.         }  
35.         System.out.print("冒泡法：");  
36.         for (int i : a) {  
37.             System.out.print(i+" ");  
38.         }  
39.     }  
40.     //二分法  
41.     public static void second(int[] a){  
42.           
43.         for (int i = 0; i < a.length; i++) {  
44.             int start,end,mid;  
45.             start = 0;  
46.             end = i-1;  
47.             mid = 0;  
48.             int temp = a[i];  
49.             while(start<=end){  
50.                 mid = (start + end)/2;  
51.                 if(a[mid] > temp){  
52.                     end = mid - 1;  
53.                 }else{  
54.                     start = mid + 1;  
55.                 }  
56.             }  
57.         }  
58.         System.out.println();  
59.         System.out.print("二分法：");  
60.         for (int i : a) {  
61.             System.out.print(i+" ");  
62.         }  
63.     }  
64.   
65. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. import java.util.Scanner;  
4.   
5. /** 
6.  * 第4题：从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。 
7.  *  
8.  * */  
9.   
10. public class Test4 {  
11.   
12.     private static Scanner input;  
13.     public static void main(String[] args) {  
14.         System.out.println("请输入阿拉伯数字（限5位），程序将自动转换为相应汉字");  
15.         input = new Scanner(System.in);  
16.         String come = input.next();  
17.         //将由come接收的字符串转换为字符数组  
18.         char[] array = come.toCharArray();  
19.         //用于存放字符串强转后的int数组  
20.         int[] change = new int[array.length];  
21.         for (int i = 0; i < array.length; i++) {  
22.             //转换  
23.             change[i] = (int)array[i] - 48;  
24.         }  
25.         //调用fun方法  
26.         fun(change);  
27.     }  
28.     //实现数字与汉字的对于关系并打印  
29.     public static void fun(int[] tab){  
30.         for (int i = 0; i < tab.length; i++) {  
31.             switch(tab[i]){  
32.                 case 0:System.out.print("零");break;  
33.                 case 1:System.out.print("一");break;  
34.                 case 2:System.out.print("二");break;  
35.                 case 3:System.out.print("三");break;  
36.                 case 4:System.out.print("四");break;  
37.                 case 5:System.out.print("五");break;  
38.                 case 6:System.out.print("六");break;  
39.                 case 7:System.out.print("七");break;  
40.                 case 8:System.out.print("八");break;  
41.                 case 9:System.out.print("九");break;  
42.                 //实现对数字的判断，如果输入不是阿拉伯数字，提示错误并结束程序  
43.                 default:System.out.println("输入错误，程序结束");return;  
44.             }  
45.         }  
46.     }  
47.       
48. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedOutputStream;  
5. import java.io.File;  
6. import java.io.FileInputStream;  
7. import java.io.FileNotFoundException;  
8. import java.io.FileOutputStream;  
9. import java.io.IOException;  
10.   
11.   
12. /** 
13.  *第五题：使用带缓冲功能的字节流复制文件。 
14.  *  
15.  * */  
16.   
17. public class Test5 {  
18.     public static void main(String[] args) {  
19.         copy("d://C_MySpace//DownSpace//浏览器下载//pictureC.jpg","d://t.jpg");  
20.         System.out.println("succeed");  
21.     }  
22.     public static void copy(String srcName,String copyName){  
23.         File srcfile = new File(srcName);  
24.         File copyfile = new File(copyName);  
25.         int len = -1;  
26.         byte[] bytes = new byte[1024];  
27.           
28.         try {  
29.             BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcfile));  
30.             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(copyfile));  
31.             while((len = bis.read(bytes))!=-1){  
32.                 bos.write(bytes, 0, len);  
33.                 bos.flush();  
34.             }  
35.             bos.close();  
36.             bis.close();  
37.         } catch (FileNotFoundException e) {  
38.             e.printStackTrace();  
39.         } catch (IOException e) {  
40.             // TODO Auto-generated catch block  
41.             e.printStackTrace();  
42.         }   
43.     }  
44. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. /** 
4.  *第六题：编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72 
5.  *  
6.  * */  
7.   
8. public class Test6 {  
9.   
10.     public static void main(String[] args) {  
11.         //利用循环，完成1-100数字的筛选  
12.         for (int i = 1; i <= 100; i++) {  
13.             //条件筛选  
14.             if(i==7||i/10==7||i%10==7){  
15.                 continue;  
16.             }  
17.             System.out.print(i+" ");  
18.         }  
19.     }  
20.   
21. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. /** 
4.  * 第7题：编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如： 
5.  *      原始字符串是"abc"，打印得到下列所有组合情况： 
6.  *      "a" "b" "c" 
7.  *      "ab" "bc" "ca" "ba" "cb" "ac" 
8.  *      "abc" "acb" "bac" "bca" "cab" "cba" 
9.  *    
10.  * */  
11.   
12. public class Test7 {  
13.   
14.     public static void main(String[] args) {  
15.         //字符串abc  
16.         String str = "abc";  
17.         //字符串转换为字符数组  
18.         char[] array = str.toCharArray();  
19.         //功能实现函数  
20.         fun(array);  
21.     }  
22.       
23.     public static void fun(char[] src){  
24.         //打印"a" "b" "c"  
25.         for (int i = 0; i < src.length; i++) {  
26.             System.out.print(src[i]+" ");  
27.         }  
28.         //换行  
29.         System.out.println();  
30.         //打印"ab" "bc" "ca" "ba" "cb" "ac"  
31.         for (int i = 0; i < src.length; i++) {  
32.             for (int j = 0; j < src.length; j++) {  
33.                 //判断去重复  
34.                 if(src[i]==src[j]){  
35.                     continue;  
36.                 }  
37.                 System.out.print(src[i]+""+src[j]+" ");  
38.             }  
39.         }  
40.         //换行  
41.         System.out.println();  
42.         //打印"abc" "acb" "bac" "bca" "cab" "cba"  
43.         for (int i = 0; i < src.length; i++) {  
44.             for (int j = 0; j < src.length; j++) {  
45.                 for (int j2 = 0; j2 < src.length; j2++) {  
46.                     //判断去重复  
47.                     if((src[i]==src[j])||(src[i]==src[j2])||(src[j]==src[j2])){  
48.                         continue;  
49.                     }  
50.                     System.out.print(src[i]+""+src[j]+""+src[j2]+" ");  
51.                 }  
52.             }  
53.         }  
54.     }  
55. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. /** 
4.  * 第8题： 写出以下代码执行结果，分析为什么？(没有分析结果不得分) 
5.  *  
6.  * */  
7.   
8. /** 
9.  * 分析1：自己首先读了一下程序，运行后发现原始的System.out.println(s);与自己的预计有出入，而System.out.println(s == value); 
10.  *     比较简单，因为两个字符串在内存中位置不同，==判断变量时判断的时位置是否相同，equals才是判断字符串内容是否相同，s与value是两个不同对象，所以输出false。 
11.  * 分析2：继续分析substring和replace，因此进行验证1-->"abc"于是进行验证2-->"bc",于是我好像发现了什么，赶快进行验证3-->"axyz"，原来substring 
12.  *     和replace对字符串的操作不会覆盖原来的对象，而是产生新对象，而本题中substring和replace操作后并没有将新对象存储或覆盖旧对象，所以导致 
13.  *     System.out.println(s);输出对象依然是"abc",与substring与replace操作无关。 
14.  * */  
15. public class Test8 {  
16.     public static void main(String[] args) {  
17.         String s = "abc";  
18.         s.substring(1);  
19. //                          System.out.println("my_1-->"+s);//验证1  
20.                             System.out.println("my_2-->"+s.substring(1));//验证2  
21.         s.replace("bc", "xyz");  
22.                             System.out.println("my_3-->"+s.replace("bc", "xyz"));//验证3  
23.        System.out.println(s);   
24.        String value = new String ("abc");  
25.        System.out.println(s == value);  
26. }  
27. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. import java.util.Scanner;  
4. import java.util.regex.Pattern;  
5.   
6. /** 
7.  *第9题: 写一个正则表达式，可以匹配尾号5连的手机号。 
8.  *      规则: 第1位是1，第二位可以是数字3458其中之一，后面4位任意数字，最后5位为任意相同的数字。 
9.  *      例如：18601088888、13912366666  
10.  *  
11.  * */  
12.   
13. public class Test9 {  
14.   
15.     public static void main(String[] args) {  
16.         //输入提示  
17.         System.out.println("请输入手机号码，第1位是1，第二位可以是数字3458其中之一，后面4位任意数字，最后5位为任意相同的数字。");  
18.         System.out.println("程序将对号码进行判定");  
19.         //Scanner用于检测输入  
20.         Scanner input = new Scanner(System.in);  
21.         //字符串come用于存储输入字符串  
22.         String come = input.next();  
23.         //Pattern中的matches，括号中为正则表达式，对电话号码进行匹配，返回boolean值  
24.         boolean flag = come.matches("[1][3458]\\d{4}(\\d)\\1{4}");System.out.println(flag);  
25.         //对上一步flag进行判断，true表示号码匹配，false表示不匹配  
26.         if(flag){  
27.             System.out.println("电话号码格式正确");  
28.         }else{  
29.             System.out.println("电话号码格式不正确");  
30.         }  
31.                   
32.     }  
33.   
34. }  

[java]  view plain copy

1. package com.itheima;  
2.   
3. import java.util.ArrayList;  
4.   
5. /** 
6.  * 第10题： 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。 
7.  *          当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。 
8.  *  
9.  * */  
10.   
11. public class Test10 {  
12.   
13.     public static void main(String[] args) {  
14.         //存放河岸A（起始位置）现有动物  
15.         ArrayList thisLan = new ArrayList<String>();  
16.         //存放河岸B（起始位置）现有动物  
17.         ArrayList thatLan = new ArrayList<String>();  
18.         //添加动物狗  
19.         thisLan.add("猫");  
20.         //添加动物猫  
21.         thisLan.add("鱼");  
22.         //添加动物鱼  
23.         thisLan.add("狗");  
24.         //老农类，实现所以功能  
25.         Fammer fammer = new Fammer();  
26.         //老农类中的dispose方法，其中调用tothatLan与tothisLan方法  
27.         fammer.dispose(thisLan, thatLan);  
28.     }  
29.   
30.     //实现农夫运送动物的功能  
31.       
32.       
33. }  
34. class Fammer{  
35.     //元素缓存，辅助tothatLan和tothisLan进行元素删除与恢复  
36.     private String temp;  
37.       
38.     //步骤记录  
39.     private int time = 1;  
40.     //当老农不在时，判断猫狗鱼三者的关系。如果出现狗会咬猫，猫会吃鱼的情况返回false，否则返回true  
41.     public boolean safe(ArrayList<String> a){  
42.         if((a.contains("狗")&&a.contains("猫")) || (a.contains("猫")&&a.contains("鱼"))){  
43.             return false;  
44.         }  
45.         return true;  
46.     }  
47.     //从河岸A向河岸B运送动物的方法  
48.     public void tothatLan(ArrayList<String> tis,ArrayList<String> tat){  
49.         //用于while循环  
50.         boolean flag = true;  
51.         while(true){  
52.             //当河岸A没有动物时说明动物均被带到河岸B  
53.             if(tis.size()==0){  
54.                 //提示结束  
55.                 System.out.println("结束！");  
56.                 return;  
57.             }  
58.             //自动查询符合条件的动物，并带到河岸B  
59.             for (int i = 0; i < tis.size(); i++) {  
60.                 //缓存，用于删除与恢复动物  
61.                 temp = tis.get(i);  
62.                 if(tis.remove(temp)){                         
63.                     if(this.safe(tis)){  
64.                         System.out.println("第"+time+"步,将"+temp+"从河岸A运送到河岸B");  
65.                         time++;  
66.                         //动物过河  
67.                         tat.add(temp);  
68.                         temp = null;  
69.                         System.out.println("            "+"河岸A有"+tis);  
70.                         System.out.println("            "+"河岸B有"+tat);  
71.                         return;  
72.                     }else{  
73.                         //恢复删除  
74.                         tis.add(temp);  
75.                         continue;  
76.                     }  
77.                 }else{  
78.                     continue;  
79.                 }  
80.             }  
81.         }  
82.     }  
83.     //从河岸B向河岸A运送动物的方法,与tothatLan相似  
84.     public void tothisLan(ArrayList<String> tis,ArrayList<String> tat){  
85.         //用于while循环  
86.         boolean flag = true;  
87.         while(flag){  
88.             //当河岸B的动物符合要求或没有动物，便不需要将动物带回河岸A  
89.             if(tat.size()<1 || this.safe(tat)){  
90.                 return;  
91.             }  
92.             //自动查询符合条件的动物，并带到河岸A  
93.             for (int i = 0; i < tat.size(); i++) {  
94.                 //缓存，用于删除与恢复动物  
95.                 temp = tat.get(i);  
96.                 if(tat.remove(temp)){  
97.                     if(this.safe(tat)){  
98.                         System.out.println("第"+time+"步,将"+temp+"从河岸B运送到河岸A");  
99.                         time++;  
100.                         //动物过河  
101.                         tis.add(temp);  
102.                         temp = null;  
103.                         System.out.println("            "+"河岸A有"+tis);  
104.                         System.out.println("            "+"河岸B有"+tat);  
105.                         return;  
106.                     }else{  
107.                         //恢复删除  
108.                         tat.add(temp);  
109.                         continue;  
110.                     }  
111.                 }else{  
112.                     continue;  
113.                 }  
114.             }  
115.         }  
116.     }  
117.     //自动完成动物过河，调用tothatLan和tothisLan的方法  
118.     public void dispose(ArrayList<String> tis,ArrayList<String> tat){  
119.         boolean flag = true;  
120.         while(flag){  
121.             //当河岸A没有动物说明动物全部过河  
122.             if(tis.isEmpty()){  
123.                 return;  
124.             }  
125.             this.tothatLan(tis, tat);  
126.             //当河岸A没有动物说明动物全部过河  
127.             if(tis.isEmpty()){  
128.                 return;  
129.             }  
130.             this.tothisLan(tis, tat);  
131.         }  
132.     }  
133.       
134. }