华为校招JAVA机试题

又到校园招聘的时候了，前几天听同学说华为校招还要考上机，然后就在网上找往年的机试题，找到之后就开始战斗了。。下面的题目都是在网上找的，然后代码是自己一个一个写的。。。
1.程序实现目标： 输入一个字符串，将其各个字符对应的ASCII值加5后，输出结果。
程序要求：该字符串只包含小写字母，若其值加5后的字符值大于'z',将其转换成从a开始的字符。

[java]  view plain  copy

1.    import java.util.Scanner;  
2.   
3.   
4.    public class Test {  
5.   
6.   
7. public static void main(String[] args) {  
8.     System.out.println(StringASCII("abcd"));  
9.     Scanner in = new Scanner(System.in);  
10.     System.out.println("请输入一串小写字母：");  
11.     String str = in.next();  
12.     System.out.println(StringASCII(str));  
13.     in.close();  
14. }  
15.   
16.   
17. public static String StringASCII(String str) {  
18.     StringBuffer reslut = new StringBuffer();  
19.     // 将字符串转换成数组  
20.     char[] array = str.toCharArray();  
21.     for (int i = 0; i < array.length; i++) {  
22.         char arr= (char) (array[i] + 5);  
23.         if (arr >'z') {  
24.             arr = 'a';  
25.         }  
26.         reslut.append(arr);  
27.     }  
28.     return reslut.toString();  
29. }  

2.程序实现目标：求一个整型数组中元素的平均值，并统计其中大于和小于此平均值的元素的个数。
  程序要求：输入：整型数组中的元素个数及各个元素。

            输出：整型数组中元素的平均值，大于和小于此平均值的元素的个数

[java]  view plain  copy

1. import java.util.Scanner;  
2.   
3.   
4. public class CountAvg {  
5.   
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11. //      int arr[] = { 1, 2, 4, 23, 8, 11, 22, 31 };  
12.         int[] arr = inputArr();  
13.         int[] count = count(arr);  
14.         System.out.println("数组的平均值：" + count[2] + ",小于平均值的个数：" + count[1]  
15.                 + ",大于平均值的个数：" + count[0]);  
16.     }  
17.   
18.   
19.     // 输入整形数组  
20.     private static int[] inputArr() {  
21.         Scanner scanner = new Scanner(System.in);  
22.         System.out.println("请输入整形数组的长度：");  
23.         int i = scanner.nextInt();  
24.         int arr[] = new int[i];  
25.         System.out.println("请输入整形数组的元素：");  
26.         for (int j = 0; j < arr.length; j++) {  
27.             int str = scanner.nextInt();  
28.             // System.out.println(arr[j]+"----"+str);  
29.             arr[j] = str;  
30.         }  
31.         scanner.close();  
32.         return arr;  
33.     }  
34.   
35.   
36.     /** 
37.      * 求出整形数组的平均值，大于和小于平均值的个数 
38.      *  
39.      * @param arr 
40.      * @return 
41.      */  
42.     private static int[] count(int[] arr) {  
43.         int m = 0, n = 0, avg, total = 0;  
44.         for (int i = 0; i < arr.length; i++) {  
45.             total += arr[i];  
46.         }  
47.         avg = total / arr.length;  
48.         for (int i = 0; i < arr.length; i++) {  
49.             if (avg < arr[i]) {  
50.                 m++;  
51.             } else {  
52.                 n++;  
53.             }  
54.         }  
55.         int result[] = new int[3];  
56.         result[0] = m;  
57.         result[1] = n;  
58.         result[2] = avg;  
59.         return result;  
60.     }  
61. }  

3、手动输入一个存储整数的数组，要求输出数组里面的2个最大值。
   实例： 
             输入：1,2,5,9,84,3,2
             输出：84,9
   

[java]  view plain  copy

1.  import java.util.Scanner;  
2.   
3.   
4.     public class CountMax {  
5.   
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.         int[] arr = inputArr();  
12.         countMax(arr);  
13.         System.out.println("最大值：" + arr[0] + ",第二大的值" + arr[1]);  
14.     }  
15.   
16.   
17.     /** 
18.      * 计算出两个最大值 
19.      *  
20.      * @param arr 
21.      * @return 
22.      */  
23.     private static void countMax(int[] a) {  
24.         // 冒泡排序  
25.         int temp = 0;  
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.                     temp = a[j];  
30.                     a[j] = a[j + 1];  
31.                     a[j + 1] = temp;  
32.                 }  
33.             }  
34.         }  
35.     }  
36.   
37.   
38.     // 输入整形数组  
39.     private static int[] inputArr() {  
40.         Scanner scanner = new Scanner(System.in);  
41.         System.out.println("请输入整形数组的长度：");  
42.         int i = scanner.nextInt();  
43.         int arr[] = new int[i];  
44.         System.out.println("请输入整形数组的元素：");  
45.         for (int j = 0; j < arr.length; j++) {  
46.             int str = scanner.nextInt();  
47.             // System.out.println(arr[j]+"----"+str);  
48.             arr[j] = str;  
49.         }  
50.         scanner.close();  
51.         return arr;  
52.     }  
53. }  

[java]  view plain  copy

1. </pre><span style="font-size:18px;">4、回文数字判断。题目描述：    有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：回文数字。编写一个函数，判断某数字是否是回文数字。    要求实现方法：public String isPalindrome(String strIn);【输入】strIn: 整数，以字符串表示；【返回】true: 是回文数字；              false: 不是回文数字；【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出</span><pre name="code" class="java">import java.util.Scanner;  
2.   
3.   
4. public class Palindrome {  
5.   
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.         Scanner in = new Scanner(System.in);  
12.         System.out.println("请输入一个整形数字：");  
13.         String str = in.next();  
14.         if (isPalindrome(str)) {  
15.             System.out.println(str + "--是回文数字");  
16.         } else {  
17.             System.out.println(str + "--不是回文数字");  
18.         }  
19.         in.close();  
20.     }  
21.   
22.   
23.     /** 
24.      * 判断是否为回文数字 
25.      *  
26.      * @param str 
27.      * @return 
28.      */  
29.     private static boolean isPalindrome(String str) {  
30.         boolean result = false;  
31.         System.out.println("str长度---" + str.length());  
32.         for (int i = 0; i <= str.length() / 2 - 1; i++) {  
33.             if (str.charAt(i) == str.charAt(str.length() - i - 1)) {  
34.                 result = true;  
35.             }else {  
36.                 result = false;  
37.             }  
38.         }  
39.         return result;  
40.     }  
41.   
42.   
43. }  

