需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是 

对称字符串：123321、111 

非对称字符串：123123 

思路： 

① 

键盘录入一个字符串，用 Scanner 实现 

② 

将键盘录入的字符串反转 

③ 

使用反转后的字符串，和原字符串进行比对 

④ 

如果相同，则输出是对称字符串，反之输出不是对称字符串

StringBuilder ss = new StringBuilder();
        StringBuilder sh = new StringBuilder();
        System.out.print("请输入字符串：");
        //因为创建的是空对象，所以需要用append方法进行添加
        ss.append(s.next());
        System.out.println("原字符串："+ss);
        //如果不new一个新的的对象接受反转后的字符串，则指向的是同一个地址，就覆盖掉原字符串
        sh.append(ss.reverse());
        System.out.println("反转后字符串："+sh);
        //用reverse方法进行反转并判断与原字符串是否相等
        if (sh.equals(ss)){
            System.out.println("该字符串是对称字符串！");
        }else {
            System.out.println("该字符串不是对称字符串！");
        }

输入一个字符串s，我们可以删除字符串s中的任意字符，让剩下的字符串形成一个对称字符串，且该字符串为最长对称字符串。如：输入google，则找到最长对称字符串为goog；如输入abcda则能找到3个最长对称字符串为aba/aca/ada。 若最长对称字符串存在多个，则输出多个相同长度的最长对称字符串，且字符串中不包含特殊字符。
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Pattern;
/**
* @author sunlichao on 2019-07-09.
*/
public class Test1 {
/**
* 根据特殊字符进行字符串分割
* @param str 输入字符串
* @return
*/
private static String[] stringFilter(String str) {
String regEx = "[^a-zA-Z0-9]";
Pattern p = Pattern.compile(regEx);
return p.split(str);
}
/**
* 遍历生成的二维数组，递归查找最长路径
* @param a 第一个字符串
* @param b 第二个字符串
* @param mux 二维中间数组
* @param i 二维数组raw位置
* @param j 二维数组column位置
* @param path 一次查找的字符串
* @param paths 最终结果集合
*/
private static void getAllLcs( String a, String b, int[][] mux, int i, int j, String path, Set paths) {
StringBuilder pathBuilder = new StringBuilder(path);
while (i > 0 && j > 0) {
if (a.charAt(i - 1) == b.charAt(j - 1)) {
pathBuilder.append(a.charAt(i - 1));
--i;
--j;
}else {
if (mux[i - 1][j] > mux[i][j - 1]) {
--i;
} else if (mux[i - 1][j] < mux[i][j - 1]) {
--j;
} else {
getAllLcs(a, b, mux, i - 1, j, pathBuilder.toString(), paths);
getAllLcs(a, b, mux, i, j - 1, pathBuilder.toString(), paths);
return;
}
}
}
paths.add(pathBuilder.toString());
}
/**
* 字符串s，我们可以删除字符串s中的任意字符，让剩下的字符串形成一个对称字符串，且该字符串为最长对称字符串。
* 原字符串反转，成为查找最大公共子序列问题
* @param input 待查找字符串
* @return 查找结果
*/
private static String findLCS(String input) {
if (input == null || input.length() == 0) {
return "";
}
// 将字符串反转
String reverse = new StringBuilder(input).reverse().toString();
// 字符串长度
int len = input.length();
// 矩阵 -> 二维数组，第一行与第一列皆为零，两个原因，一是方便算法越界处理，二是在
// 通过矩阵查找子串时，作为终止时间判断使用。
int[][] tmp = new int[len + 1][len + 1];
for (int i = 1; i < len + 1; i++) {
for (int j = 1; j < len + 1; j++) {
if (input.charAt(i - 1) == reverse.charAt(j - 1)) {
//取值为左上角值+1
tmp[i][j] = tmp[i - 1][j - 1] + 1;
} else {
//取值为左/上最大值，通过矩阵值反向查找路径时，同一子串会有多个。
tmp[i][j] = Math.max(tmp[i - 1][j], tmp[i][j - 1]);
}
}
}
// 查找路径时，存在多个路径是一个字符串的情况，set去重。
Set paths = new HashSet<>();
Test1.getAllLcs(input, reverse, tmp, input.length(), reverse.length(), "", paths);
return String.join("/", paths);
}
/**
* 包括对特殊字符，结果格式生成
* @param input 待处理字符串
* @return
*/
public static String maxs(String input) {
String[] prepare = stringFilter(input);
StringBuffer sb = new StringBuffer();
for (String str : prepare) {
String result = findLCS(str);
sb.append(result);
sb.append("/");
}
return sb.substring(0, sb.length()-1);
}
public static void main(String[] args) {
// TODO 输出最长对称字符串：goog
String input1 = "google";
System.out.println(maxs(input1));
// TODO 输出3个最长对称字符串：aba/aca/ada
String input2 = "abcda";
System.out.println(maxs(input2));
// TODO 输出2个最长对称字符串：pop/upu，不会输出特殊字符的对称字符串p-p
String input3 = "pop-upu";
System.out.println(maxs(input3));
}
}

