1. package com.itheima;
   
2. class Symmetric
   
3. {
   
4.         private int i = 0;
   
5.         public boolean symmeteicTest(String s)
   
6.         {
   
7.                 int count = (s.length())/2;
   
8.                         for(;i<=count;i++)
   
9.                         {
   
10.                                         if(s.charAt(i)==s.charAt(s.length()-i-1))
    
11.                                                 return true;
    
12.                         }
    
13.                 //}else{
    
14.                         return false;
    
15.                         
    
16.                 //}
    
17.         }
    
18. }
    
19. 
    
20. 
    
21. public class Test2
    
22. {
    
23. 
    
24.         public static void main(String[] args) {
    
25.                 String s1="manttnam";
    
26.                 String s2="lkjvasdf";
    
27.                 String s3="zxcscxz";
    
28.                 String s4="asdssda";
    
29.                 Symmetric s =new Symmetric();
    
30.                 System.out.println("判断s1是否为对称字符串："+s1+":"+s.symmeteicTest(s1));
    
31.                 System.out.println("判断s2是否为对称字符串："+s2+":"+s.symmeteicTest(s2));
    
32.                 System.out.println("判断s3是否为对称字符串："+s3+":"+s.symmeteicTest(s3));
    
33.                 System.out.println("判断s4是否为对称字符串："+s4+":"+s.symmeteicTest(s4));
    
34.                 System.out.println(s1.length()/2);
    
35.                 System.out.println(s3.length()/2);
    
36. 
    
37.         }
    
38. 
    
39. }
    

复制代码

这里输出结果为判断s1是否为对称字符串：manttnam:true
判断s2是否为对称字符串：lkjvasdf:false
判断s3是否为对称字符串：zxcscxz:false
判断s4是否为对称字符串：asdssda:false
4
3




上面是原本的代码。我根据推理，S3是7位，我也特意打印了长度除2等于3呀。证明我就算字符串是单数，也不会错吧。是true吧!
于是我修改了S3的字符串写成了S1一样的字符串。怎么结果还是一样的！明明S1是true呀   我晕了

1. package com.itheima;
   
2. class Symmetric
   
3. {
   
4.         private int i = 0;
   
5.         public boolean symmeteicTest(String s)
   
6.         {
   
7.                 int count = (s.length())/2;
   
8.                         for(;i<=count;i++)
   
9.                         {
   
10.                                         if(s.charAt(i)==s.charAt(s.length()-i-1))
    
11.                                                 return true;
    
12.                         }
    
13.                 //}else{
    
14.                         return false;
    
15.                         
    
16.                 //}
    
17.         }
    
18. }
    
19. 
    
20. 
    
21. public class Test2
    
22. {
    
23. 
    
24.         public static void main(String[] args) {
    
25.                 String s1="manttnam";
    
26.                 String s2="lkjvasdf";
    
27.                 String s3="manttnam";
    
28.                 String s4="manttnam";
    
29.                 Symmetric s =new Symmetric();
    
30.                 System.out.println("判断s1是否为对称字符串："+s1+":"+s.symmeteicTest(s1));
    
31.                 System.out.println("判断s2是否为对称字符串："+s2+":"+s.symmeteicTest(s2));
    
32.                 System.out.println("判断s3是否为对称字符串："+s3+":"+s.symmeteicTest(s3));
    
33.                 System.out.println("判断s4是否为对称字符串："+s4+":"+s.symmeteicTest(s4));
    
34.                 System.out.println(s1.length()/2);
    
35.                 System.out.println(s3.length()/2);
    
36. 
    
37.         }
    
38. 
    
39. }
    

复制代码

这里输出结果为判断s1是否为对称字符串：manttnam:true
判断s2是否为对称字符串：lkjvasdf:false
判断s3是否为对称字符串：zxcscxz:false
判断s4是否为对称字符串：asdssda:false
4
3

楼主不应该把for循环里面了的局部变量i  定义成成员变量 因为成员变量随着对象的消失而消失 而局部变量随着方法的结束而结束 再调用一次后并没有消失 所以后面i的初始化值不是0

楼主你的判断出问题了，循环中有一个位置上的字符相同你就判断为对称了。
正确的做法是，定义一个标记，如果有一个不相同的就改变这个标记，最后判断标记来确定是否是对称的。

1. 
   
2. class Symmeteic {
   
3. //private int i = 0;
   
4. 
   
5. public boolean symmeteicTest(String s) {
   
6. int count = (s.length()) / 2;
   
7. boolean flag = true;// 定义标记
   
8. for (int i=0; i <= count; i++) {
   
9. if (s.charAt(i) != s.charAt(s.length() - i - 1))
   
10. {
    
11. flag = false;
    
12. }
    
13. }
    
14. return flag;
    
15. }
    
16. }
    
17. public class Test22{
    
18. 
    
19. public static void main(String[] args) {
    
20. String s1 = "manttnam";
    
21. String s2 = "lkjvasdf";
    
22. String s3 = "manttnam";
    
23. String s4 = "manttnam";
    
24. Symmeteic s = new Symmeteic();
    
25. System.out.println("判断s1是否为对称字符串：" + s1 + ":" + s.symmeteicTest(s1));
    
26. System.out.println("判断s2是否为对称字符串：" + s2 + ":" + s.symmeteicTest(s2));
    
27. System.out.println("判断s3是否为对称字符串：" + s3 + ":" + s.symmeteicTest(s3));
    
28. System.out.println("判断s4是否为对称字符串：" + s4 + ":" + s.symmeteicTest(s4));
    
29. System.out.println(s1.length() / 2);
    
30. System.out.println(s3.length() / 2);
    
31. 
    
32. }
    
33. 
    
34. }

