判断字符串是否对称

Question

import java.util.*;
class Str1 
{
public static void main(String[] args) 
{
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个字符串");
String st= sc.next();
int l=st.length();
for (i=1;i<=l ;i++ )
{
for(j=1;j<=l;j++)
{
i+j==l;//写到这写不下去了，说不是语句，应该怎么写 }
}
}
}

Answer 1

一层循环就可以了:boolean equally = true;
for (i=0;i<=l/2 ;i++ )
{
if(!st.charAt(i).equals(st.charAt(l-i))){
equally=false;
break;
}
}随手写的,如果哪里错了就说出来

Answer 2

static boolean isSymmetrical(String s) {
int len = s.length();
for(int i = 0; i < len / 2; i++) {
if ( s.charAt(i) != s.charAt(len-i-1) )
return false;
}
return true;
}

Answer 3

你可以这么判断，字符串翻转，然后比较两个字符串是不是相等的。
这样做，效率可能稍微差一点，但是代码简单。
两句Java代码就搞定了。

Answer 4

public class Str1 { public static void main(String[] args)  
{
System.out.println("请输入一个字符串");
Scanner sc =new Scanner(System.in);

String st= sc.next();

boolean result = true;

int l=st.length();

int head = 0;
int tail = l-1;

int count = (head+tail)/2;
for (int i = 0; i < count; i++) {
if(st.charAt(head++) != st.charAt(tail++))
{
result = false;
}
}

if(result)
{
System.out.println("字符串对称");
}else{
System.out.println("字符串非对称");
}

}
}

Answer 5

一重循环就够了：import java.util.Scanner;
public class Test {
public static void main(String[] args) {
boolean mrk = true;
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String st = sc.next();
int length = st.length();
for (int i = 0, j = length-1 ; i < length/2; i++, j--) {
if(st.charAt(i) != st.charAt(j)) {
mrk = false;
break;
}
}
System.out.printf("%s", mrk==true ? "对称" : "不对称");
}
}

Answer 6

String a = "abc";boolean b = a.reverse().equals(a);

Answer 7

public class Test {
    public static void main(String[] args) {
        String str = "1234321";
        boolean symmetrical = true;
        int len = str.length();
        for (int i = 0; i < len / 2; ++i) {
            if (str.charAt(i) != str.charAt(len - i - 1)) {
                symmetrical = false;
                break;
            }
        }
        
        if (symmetrical) {
            System.out.println("字符串是对称的");
        } else {
            System.out.println("字符串不对称");
        }
    }
}

Answer 8

public class Test{
public static void main(String[] args){

String s="adcdadcd";

String firstHalf=s.substring(0,s.length()/2);//前一半的字符串
//System.out.println(firstHalf);
if(s.endsWith(firstHalf)){//前一半的字符串和后一半的字符串相比较
System.out.println("该字符串对称");
}


}


}
呵呵，这么晚了大家都来积极回答，楼主是位初学者吧，应该感到幸运，我再添个解决的方法，其实对于初学者来说还是楼上循环的解决办法好！！！i+j==l;//写到这写不下去了，说不是语句，应该怎么写
没这么写的，i+j不是一个变量，1怎么能付给他呢？

Answer 9

是否对称？ 回文？
你就reverse一个字符串 然后将结果和原来的比较 一样就ok

Answer 10

用StringBuilder的reverse后再与原先的字符串比较就OK

Answer 11

呵呵，不用循环：
int length = str.length();
String subStr1 = str.substring(0, length / 2);
String subStr2 = str.substring(((length % 2) == 0) ? (length / 2): (length / 2 + 1));
StringBuffer buf= new StringBuffer(subStr2);
subStr2 = buf.reverse().toString();
System.out.println(subStr1.equals(subStr2));

Answer 12

 
这种方式也比较sure: 
StringBuffer strBuf = new StringBuffer(str);
String str2 = strBuf.reverse().toString();
System.out.println(str.equals(str2 ));

Answer 13

//递归：
public static boolean isHuiWen(String s){
int l = s.length()-1;

return l < 0 ? true : s.charAt(0) == s.charAt(l)? isHuiWen(s.substring(1 , l)) : false;

}

Answer 14

//递归：
public static boolean isHuiWen(String s){
        int l = s.length()-1;
        
        return l < 0 ? true : s.charAt(0) == s.charAt(l)? isHuiWen(s.substring(1 , l)) : false;
        
    }

Answer 15

static boolean isSymmetrical(String s) { int len = s.length(); for(int i = 0; i < len / 2; i++) { if ( s.charAt(i) != s.charAt(len-i-1) ) return false; } return true; }

Answer 16

用二分法和StringBuffer去做吧，最好在结合正则表达式去匹配

Answer 17

这里有几处小错误：
   1。 String 类中并没有reverse()方法,而StringBuffer中有这个方法。
   2。StringBuffer类没有重写equals方法
   3。a.reverse()返回的该对象本身的引用，故不能用再用equals（）方法比较了（因为是同一个对象）所以要改成
   StringBuffer a = new StringBuffer("abaddaba");
   String s = a.toString();
   boolean b = s.equals(a.reverse().toString());//String 类重写了equals方法
   System.out.println(b);

Answer 18

import java.util.*;
class Str1  
{
public static void main(String[] args)  
{
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个字符串");
String st= sc.next();
int l =st.length();
int i;

boolean equally = true;
for (i=0;i<=l/2 ;i++ )
{
    if(st.charAt(i) != (st.charAt(l-i-1))){
        equally=false;
        break;
    }
}
System.out.println(equally); }
}

Answer 19

判断回文数，连一层循环都不需要。
只要用：
StringBuffer sb = new StringBuffer(sc);
sb.reverse().toString().equals(sc)?System.out.println("对称"):System.out.println("不对称");

Answer 20

public static boolean check(String str1) {
if (str1 == null || str1.trim().length() == 0)
return false;
int i = 0;
int j = str1.length() - 1;
while (i < j) {
if (str1.charAt(i) != str1.charAt(j))
return false;
i++;
j--;
}
return true;
}

Answer 21

用equalse判断下吧,对称可以取出第二组字符串的长度,然后用一个for循环比较一下

Answer 22

这个帖子竟然那么多人顶，呵呵引用一下
public class Test{
    public static void main(String[] args){
        
            String s="adcdadcd";
            
            String firstHalf=s.substring(0,s.length()/2);//前一半的字符串
            //System.out.println(firstHalf);
            if(s.endsWith(firstHalf)){//前一半的字符串和后一半的字符串相比较
                    System.out.println("该字符串对称");    
            }
            
                
        }
        
                
}

Answer 23

int strcheck(const char *str)
{
asscert(str==NULL); int len=0,i=0;
len =strlen(str);
for(i=0;i<len/2;i++)
{
if(*(str+i)!=*(str-i+len-1))
{
return -1;
}
}
return 0;

}

Answer 24

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        boolean mrk = true;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String st = sc.next();
        int length = st.length();
        for (int i = 0, j = length-1 ; i < length/2; i++, j--) {
            if(st.charAt(i) != st.charAt(j)) {
                mrk = false;
                break;
            }
        }
        System.out.printf("%s", mrk==true ? "对称" : "不对称");
    }
}

