今天讲到了String类, String类中那些有的没的的构造方法和成员方法了解的差不多.但是晚间做作业的时候,遇上了难题..不知道从哪下手

题目是这样的:3.分析以下需求，并用代码实现：
                (1)定义数字字符串数组{"010","3223","666","7890987","123123"}
                (2)判断该数字字符串数组中的数字字符串是否是对称(第一个数字和最后一个数字相等，第二个数字和倒数第二个数字是相等的，依次类推)的，并逐个输出
                (3)如：010 是对称的，3223 是对称的，123123 不是对称的
               
                提示：循环获取字符串的每一个字符，依次比较第一个和最后一个，第二个和倒数第二个。。。

还请各位同学耐心指教,谢过.

在线等...停急的.

1. package com.heima.test;
   
2. 
   
3. /**
   
4. * 题目是这样的:3.分析以下需求，并用代码实现： (1)定义数字字符串数组{"010","3223","666","7890987","123123"}
   
5. * (2)判断该数字字符串数组中的数字字符串是否是对称 (第一个数字和最后一个数字相等，第二个数字和倒数第二个数字是相等的，依次类推)的，并逐个输出
   
6. * (3)如：010 是对称的，3223 是对称的，123123 不是对称的
   
7. *
   
8. * 提示：循环获取字符串的每一个字符，依次比较第一个和最后一个，第二个和倒数第二个。。。
   
9. *
   
10. * @author Venus
    
11. *
    
12. */
    
13. public class Test9 {
    
14.         public static void main(String[] args) {
    
15.                 String[] strarr = { "010", "3223", "666", "7890987", "123123" };
    
16.                 for (int i = 0; i < strarr.length; i++) {
    
17.                         String temp = strarr[i];
    
18.                         boolean b = method(temp);
    
19.                         if(b)
    
20.                                 System.out.println(temp+" 是对称的.");
    
21.                         else{
    
22.                                 System.out.println(temp+" 是不对称的.");
    
23.                         }
    
24.                 }
    
25.         }
    
26. 
    
27.         static boolean method(String temp) {
    
28.                 int count =0;
    
29.                 for (int i = 0; i < temp.length() / 2; i++) {
    
30.                         if (temp.charAt(i) != temp.charAt(temp.length() - i - 1)) {
    
31.                                 count++;
    
32.                         }
    
33.                 }
    
34.                 if (count > 0)
    
35.                         return false;
    
36.                 return true;
    
37.         }
    
38. }
    

复制代码

我不加注释,看你能看懂么.方法不太好.

默默的说一句,楼上的不加注释,点招的时候老师如果看不懂,就不给分哦!!!或者说给不了满分的......

1. public static void main(String[] args) {
   
2.                 //获取每个字符串元素
   
3.                 //对称校验并输出
   
4.                 String[] str = {"010","3223","666","7890987","123123"};
   
5.                 outer:for (int i = 0; i < str.length; i++) {
   
6.                         char[] ch = str[i].toCharArray();                //字符串转字符数组
   
7. 
   
8.                         for (int j = 0;j < ch.length / 2;++j) {
   
9.                                 if (ch[j] != ch[ch.length -1 -j]) {
   
10.                                         System.out.print(str[i] + "不是对称的");
    
11.                                         if (i < str.length - 1)
    
12.                                                 System.out.print("，");
    
13.                                         continue outer;                                        //非对称输出后 跳过本次外层循环
    
14.                                 }
    
15.                         }
    
16.                         System.out.print(str[i] + "是对称的");
    
17.                         if (i < str.length - 1)
    
18.                                 System.out.print("，");
    
19.                 }
    
20.         }

复制代码

1. package com.heima.test;
   
2. 
   