复制代码

对称字符串的题么？ 如果是的话  你直接把字符串翻转 如果相等就是对称 不相等就不对称  就这么简单。。。貌似不需要搞这么复杂把

1. public class StringRevers {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 String str = "abba";
   
5.                
   
6.                 System.out.println(symmeteicTest(str));
   
7. 
   
8.         }
   
9. 
   
10.         private static boolean symmeteicTest(String str) {
    
11.                 StringBuilder sb= new StringBuilder();
    
12.                 sb.append(str);
    
13.                 String str2 = sb.reverse().toString();
    
14.                
    
15.                 return str2.equals(str);
    
16.         }
    
17. 
    
18. }

复制代码

你试试我这方法管用不

public class Test2 {

        public static void main(String[] args) {
                //用一系列的值进行测试
                String str ="aba";
                /*String str1 = "abba";
                String str2 = "aaa";
                String str3 = "mnanm";
                String str4 = "sgfbd";
                String str6 = "abcaba";*/
               
                System.out.println(symmetryString(str));

        }
        public static String symmetryString(String str){
                //将字符串转换成字符数组
                char[] arr =str.toCharArray();
                //定义了二个变量，min代表最小角标，max代表最大角标
                int min = 0;
                int max = arr.length-1;
                //判断字符数组的（长度-1）摸2是否等于0
                if(max%2==0)
                {
                        //如果当min的值不等于max时候，就一直循环。循环判断两个相对应的字符是否相等
                        while(min!=max)
                        {
                                if(arr[min]==arr[max])
                                {
                                        //如果条件成立，对min自增，max自减
                                        min++;
                                        max--;
                                }else//如果不相等，就返回不是对称字符串。
                                {
                                        return str+"不是对称的字符串";
                                }
                        }
                        //循环完后，条件都相等就返回是对称的字符串
                        return str+"是对称的字符串";
                       
                }else//如果摸2的值不等于0，就执行以下代码
                {
                        //如果当min的值小于max时候，就一直循环。循环判断两个相对应的字符是否相等
                        while(min<max)
                        {
                                if(arr[min]==arr[max])
                                {
                                        min++;
                                        max--;
                                }else
                                {
                                        return str+"不是对称的字符串";
                                }
                               
                        }
                        return str+"是对称的字符串";
                }
               
        }
}
  我考过这道题 这是我自己的思路 注释都有，你可以看看，希望能帮到你

xiao飞 发表于 2015-2-1 22:59
public class Test2 {

        public static void main(String[] args) {

这样搞太麻烦吧，，，，直接字符串翻转 比较是否相等  就可把。。。。为何每人采纳我的方法呢。。难道是技术含量 太低的原因么

希冀 发表于 2015-2-1 13:22
楼主不应该把for循环里面了的局部变量i  定义成成员变量 因为成员变量随着对象的消失而消失 而局部变量随着 ...

成员变量随着对象的消失而消失吗？不是还有什么静态成员变量吗，它是类相关的啊？？

guiqi225 发表于 2015-2-2 10:35
成员变量随着对象的消失而消失吗？不是还有什么静态成员变量吗，它是类相关的啊？？ ...

静态变量又称类变量，随着类的加载而加载，消失而消失，静态变量存在于方法区中的，而且可以被类名直接调用

wf111sxwf 发表于 2015-2-2 10:05
这样搞太麻烦吧，，，，直接字符串翻转 比较是否相等  就可把。。。。为何每人采纳我的方法呢。。难道是 ...

如果出现数字呢？？？  你考虑到没有

guiqi225 发表于 2015-2-2 10:35
成员变量随着对象的消失而消失吗？不是还有什么静态成员变量吗，它是类相关的啊？？ ...

是的成员变量随着对象的消失而消失 静态是优先于对象存在的  随着类的加载而加载

判断字符串是否对称

1. public class Test1 {
   
2.         @SuppressWarnings("resource")
   
3.         public static void main(String[]args){
   
4.                 System.out.println("输入一个字符串");
   
5.                 Scanner scan=new Scanner(System.in);
   
6.                 String str=scan.next();
   
7.                 byte[] b=str.getBytes();
   
8.                 int len=b.length;
   
9.                 //sum作为计数器，计算字符串中对称的字符对的个数
   
10.                 int sum=0;
    
11.                 //输入的字符串是奇数个字符的情况
    
12.                 if(len%2!=0){               
    
13.                         show(str, b, len, sum);
    
14.                 }else {
    
15.                         //输入的字符串是偶数个字符的情况
    
16.                         show(str,b,len,sum);
    
17.                 }
    
18.         }
    
19.         //提取判断方法作为公共方法
    
20.         private static void show(String str, byte[] b, int len, int sum) {
    
21.                 for(int i=0;i<len/2;i++){
    
22.                         if(b[i]==b[len-1-i]){
    
23.                                 sum++;
    
24.                         }
    
25.                 }
    
26.                 if(sum==len/2){
    
27.                         System.out.println(str+" 是对称的");
    
28.                 }else{
    
29.                         System.out.println(str+" 不是对称的");
    
30.                 }
    
31.         }
    
32. }

复制代码

希冀 发表于 2015-2-4 22:32
是的成员变量随着对象的消失而消失 静态是优先于对象存在的  随着类的加载而加载 ...

我想我知道了，原来我以为成员变量包括静态的和非静态的，现在知道一般说成员变量指的就是实例变量。受教了~~谢谢！

xiao飞 发表于 2015-2-2 19:53
如果出现数字呢？？？  你考虑到没有

12abccba21  这个是对称字符串 翻转过来 也相等啊  这和数字有什么关联呢？