Answer 25

i+j==1
这样写是，i+j是不是等于1的判断吧，这个语句返回的是true或false的。

Answer 26

方法大家都写的挺多的~！
我看了下以下几种方法：
1：通过StringBuffer 的reverse反转做比较的（如15L）；
2：循环前后字符做比较的 ；如：（6，8L）；
都挺对 ，关键看看效率 楼主可以通过允许获取毫秒数测下~进行下比较 ~ 

Answer 27

这其实是一种过程式编程，看了上面的很多方案都不够彻底，也不确定java是否能真正解决你的问题，发一段动态混合性语言的解决方案，仅供参考，如有bug请直接反馈给我。代码如下：io.open(); //打开控制台
str = "对称a;中11中;a称对";对称吗 = function(str){
var p;
var l = #str; //字串长度值
if( l & 1) return false; //字串长度值不能整除直接返回false

for(i=1;l){
if(i>(l>>1)) break; //比较超过一半停止比较

//字节码分两种情况：中文字节码，ascii字节码，包括3种算法
if( str[i] >= 0xA1 && str[i] <= 0xFE ){
if(i&1) p = str[i]-str[l-i];
else p = str[i]-str[l-i+2];
}else{
p = str[i]-str[l-i+1];
}

if(p) return false; //两个比较的字节码不相等直接返回false，不再比较
else continue; //相等则继续比较下一对
}
return true; //比较完了，并且没有不相等的，返回true
}io.print(对称吗(str)); //控制台输出结果

Answer 28

修正算法上的一个bug，修正后的代码如下：io.open(); //打开控制台
str = "\'/'.dc对。b称a;中|间11间|中;a称b。对cd.'/'\";对称吗 = function(str){
var p;
var flag = 0; //0为中文首字节码，1为中文次字节码
var l = #str; //字串长度值
if( l & 1) return false; //字串长度值不能整除直接返回false

for(i=1;l){
if(i>(l>>1)) break; //比较超过一半停止比较

//字节码分两种情况：中文字节码，ascii字节码，包括3种算法
if( str[i] >= 0xA1 && str[i] <= 0xFE ){
if( ! flag ){
p = str[i]-str[l-i];
flag = 1;
}else{
p = str[i]-str[l-i+2];
flag = 0;
}
}else{
p = str[i]-str[l-i+1];
}

if(p) return false; //两个比较的字节码不相等直接返回false，不再比较
}
return true; //比较完了，并且没有不相等的，返回true
}io.print(对称吗(str)); //控制台输出结果

Answer 29

如果是中文的话，循环的方法可能就不行了，
个人觉得还是StringBuffer的转换字符串方法好....