5、要求：随机打印50个随机（4-10长度）的字符串，要求字符串包含的范围是所有的英文字母包含大小写和数字，按照编码顺序排序，每行打印4个，要求首字符对齐.

[java]  view plain  copy

1. import java.util.ArrayList;  
2. import java.util.List;  
3. import java.util.Random;  
4.   
5.   
6. public class RandomStr {  
7.   
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         List<String> arrayStr = new ArrayList<String>();  
14.         for (int i = 0; i < 50; i++) {  
15.             Random random = new Random();  
16.             // 0-6  
17.             int nextInt = random.nextInt(7);  
18.             int strlen = nextInt + 4;  
19.             // 打印出随机数  
20.             String randomStr = randomStr(strlen);  
21.             // System.out.println("打印出来的字符串:" + randomStr);  
22.             arrayStr.add(randomStr);  
23.         }  
24.         int count = 0;  
25.         for (String str : arrayStr) {  
26.             System.out.print(str + " ");  
27.             if (count % 4 == 0) {  
28.                 // 换行  
29.                 System.out.println();  
30.             }  
31.             count++;  
32.         }  
33.     }  
34.   
35.   
36.     /** 
37.      * 打印出随机的字符串 
38.      *  
39.      * @param strlen 
40.      * @return 
41.      */  
42.     private static String randomStr(int strlen) {  
43.         char[] str = new char[strlen];  
44.         int i = 0;  
45.         while (i < strlen) {  
46.             // 生成0-3的随机数  
47.             int f = new Random().nextInt(4);  
48.             if (f == 0) {  
49.                 str[i] = (char) ('a' + Math.random() * 26);  
50.             } else if (f == 1) {  
51.                 str[i] = (char) ('A' + Math.random() * 26);  
52.             } else {  
53.                 str[i] = (char) ('0' + Math.random() * 10);  
54.             }  
55.             i++;  
56.         }  
57.   
58.   
59.         return new String(str);  
60.     }  
61.   
62.   
63. }  

6.手动输入一个字符串，仅限小写字母，统计并输出每个字符在字符串中出现的次数,并输出。提示(可以用Map)
实例：
输入：aaabbbccc
输出：a 3
      b 3
      c 3

[java]  view plain  copy

1. import java.util.HashMap;  
2. import java.util.Map;  
3. import java.util.Scanner;  
4.   
5.   
6. public class NumberOfElement {  
7.   
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         Scanner in = new Scanner(System.in);  
14.         System.out.println("请输入的一组小写字符串：");  
15.         String str = in.next();  
16.         in.close();  
17.         // 正则运算  
18.         String reg = "^[a-z]*$";  
19.         if (str.matches(reg)) {  
20.   
21.   
22.             Map<Character, Integer> charCount = getCharCount(str);  
23.             // 遍历map  
24.             for (Map.Entry<Character, Integer> e : charCount.entrySet()) {  
25.                 System.out.println(e.getKey() + " " + e.getValue());  
26.             }  
27.         }else {  
28.             System.out.println("您输入的字符串不符合要求");  
29.         }  
30.     }  
31.   
32.   
33.     private static Map<Character, Integer> getCharCount(String str) {  
34.         Map<Character, Integer> map = new HashMap<Character, Integer>();  
35.         char[] array = str.toCharArray();  
36.         for (int i = 0; i < array.length; i++) {  
37.             if (!map.containsKey(array[i])) {  
38.                 map.put(array[i], 1);  
39.             } else {  
40.                 map.put(array[i], map.get(array[i]) + 1);  
41.             }  
42.         }  
43.         return map;  
44.     }  
45.   
46.   
47. }  

7、要求实现方法public String addTwoBigNumber(String s1,string s2)
 大数相加，注意处理异常

[java]  view plain  copy

1. import java.math.BigInteger;  
2. import java.util.Scanner;  
3.   
4.   
5. public class BigNumAdd {  
6.   
7.   
8.     /** 
9.      * @param args 
10.      */  
11.     public static void main(String[] args) {  
12.         Scanner in = new Scanner(System.in);  
13.         System.out.println("请输入第一个大数：");  
14.         String str1 = in.next();  
15.         System.out.println("请输入第二个大数：");  
16.         String str2 = in.next();  
17.         in.close();  
18.         if (isBigNumber(str1) &&isBigNumber(str2)) {  
19.             String bigNumber = addTwoBigNumber(str1, str2);  
20.             System.out.println("两个大数相加的结果为：" + bigNumber);  
21.         }else {  
22.             System.out.println("输入错误！");  
23.         }  
24.     }  
25.   
26.   
27.     /** 
28.      * 大数相加 
29.      *  
30.      * @param s1 
31.      * @param s2 
32.      * @return 
33.      */  
34.     public static String addTwoBigNumber(String s1, String s2) {  
35.         BigInteger bt1 = new BigInteger(s1);  
36.         BigInteger bt2 = new BigInteger(s2);  
37.         return bt1.add(bt2).toString();  
38.     }  
39.     /** 
40.      * 判断一个字符串是否为大数 
41.      * @param str 
42.      * @return  
43.      */  
44.     public static boolean isBigNumber(String str) {  
45.         boolean result = false;  
46.         String reg = "[0-9]*$";  
47.         if (str.matches(reg)) {  
48.             result = true;  
49.         } else {  
50.             result = false;  
51.         }  
52.         return result;  
53.     }  
54. }  

8、比较二维数组列最小值，组成一个新数组返回。(实现核心算法，不需要使用IO)