判断一个字符串是否是对称字符串，例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
package yang.base;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
/**
*判断一个字符串是否是对称字符串，
*例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
*分析：
*键盘录入数据
*把字符数据转换成高效字符
*使用高效中的翻转功能对数据进行翻转，在转换成字符串数据存储
*使用equals方法进行两个数据比较
*如果是，输出是对称数据，否则输出不是
*
*
*
*/
public class Test48 {
public static void main(String[] args) {
//键盘录入数据
Scanner s = new Scanner(System.in);
while(true){
String y=s.nextLine();
//使用高效中的翻转功能对数据进行翻转，在转换成字符串数据存储
StringBuffer sb = new StringBuffer(y);
String y1 = sb.reverse().toString();
//使用equals方法进行两个数据比较
// 如果是，输出是对称数据，否则输出不是
if(y1.equals(y)){
System.out.println("是对称字符");
}else{
System.out.println("不是对称字符");
}
System.out.println("结束请输入end");
if(y.equals("end")){
break;
}
}
}
}

输入一个字符串s，我们可以删除字符串s中的任意字符，让剩下的字符串形成一个对称字符串，且该字符串为最长对称字符串。如：输入google，则找到最长对称字符串为goog；如输入abcda则能找到3个最长对称字符串为aba/aca/ada。 若最长对称字符串存在多个，则输出多个相同长度的最长对称字符串，且字符串中不包含特殊字符。

package com.study.lsw;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 找出最长对称字符串
 *
 * @author Your Name
 *
 */
public class Test1 {
    public static void main(String[] args) {
        // TODO 输出最长对称字符串：goog
        String input1 = "google";

        // TODO 输出3个最长对称字符串：aba/aca/ada
        String input2 = "abcda";

        // TODO 输出2个最长对称字符串：pop/upu，不会输出特殊字符的对称字符串p-p
        String input3 = "pop-upu";
        List<String> list = new ArrayList<>();
        char[] c=input2.toCharArray();
        StringBuffer sb=new StringBuffer();
        for(int i=1;i<=c.length;i++) {
            getAllSubs(c, 0, i, sb,list);
        }
        //去重
        Set<String> set = new HashSet<>();
        set.addAll(list);
        list.clear();
        list.addAll(set);
        print(list);
        System.out.println("=================");
        List<String> list1 = getRel(list);
        print(list1);
        System.out.println("=================");
        List<String> list2 = getRelsult(list1);
        print(list2);
    }
    /**
     * 获取list中的对称字符串的最大长度，如果有多个分别输出
     * @param list
     * @return
     */
    public static List<String> getRelsult(List<String>  list){
        List<String> list2 = new ArrayList<>();
        int maxLen = 0;
        //求最大字符串的长度
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i).length() > maxLen){
                maxLen = list.get(i).length();
            }
        }
        //遍历集合，输出符合要求的字符串
        for (String s : list) {
            if(s.length() == maxLen){
                list2.add(s);
            }
        }
        return list2;
    }
    /**
     * 获取给定字符串中的所有排列的字符串
     * @param c
     * @param begin
     * @param len
     * @param sb
     * @param list
     * @return
     */
    private static List<String> getAllSubs(char[] c,int begin,int len, StringBuffer sb,List<String> list) {
        if(len==0) {                //当都选择结束时打印sb内容
            String s = sb+"";
            //排除含有特殊符号和长度等于1的字符串
            if(s.matches("[A-Za-z0-9]*") && (s.length() > 1)){
                list.add(s);
            }
            return list;
        }
        if(begin==c.length)
            return list;
        sb.append(c[begin]);   				//取
        getAllSubs(c,begin+1,len-1,sb,list);   	//剩下的里面选len-1个
        sb.deleteCharAt(sb.length()-1); 	//不取
        getAllSubs(c,begin+1,len,sb,list);   	//剩下的里面选len个
        return list;
    }


    /**
     * 将字符串反转后如果和原来相等，则证明是对称的，将对称的字符串放到list中
     * @param list
     * @return
     */
    public static List<String> getRel(List<String> list){
        List<String> list2 = new ArrayList<>();
        //遍历list中的字符串
        for (String s : list) {
            //判断反转后是否相等
            StringBuilder sb = new StringBuilder(s);
            if(s.equals(sb.reverse().toString())){
                list2.add(s);
            }
        }
        return list2;
    }

    /**
     * 打印list中的内容
     * @param list
     */
    public static void print(List<String> list){
        for (String s: list) {
            System.out.print(s+" ");
        }
        System.out.println();
    }
}