3. public class Test3 {
   
4. 
   
5.         /**
   
6.          * 分析以下需求，并用代码实现：
   
7.                 (1)定义数字字符串数组{"010","3223","666","7890987","123123"}
   
8.                 (2)判断该数字字符串数组中的数字字符串是否是对称(第一个数字和最后一个数字相等，
   
9.                         第二个数字和倒数第二个数字是相等的，依次类推)的，并逐个输出
   
10.                 (3)如：010 是对称的，3223 是对称的，123123 不是对称的
    
11.                
    
12.                 提示：循环获取字符串的每一个字符，依次比较第一个和最后一个，第二个和倒数第二个。。。
    
13.                 思路:
    
14.                 1.定义一个标志flag,当flag为true时,表示一个数字字符串满足(2)中要求
    
15.                 2.循环遍历数组中的元素for循环,元素满足条件时,即flag=true时,输出打印这个元素
    
16.                 3.在for循环中内嵌一个for循环判断每个数字字符串是否满足(2)中要求,不满足要求,设置标记flag,为false,同时跳出内循环
    
17.          */
    
18.        
    
19.         public static void main(String[] args) {
    
20.                
    
21.                 String[] arr = {"010", "3223", "666", "7890987", "123123"};
    
22.                
    
23.                 printArray(arr);
    
24.                
    
25.         }
    
26. 
    
27.         public static void printArray(String[] arr) {
    
28.                
    
29.                 boolean flag = true;
    
30.                 for (int i = 0; i < arr.length; i++) {
    
31.                         for (int j = 0; j < arr[i].length()/2; j++) {
    
32.                                
    
33.                                 //获取字符数组中第(i+1)字符串中的第(j+1)个字符
    
34.                                 char ch1 = arr[i].charAt(j);
    
35.                                 //获取字符数组中第i个字符串中的倒数第(j+1)个字符
    
36.                                 char ch2 = arr[i].charAt(arr[i].length()-1-j);
    
37.                                 //判断这个两个字符是否相等
    
38.                                 if (ch1 != ch2) {                //不相等,不满足要求
    
39.                                         flag = false;                //不满足要求设置标记flag为false
    
40.                                         break;                                //跳出循环,停止判断第i个字符串,判断下一个字符串
    
41.                                 }
    
42.                         }
    
43.                         if (flag) {
    
44.                                 System.out.println(arr[i] + " 是对称的");
    
45.                         } else {
    
46.                                 System.out.println(arr[i] + " 是不对称的");
    
47.                         }
    
48.                 }
    
49.         }
    
50. 
    
51. }
    

复制代码

1. package com.heima.test;
   
2. 
   
3. public class Test3_Sb {
   
4. 
   
5.         /**
   
6.          * 分析以下需求，并用代码实现：
   
7.                 (1)定义数字字符串数组{"010","3223","666","7890987","123123"}
   
8.                 (2)判断该数字字符串数组中的数字字符串是否是对称(第一个数字和最后一个数字相等，
   
9.                         第二个数字和倒数第二个数字是相等的，依次类推)的，并逐个输出
   
10.                 (3)如：010 是对称的，3223 是对称的，123123 不是对称的
    
11.                
    
12.                 提示：循环获取字符串的每一个字符，依次比较第一个和最后一个，第二个和倒数第二个。。。
    
13.                 思路:
    
14.                 1.将字符串反转,如果反转后与字符串相同,则表示这个字符串是对称的
    
15.                         反转:        StringBuffer sb;        sb.reverse()方法
    
16.                         转换成字符串:        String str = sb.reverse().toString();
    
17.                         判断是否与原字符串相等:        str.equals(arr[i]);
    
18.                 2.使用for循环遍历数组中的元素,进行步骤一中的判断,满足输出这个数组元素是对称的,不满足输出这个元素是不对称的
    
19.          */
    
20.        
    
21.         public static void main(String[] args) {
    
22.                
    
23.                 String[] arr = {"010", "3223", "666", "7890987", "123123"};
    
24.                
    
25.                 for (int i = 0; i < arr.length; i++) {
    
26.                         StringBuffer sb = new StringBuffer(arr[i]);
    
27.                         String str = sb.reverse().toString();
    
28.                         if (str.equals(arr[i])) {
    
29.                                 System.out.println(arr[i] + " 是对称的!");
    
30.                         } else {
    
31.                                 System.out.println(arr[i] + " 是不对称的!");
    
32.                         }
    
33.                 }
    
34.                
    
35.         }
    
36. 
    
37. }

复制代码

目前所想出来的两种不同方法

要么将字符串转成字符数组，前后遍历比较，要么用字符容器里面的反转方法，直接比较字符

1. public class Test57 {
   
2.         public static void main(String[] args) {
   
3.                 String [] arr = {"010","3223","666","7890987","123123"};
   
4.                 for (int i = 0; i < arr.length; i++) {
   
5.                         if(new StringBuffer(arr[i]).reverse().toString().equals(arr[i]))
   
6.                                 System.out.println(arr[i]+"是对称的");
   
7.                         else System.out.println(arr[i]+"是不对称的");
   
8.                 }
   
9.         }
   
10. }

复制代码

我是你岁哥❤环 发表于 2016-6-15 07:40

大哥你这个方法很讨巧..   
思路是先反转,然后比较反转先后是否相等,相等就是对称的..赞!!

但是当时我们还没有学到StringBuffer的内容.后来我想出来了
把字符串数组遍历,每一个元素转换成一个数组"010"变成了{010}
之后按照数组的方法完成的比较,现在看来还是你这个方法快啊哈哈哈哈