输入：intArr = {{5,6,1,16},{7,3,9}}

输出：intArrs ={1,3}

[java]  view plain  copy

1. import java.util.Arrays;  
2. import java.util.Scanner;  
3.   
4.   
5.   
6.   
7. public class CountMin {  
8.   
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         int[][] arr = {{5,6,1,16},{7,3,9},{5,7,12}};  
15.         int[] colmin = getColmin(arr);  
16.         System.out.println(Arrays.toString(colmin));  
17.     }  
18.   
19.   
20.     private static int[] getColmin(int[][] arr) {  
21.         int minArr[] = new int[arr.length];  
22.         for (int i = 0; i < arr.length; i++) {  
23.             int tmp[] = arr[i];  
24.             // 数组的排序，从小到大  
25.             Arrays.sort(tmp);  
26.             minArr[i] = tmp[0];  
27.         }  
28.         return minArr;  
29.     }  
30.   
31.   
32. }  

9. 输入：a aa,cat tiger.123dd 
输出： tiger
功能描述：键盘输入一句话
输出一句话中最常的单词，如果最长的出现多次，返回第一个。这句话只包含数字字母和标点。

[java]  view plain  copy

1. import java.util.ArrayList;  
2. import java.util.HashMap;  
3. import java.util.Map;  
4. import java.util.Scanner;  
5.   
6.   
7.   
8.   
9. public class FindLongString {  
10.   
11.   
12.     /** 
13.      * @param args 
14.      */  
15.     public static void main(String[] args) {  
16. //      String str = "a aa,cat tiger.123dd 12ssss,asxdrt saxfdt asdgde";  
17.         Scanner in = new Scanner(System.in);  
18.         System.out.println("请任意的输入一串字符串：");  
19.         String str = in.nextLine();  
20.         System.out.println("str---" + str);  
21.         String reslut = getLongString(str);  
22.         System.out.println("----" + reslut);  
23.         in.close();  
24.     }  
25.     /** 
26.      * 找出一串字符串中最长的字符 
27.      * @param str 
28.      * @return 
29.      */  
30.     private static String getLongString(String str) {  
31.         String reg = "[ .,]";  
32.         String[] arr = str.split(reg);  
33.         ArrayList<String> result = new ArrayList<String>();  
34.         int length = 0;  
35.         for (int i = 0; i < arr.length; i++) {  
36.             System.out.println(arr[i]);  
37.             // 获得长度  
38.             if (length<arr[i].length()) {  
39.                 length = arr[i].length();  
40.                 result.add(arr[i]);  
41.             }  
42.         }  
43.         return result.get(result.size()-1);  
44.     }  
45.   
46.   
47. }  

10. 功能描述：将字符串中的字母全部替换成字母的下一个字母，
要是最后一位是z或Z则替换为a或A。
输入：aBxyZ
输出：bCyzA

[java]  view plain  copy

1. import java.util.Scanner;  
2.   
3.   
4.   
5.   
6. public class TransNext {  
7.   
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         Scanner in = new Scanner(System.in);  
14.         System.out.println("请输入一串字符串（大小写字母）：");  
15.         String str = in.nextLine();  
16.         String reg = "^[A-Za-z]+$";  
17. //      String reg2 = "^[A-Z]$";  
18.         if (str.matches(reg)) {  
19.             String result = transNext(str);  
20.             System.out.println("转换后的字符串：" + result);  
21.         }else {  
22.             System.out.println("输入不符合要求！");  
23.         }  
24.         in.close();  
25.     }  
26.     /** 
27.      * 将字符串中的字母全部替换成字母的下一个字母 
28.      * @param str 目标字符串 
29.      * @return 
30.      */  
31.     private static String transNext(String str) {  
32.         char[] charArray = str.toCharArray();  
33.         char[] newArray = new char[charArray.length];  
34.         for (int i = 0; i < charArray.length; i++) {  
35.             newArray[i] = (char) (charArray[i]+ 1);  
36.             if (charArray[i] =='Z') {  
37.                 newArray[i] = 'A';  
38.             }  
39.             if (charArray[i] =='z') {  
40.                 newArray[i] = 'a';  
41.             }  
42.         }  
43.         return String.valueOf(newArray);  
44.     }  
45.   
46.   
47. }  

11. 功能描述：判断一个字符串中是否只含有相同的子字符串（子串长度>=2）
输入：abab 
返回：true
输入：abcd
返回：false

[java]  view plain  copy

1. import java.util.HashMap;  
2. import java.util.Map;  
3. import java.util.Scanner;  
4.   
5.   
6. public class CheckStr {  
7.   
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         Scanner in = new Scanner(System.in);  
14.         System.out.println("请输入一串字符：");  
15.         String str = in.nextLine();  
16.         in.close();  
17.         boolean result = checkString(str);  
18.         System.out.println("结果--" + result);  
19.     }  
20.   
21.   
22.     public static boolean checkString(String data) {  
23.         boolean result = false;  
24.         Map<Character, Integer> map = new HashMap<Character, Integer>();  
25.         char[] array = data.toCharArray();  
26.         for (int i = 0; i < array.length; i++) {  
27.             if (!map.containsKey(array[i])) {  
28.                 result = false;  
29.                 map.put(array[i], 1);  
30.             }else {  
31.                 result = true;  
32.             }  
33.         }  
34.         return result;  
35.     }  
36. }  

12. 功能描述：已知：yi er san si wu liu qi ba jiu 分别对应123456789，
对一段只含有这几种字符串的字符串进行转换，如：
输入：yiersansan
输出：1233


   

[java]  view plain  copy

1. public class Tran2Num {  
2.   
3.   
4. /** 
5.  * 功能描述：已知：yi er san si wu liu qi ba jiu 分别对应123456789， 
6.  * 对一段只含有这几种字符串的字符串进行转换，如： 输入：yiersansan 输出：1233 
7.  *  
8.  * @param args 
9.  */  
10. public static void main(String[] args) {  
11.     String str = "yiersansansisiwuwu";  
12.     String number = trunNumber(str);  
13.     System.out.println("转换输出的结果--" + number);  
14. }  
15.   
16.   
17. public static String trunNumber(String data) {  
18.     String result = "";  
19.     String str[] = {"yi","er","san","si","wu","liu","qi"," ba","jiu"};  
20.     for (int i = 0; i < 9; i++) {  
21.         if (data.contains(str[i])) {  
22.             result = data.replace(str[i], String.valueOf(i+1));  
23.             data = result;  
24.         }  
25.     }  
26.     return result;  
27. }  

13. 功能描述：删除字符串中字符个数最少的字符，最少字符串有多个，最少的要全部删除
               然后返回该子字符串。
输入：asdasdas
输出：asasas

[java]  view plain  copy

1. import java.util.ArrayList;  
2. import java.util.Arrays;  
3. import java.util.HashMap;  
4. import java.util.List;  
5. import java.util.Map;  
6. import java.util.Scanner;  
7.   
8.   
9. public class DeleteMin {  
10.   
11.   
12.     /** 
13.      * 功能描述：删除字符串中字符个数最少的字符，最少字符串有多个，最少的要全部删除 然后返回该子字符串。 
14.      * 输入：asdasdas 输出：asasas 
15.      *  
16.      * @param args 
17.      */  
18.     public static void main(String[] args) {  
19.         //String str = "asdasdas";  
20.         Scanner in = new Scanner(System.in);  
21.         System.out.println("请输入一串字符串：");  
22.         String str = in.nextLine();  
23.         in.close();  
24.         List<Character> deleteChar = deleteLittle(str);  
25.         for (Character character : deleteChar) {  
26.             str = str.replace(character.toString(), "");  
27.        //System.out.println("出现次数最少的字符---" + character.toString());  
28.         }  
29.         System.out.println("删除后的字符串---" + str);  
30.     }  
31.   
32.   
33.     private static List<Character> deleteLittle(String str) {  
34.         // 统计那些字符串的个数最少  
35.         Map<Character, Integer> map = new HashMap<Character, Integer>();  
36.         char[] charArray = str.toCharArray();  
37.         for (int i = 0; i < charArray.length; i++) {  
38.             if (!map.containsKey(charArray[i])) {  
39.                 map.put(charArray[i], 1);  
40.             } else {  
41.                 map.put(charArray[i], map.get(charArray[i]) + 1);  
42.             }  
43.         }  
44.         // 删除map中值最小的字符串  
45.         int[] values = new int[map.size()];  
46.         int i = 0;  
47.         for (Map.Entry<Character, Integer> e : map.entrySet()) {  
48.             // 获得值的大小  
49.             values[i++] = e.getValue();  
50.         }  
51.         // 排序  
52.         Arrays.sort(values);  
53.         // 得到最小值  
54.         int j = values[0];  
55.         List<Character> list = new ArrayList<Character>();  
56.         for (Map.Entry<Character, Integer> e : map.entrySet()) {  
57.             // 通过值获取键  
58.             if (e.getValue() == j) {  
59.                 Character key = e.getKey();  
60.                 list.add(key);  
61.             }  
62.         }  
63.         return list;  
64.     }  
65. }  

16. 功能描述：统计一个数字转为二进制后，0和1的个数，组成数组返回

输入：6

输出：{1,2}

[java]  view plain  copy

1. import java.util.Arrays;  
2. import java.util.HashMap;  
3. import java.util.Map;  
4. import java.util.Scanner;  
5.   
6. public class Int2ASSII {  
7.   
8.     /** 
9.      * @param args 
10.      */  
11.     public static void main(String[] args) {  
12. //      int i = 6;  
13.         Scanner in = new Scanner(System.in);  
14.         System.out.println("请输入一个数字：");  
15.         int i = in.nextInt();  
16.         in.close();  
17. //      String reg = "^[0-9]*$";  
18. //      if (!String.valueOf(i).matches(reg)) {  
19. //          System.out.println("请输入数字！");  
20. //      }  
21.         int[] result = trans(i);  
22.         System.out.println("输出---" + Arrays.toString(result));  
23.     }  
24.   
25.     /** 
26.      * 将数字转换成ASII码 
27.      *  
28.      * @param i 
29.      * @return 返回0和1的个数 
30.      */  
31.     private static int[] trans(int i) {  
32.         // 将整形转换成二进制  
33.         char[] charArray = Integer.toBinaryString(i).toCharArray();  
34.         Map<Character, Integer> map = new HashMap<Character, Integer>();  
35.         for (int j = 0; j < charArray.length; j++) {  
36.             if (!map.containsKey(charArray[j])) {  
37.                 map.put(charArray[j], 1);  
38.             } else {  
39.                 map.put(charArray[j], map.get(charArray[j]) + 1);  
40.             }  
41.         }  
42. //      int[] result = new int[2];  
43.         Integer integer = map.get('0');  
44.         Integer integer2 = map.get('1');  
45.         int[] result = {integer,integer2};  
46. //      for (Map.Entry<Character, Integer> entry : map.entrySet()) {  
47. //          if (entry.getKey() == '0') {  
48. //              result[0] = entry.getValue();  
49. //          } else {  
50. //              result[1] = entry.getValue();  
51. //          }  
52. //      }  
53.         return result;  
54.     }  
55.   
56. }  

17. 功能描述：对一个二进制数的每位进行0和1反转，求翻转后的二进制所对应的十进制

输入：1010

输出：5

[java]  view plain  copy

1. import java.util.Arrays;  
2.   
3.   
4. public class Binary2Int {  
5.   
6.     /** 
7.      * @param args 
8.      */  
9.     public static void main(String[] args) {  
10.         String str = "1010";  
11.         int result = binaryToInt(str);  
12.         System.out.println("反转后的值:" + result);  
13.     }  
14.     /** 
15.      * 对一个二进制数的每位进行0和1反转，求翻转后的二进制所对应的十进制 
16.      * @param str 
17.      * @return 
18.      */  
19.     private static int binaryToInt(String str) {  
20.         char[] array = str.toCharArray();  
21.         for (int i = 0; i < array.length; i++) {  
22.             if (array[i]=='0') {  
23.                 array[i]='1';  
24.             }else {  
25.                 array[i]='0';  
26.             }  
27.         }  
28.         System.out.println(Arrays.toString(array));  
29.         String result = "";  
30.         for (int i = 0; i < array.length; i++) {  
31.             result += array[i];  
32.         }  
33.         return Integer.parseInt(result, 2);  
34.     }  
35.   
36. }  

18. 功能描述：判断一个字符串中的"( )"是否配对

输入：if(a.equals(a))

输出：true

[java]  view plain  copy

1. public class IsMatch {  
2.   
3.     /** 
4.      * 判断一个字符串中的"( )"是否配对  
5.      * 输入：if(a.equals(a)) 输出：true 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         String str = "if(a.(equals(a)))";  
10.         boolean result = isMatch(str);  
11.         System.out.println("字符串中的()是否配对：" + result);  
12.     }  
13.   
14.     /** 
15.      * 判断（）内的字符是否匹配 
16.      *  
17.      * @param str 
18.      * @return 
19.      */  
20.     private static boolean isMatch(String str) {  
21.         boolean result = false;  
22.         int count = 0;  
23.         char[] array = str.toCharArray();  
24.         for (int i = 0; i < array.length; i++) {  
25.             if (array[i] == '(') {  
26.                 count++;  
27.             } else if (array[i] == ')') {  
28.                 count--;  
29.             }  
30.         }  
31.         if (count == 0) {  
32.             result = true;  
33.         }  
34.         return result;  
35.     }  
36.   
37. }  

19. 功能描述：查找一个字符串的子字符串集

输入：abab

输出：a b ab ba aba bab 

 

要求实现方法：

public List<String> getChildren(String data)

{

    List<String> list = new ArrayList<String>();

    //TODO

    return list;

}

[java]  view plain  copy

1. import java.util.ArrayList;  
2. import java.util.List;  
3.   
4. public class GetChildren {  
5.   
6.     /** 
7.      * 查找一个字符串的子字符串集 输入：abab 输出：a b ab ba aba bab 
8.      *  
9.      * @param args 
10.      */  
11.     public static void main(String[] args) {  
12.         String str = "ababc";  
13.         List<String> children = getChildren(str);  
14. //      System.out.println(children.toString());  
15.         for (String string : children) {  
16.             System.out.print(string+" ");  
17.         }  
18.     }  
19.   
20.     public static List<String> getChildren(String data) {  
21.         List<String> list = new ArrayList<String>();  
22.         for (int i = 1; i < data.length(); i++) {  
23.             for (int j = data.length() - i + 1; j > 0; j--) {  
24.                 String newStr = data.substring(data.length() - j - i + 1,  
25.                         data.length() - j + 1);  
26. //              System.out.println("----" + newStr);  
27.                 if (!list.contains(newStr)) {  
28.                     list.add(newStr);  
29.                 }  
30.             }  
31.         }  
32.         return list;  
33.     }  
34. }  

21. 程序实现目标： 输入一个字符，将字符转换为小写，将其对应的ASCII值加5后，输出结果。

程序要求：若其值加5后的字符值大于'z',将其转换成从a开始的字符。

输入：‘A’

输出：‘f’

[java]  view plain  copy

1. public class Trans {  
2.   
3.     public static void main(String[] args) {  
4.         char input = 'X';  
5.         char output = trans(input);  
6.         System.out.println(output);  
7.     }  
8.     /** 
9.      * 将大写字母转换成小写字母再加5 
10.      * @param input 
11.      * @return 
12.      */  
13.     private static char trans(char input) {  
14.         // 将大写转为小写  
15.         char result = (char) (Character.toLowerCase(input) + 5);  
16.         if (result>'z') {  
17.             result = (char) (result-26);  
18.         }  
19.         return result;  
20.     }  
21.   
22. }  

22. 要求：将一个二维数组进行逆序，逆序后所有的元素行列不定，进行随机排列

①先把数组每一行逆序

②再把逆序后每一行进行随机排列

如：{{4,3,32,5},{1,2,3,4},{9,6,5,4}};

⇒4 6 5 9 
　3 4 2 1 
　5 4 32 3

[java]  view plain  copy

1. import java.util.Arrays;  
2. import java.util.Random;  
3.   
4. public class ArraySort {  
5.   
6.     /** 
7.      * @param args 
8.      */  
9.     public static void main(String[] args) {  
10.         int input[][] = { { 4, 3, 32, 5 }, { 1, 2, 3, 4 }, { 9, 6, 5, 4 } };  
11.         int output[][] = arraySort(input);  
12.         for (int i = 0; i < output.length; i++) {  
13.             System.out.println(Arrays.toString(input[i]));  
14.         }  
15.     }  
16.   
17.     /** 
18.      * ①先把数组每一行逆序 ②再把逆序后每一行进行随机排列 
19.      *  
20.      * @param input 
21.      * @return 
22.      */  
23.     private static int[][] arraySort(int[][] input) {  
24.         int[] temp = null;  
25.         for (int i = 0; i <= input.length / 2; i++) {  
26.             // 先把数组每一行逆序  
27.             temp = input[i];  
28.             input[i] = input[input.length - 1 - i];  
29.             input[input.length - 1 - i] = temp;  
30.   
31.         }  
32.         for (int i = 0; i < input.length; i++) {  
33.             int tmp = 0;  
34.             for (int j = 0; j < input[i].length; j++) {  
35.                 // 产生[0-len)的数  
36.                 int n = (int) (Math.random()*(input[i].length));  
37.                 int m = (int) (Math.random()*(input[i].length));  
38.                 // 随机交换数据  
39.                 tmp = input[i][m];  
40.                 input[i][m] = input[i][n];  
41.                 input[i][n] = tmp;  
42.             }  
43.         }  
44.         return input;  
45.     }  
46.   
47. }  

24. 分解质因数

eg：输入 28

输出 2*2*7

[java]  view plain  copy

1. public class Test {  
2.   
3.     /** 
4.      *  
5.      * @param args 
6.      */  
7.     public static void main(String[] args) {  
8.         int m = 28;  
9.         String result = perenum(m);  
10.         System.out.println("因数--" + result);  
11.     }  
12.   
13.     private static String perenum(int m) {  
14.         StringBuffer sb = new StringBuffer();  
15.         int tmp = m;  
16.         int i = 0;  
17.         while (true) {  
18.             for (i = 2; i <= tmp; i++) {  
19.                 if (tmp % i == 0) {  
20.                     tmp = tmp / i;  
21.                     sb.append(i + "*");  
22.                     break;  
23.                 }  
24.             }  
25.             if (tmp == 1){  
26.                 break;  
27.             }  
28.         }  
29.         // 删除最后一个字符  
30.         String result = sb.toString().substring(0, sb.toString().length()-1);  
31.         return result;  
32.     }  
33. }  

26. 二维数组转置

例：1 2 3

    4 5 6

转置

    1 4

    2 5

   3 6

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. import java.util.Arrays;  
4.   
5. /** 
6.  * 二维数组倒置 
7.  *  二维数组转置 
8. 例：1 2 3 
9.     4 5 6 
10. 转置 
11.     1 4 
12.     2 5 
13.    3 6 
14.  * @author cqu_zhu 
15.  * 
16.  */  
17. public class TransArray {  
18.   
19.     /** 
20.      * @param args 
21.      */  
22.     public static void main(String[] args) {  
23.         int [][] input = {{1,2,3},{4,5,6}};  
24.         int [][] output = inversionArray(input);  
25.         for (int i = 0; i < output.length; i++) {  
26.             for (int j = 0; j < output[i].length; j++) {  
27.                 System.out.print(output[i][j]+" ");  
28.             }  
29.             System.out.println();  
30.         }  
31.     }  
32.   
33.     private static int[][] inversionArray(int[][] input) {  
34.         int result[][] = new int[input[0].length][input.length];  
35.         for (int i = 0; i < input.length; i++) {  
36.             for (int j = 0; j < input[i].length; j++) {  
37.                 result[j][i] = input[i][j];  
38.             }  
39.         }  
40.         return result;  
41.     }  
42.   
43. }  

27. 功能描述：输入字符串，将该字符串中数字放到非数字的后面，并保持原有顺序不变。

例如：h3a2p0p1y----------happy3201

public String  childStr(String inputStr){

}

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. import java.util.Scanner;  
4.   
5. /** 
6.  * 输入字符串，将该字符串中数字放到非数字的后面，并保持原有顺序不变。 例如：h3a2p0p1y----------happy3201 
7.  *  
8.  * @author cqu_zhu 
9.  *  
10.  */  
11. public class FindCharAndNum {  
12.   
13.     /** 
14.      * @param args 
15.      */  
16.     public static void main(String[] args) {  
17. //      String str = "h3a2p0p1y";  
18.         Scanner in = new Scanner(System.in);  
19.         System.out.println("请随机输入字母和字符串：");  
20.         String str = in.nextLine();  
21.         String reg = "^[0-9a-zA-Z]*$";  
22.         in.close();  
23.         if (!str.matches(reg)) {  
24.             System.out.println("输入的字符串不符合要求");  
25.             return;  
26.         }  
27.         String result = childStr(str);  
28.         System.out.println(result);  
29.     }  
30.     public static String  childStr(String inputStr){  
31.         StringBuffer charBuffer = new StringBuffer();  
32.         StringBuffer numBuffer = new StringBuffer();  
33.         char[] array = inputStr.toCharArray();  
34.         // 字母的正则表达式  
35.         String reg = "^[a-zA-Z]*$";  
36.         String reg2 = "^[0-9]*$";  
37.         for (int i = 0; i < array.length; i++) {  
38.             // 如果是字母  
39.             if (String.valueOf(array[i]).matches(reg)) {  
40.                 charBuffer.append(array[i]);  
41.             }else if(String.valueOf(array[i]).matches(reg2)){  
42.                 numBuffer.append(array[i]);  
43.             }  
44.         }  
45.         return charBuffer.toString()+numBuffer.toString();  
46.     }  
47. }  

28. 输入一个身份证号码（15位和18位）和一个年份，计算现在的年龄（忽略非法参数）

eg：610618199001020065  2011

输出：21

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. /** 
4.  * 输入一个身份证号码（15位和18位）和一个年份，计算现在的年龄（忽略非法参数） eg：610618199001020065 2011 输出：21 
5.  *  
6.  * @author cqu_zhu 
7.  *  
8.  */  
9. public class Demo28 {  
10.   
11.     /** 
12.      * @param args 
13.      */  
14.     public static void main(String[] args) {  
15. //      String ID = "610618199001020065";  
16.         String ID ="110105710923582";  
17.         int year = 2015;  
18.         int age = countAge(ID,year);  
19.         System.out.println("年龄---" + age);  
20.     }  
21.   
22.     private static int countAge(String ID, int year) {  
23.         String date = "";  
24.         //7-12位出生年月日,比如670401代表1967年4月1日  
25.         if (ID.length() == 15) {  
26.             String d = ID.substring(6, 8);  
27.             date = "19"+d;  
28.         }else if(ID.length() ==18){  
29.             date = ID.substring(6,10);  
30.         }  
31.         int age = year -Integer.parseInt(date);  
32.         System.out.println(date);  
33.         return age;  
34.     }  
35. }  

29.  输入一个字符串，如果是小写则转换成相应的大写字母的后五位，如果是 VWXYZ 则转换成 abcde, 其他的都不变，例如：“ aDsR154+-/. ”则应该输出为“ FDXR154+-/. ”

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. /** 
4.  * 输入一个字符串，如果是小写则转换成相应的大写字母的后五位，如果是VWXYZ则转换成abcde,其他的都不变，例如：“aDsR154+-/.”则应该输出为“ 
5.  * FDXR154+-/.” 
6.  *  
7.  * @author cqu_zhu 
8.  *  
9.  */  
10. public class Demo29 {  
11.   
12.     public static void main(String[] args) {  
13.         String str = "aDsR154+-/.";  
14.         String reslut = parseStr(str);  
15.         System.out.println("转换后的字符串---" + reslut);  
16.     }  
17.   
18.     private static String parseStr(String str) {  
19.         char[] array = str.toCharArray();  
20.         String reg = "^[a-z]*$";  
21.         for (int i = 0; i < array.length; i++) {  
22.             if (String.valueOf(array[i]).matches(reg)) {  
23.                 // 把小写转换为大写，并后退5位  
24.                 array[i] = (char) (Character.toUpperCase(array[i]) + 5);  
25.                 if (array[i]>'Z') {  
26.                     array[i]= (char) (array[i]-26);  
27.                 }  
28.             }  
29.         }  
30.         StringBuffer buffer = new StringBuffer();  
31.         for (int i = 0; i < array.length; i++) {  
32.             buffer.append(array[i]);  
33.         }  
34.         return buffer.toString();  
35.     }  
36.   
37. }  

31. 删除一个字符串里出现次数最多的子字符串

如果有多个出现次数相同的并且出现次数最多则将多个全部删除比如abbccd得到结果 ad

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. /** 
7.  * 删除一个字符串里出现次数最多的子字符串 
8. 如果有多个出现次数相同的并且出现次数最多则将多个全部删除比如abbccd得到结果 ad 
9.  * @author cqu_zhu 
10.  * 
11.  */  
12. public class Demo30 {  
13.   
14.     /** 
15.      * @param args 
16.      */  
17.     public static void main(String[] args) {  
18.         String str = "abbccdeefff";  
19.         String result = deleteMaxChar(str);  
20.         System.out.println(result);  
21.     }  
22.     /** 
23.      * 删除字符串字符出现次数最多的字符 
24.      * @param str 
25.      * @return 
26.      */  
27.     private static String deleteMaxChar(String str) {  
28.         char[] array = str.toCharArray();  
29.         Map<Character,Integer> map = new HashMap<Character,Integer>();  
30.         for (int i = 0; i < array.length; i++) {  
31.             if(!map.containsKey(array[i])){  
32.                 map.put(array[i], 1);  
33.             }else {  
34.                 map.put(array[i], map.get(array[i])+1);  
35.             }  
36.         }  
37.         int m =0;  
38.         // 得出字符最大值  
39.         for(Map.Entry<Character, Integer> entry :map.entrySet()){  
40.             if (entry.getValue() > m) {  
41.                 m = entry.getValue();  
42.             }  
43.         }  
44.         // 根据字符最大值得到相应的字符  
45.         for(Map.Entry<Character, Integer> entry :map.entrySet()){  
46.             if (entry.getValue() ==m) {  
47.                 String replace = str.replace(String.valueOf(entry.getKey()), "");  
48.                 str = replace;  
49.             }  
50.         }  
51.         return str;  
52.     }  
53.   
54. }  

32. 判断字符串首字母就大写，非首字母小写

1、如输入 Good 返回 TRUE

2、过程中不需要输出任何IO流。

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. /** 
4.  * 32. 判断字符串首字母就大写，非首字母小写 1、如输入 Good 返回 TRUE 2、过程中不需要输出任何IO流。 
5.  *  
6.  * @author cqu_zhu 
7.  *  
8.  */  
9. public class Demo32 {  
10.   
11.     /** 
12.      * @param args 
13.      */  
14.     public static void main(String[] args) {  
15.         String str = "Good";  
16.         String result = fristChar(str);  
17.         System.out.println(result);  
18.     }  
19.   
20.     private static String fristChar(String str) {  
21.         String result = "";  
22.         String reg = "^[A-Z]*$";  
23.         char[] array = str.toCharArray();  
24.         if (String.valueOf(array[0]).matches(reg)) {  
25.             result ="TRUE";  
26.         }else {  
27.             result ="FALSE";  
28.         }  
29.         return result;  
30.     }  
31.   
32. }  

33. 将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”

所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. import java.util.Arrays;  
4.   
5. /** 
6.  * 33. 将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I” 
7.  * 所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符 
8.  *  
9.  * @author cqu_zhu 
10.  *  
11.  */  
12. public class Demo33 {  
13.   
14.     /** 
15.      * @param args 
16.      */  
17.     public static void main(String[] args) {  
18.         String str = "I am a boy";  
19.         String result = inversionString(str);  
20.         System.out.println(result);  
21.     }  
22.   
23.     private static String inversionString(String str) {  
24.         String[] splitStr= str.split(" ");  
25.         String[] newStr = new String[splitStr.length];  
26.         for (int i = 0; i < splitStr.length; i++) {  
27.             newStr[splitStr.length -i-1] = splitStr[i];  
28.         }  
29.         StringBuffer result = new StringBuffer();  
30.         for (int i = 0; i < splitStr.length; i++) {  
31.             result.append(newStr[i] + " ");  
32.         }  
33.         return result.toString();  
34.     }  
35.   
36. }  

34. 题目背景

写出一个程序，接受一个浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整

接口

int round(double d)

举例

-4.5 四舍五入的结果是-4

4.4 四舍五入的结果是4

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. import java.util.Arrays;  
4.   
5. /** 
6.  * 33. 将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I” 
7.  * 所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符 
8.  *  
9.  * @author cqu_zhu 
10.  *  
11.  */  
12. public class Demo34 {  
13.   
14.     /** 
15.      * @param args 
16.      */  
17.     public static void main(String[] args) {  
18.         double d = -3.65;  
19.         int result = round(d);  
20.         System.out.println("返回的结果--" + result);  
21.     }  
22.   
23.     private static int round(double d) {  
24.         String str = String.valueOf(d);  
25.         String subStr = str.substring(str.indexOf(".") + 1,  
26.                 str.indexOf(".") + 2);  
27.         int i = Integer.parseInt(subStr);  
28.         int reg = 0;  
29.         if (i >= 5) {  
30.             // 返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。  
31.             reg = (int) Math.ceil(d);  
32.         } else {  
33.             // 返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。  
34.             reg = (int) Math.floor(d);  
35.         }  
36.         return reg;  
37.     }  
38.   
39. }  

35.数列求和

编写程序，输入一个正整数n，求下列算式的值。要求定义和调用函数fact(k)计算k的阶乘，函数返回值的类型是double。

1+1/2!+ .... +1/n!

输出保留5位小数。

下面是一些合理的表达式的例子：

Input         5                

Output      1.71667   

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3.   
4. /** 
5.  * 编写程序，输入一个正整数n，求下列算式的值。要求定义和调用函数fact(k)计算k的阶乘，函数返回值的类型是double。 1+1/2!+ .... 
6.  * +1/n! 输出保留5位小数。 下面是一些合理的表达式的例子： Input 5 Output 1.71667 
7.  *  
8.  * @author cqu_zhu 
9.  *  
10.  */  
11. public class Demo35 {  
12.   
13.     /** 
14.      * @param args 
15.      */  
16.     public static void main(String[] args) {  
17.         int k = 5;  
18.         double result = result(k);  
19.         if (result>1.5) {  
20.             // 保留5位有效数字  
21.             String str = String.valueOf(result);  
22.             String reg = str.substring(str.indexOf(".")+6, str.indexOf(".")+7);  
23.             String m = str.substring(str.indexOf(".")+1, str.indexOf(".")+6);  
24.             String in = str.substring(str.indexOf(".")-1, str.indexOf(".")+1);  
25.             int n = 0;  
26.             if (Integer.parseInt(reg)>=5) {  
27.                 n = Integer.parseInt(m)+1;  
28.             }else {  
29.                 n = Integer.parseInt(m);  
30.             }  
31.             System.out.println("---" + in + n);  
32.         }else {  
33.             System.out.println("---" + result);  
34.         }  
35.     }  
36.     /** 
37.      * 求阶乘的倒数 
38.      * @param k 
39.      * @return 
40.      */  
41.     private static double result(int k){  
42.         double d = 0;  
43.         for (int i = 1; i <= k; i++) {  
44.             d +=(double)1/fact(i);  
45.         }  
46.         return d;  
47.     }  
48.     /** 
49.      * 计算k的阶乘 
50.      * @param i 
51.      * @return 
52.      */  
53.     private static int fact(int k) {  
54.         int i = 1;  
55.         for (int j = 1; j <= k; j++) {  
56.             i =j*i;  
57.         }  
58.         return i;  
59.     }  
60.   
61. }  

36. 计算整数各个数位之和 

描述: 要求使用递归实现，计算整数各个数位之和。

举例： 123 --> 1+2+3 = 6

运行时间限制: 无限制 

内存限制: 无限制 

输入: 0xff ff ff ff以内的整数

输出: NA

样例输入: 123 

样例输出: 6 

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. /** 
4.  * 计算整数各个数位之和 描述: 要求使用递归实现，计算整数各个数位之和。 举例： 123 --> 1+2+3 = 6 运行时间限制: 无限制 内存限制: 
5.  * 无限制 输入: 0xff ff ff ff以内的整数 输出: NA 样例输入: 123 样例输出: 6 
6.  *  
7.  * @author cqu_zhu 
8.  *  
9.  */  
10. public class Demo36 {  
11.   
12.     /** 
13.      * @param args 
14.      */  
15.     public static void main(String[] args) {  
16.         int num = 1234351363;  
17.         int result = bitSum(num);  
18.         System.out.println("各个位相加得到的和--" + result);  
19.     }  
20.   
21.     /** 
22.      * 递归求各个各个数位之和 
23.      *  
24.      * @param k 
25.      * @return 
26.      */  
27.     private static int bitSum(int num) {  
28.         int tmp = 0;  
29.         if (num > 10) {  
30.             tmp += num % 10 + bitSum(num / 10);  
31.         } else {  
32.             tmp = num;  
33.         }  
34.         return tmp;  
35.     }  
36.   
37. }  

37.提取不重复的整数 

描述: 输入一个int型32位整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

运行时间限制: 10 Sec 

内存限制: 无限制 

输入: 整数，如9876673

注意：

1、整数最后的0，请忽略，例如：输入1750，输出：571

2、负数，保留'-'在前面，例如：输入-175，输出：-571

输出: 整数，如37689

样例输入: 9876673 

样例输出: 37689  

[java]  view plain  copy

1. package com.zjp.huawei;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Arrays;  
5. import java.util.List;  
6.   
7. /** 
8.  * 输入一个int型32位整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。 
9.  * @author cqu_zhu 
10.  * 
11.  */  
12. public class Demo37 {  
13.   
14.     /** 
15.      * @param args 
16.      */  
17.     public static void main(String[] args) {  
18.         int num = -9876673;  
19.         if (num <0) {  
20.             int abs = Math.abs(num);  
21.             int result = getConvertInt(abs);  
22.             System.out.println("-" + result);  
23.         }else {  
24.             int result = getConvertInt(num);  
25.             System.out.println(String.valueOf(result));  
26.         }  
27.     }  
28.   
29.     private static int getConvertInt(int num) {  
30.         String str = String.valueOf(num);  
31.         char[] array = str.toCharArray();  
32.         List<Character> list = new ArrayList<Character>();  
33.         for (int i = 0; i < array.length; i++) {  
34.             if (!list.contains(array[i])) {  
35.                 list.add(array[i]);  
36.             }  
37.         }  
38.         List<Character> newList = new ArrayList<Character>();  
39.         for (int i = 0; i <list.size(); i++) {  
40.             newList.add(list.get(list.size()-1-i));  
41.         }  
42.         StringBuffer buffer = new StringBuffer();  
43.         for (Character character : newList) {  
44.             buffer.append(character);  
45.         }  
46.         return Integer.parseInt(buffer.toString());  
47.     }  
48.   
49. }