Java 将单词反转为回文

你好，我一直在尝试从这个输入中形成回文：但是我无法得到输出，有人能帮我正确地编写函数吗？非常感谢

输入：

String[] text ={"ivcci", "oyotta", "cecarar","bbb","babbbb"};
generatePalindromes();

功能：

public static void generatePalindromes(String[] words) {

}

输出：

civic, -1, racecar, bbb, bbabb

这是我的密码：

    if (s == null) {

        return null;
    }

    Map<Character, Integer> letters = new HashMap<Character, Integer>();

    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (!letters.containsKey(c)) {
            letters.put(c, 1);
        } else
            letters.put(c, letters.get(c) + 1);
    }

    char[] result = new char[s.length()];
    int i = 0, j = result.length - 1;
    Character middle = null;

    for (Entry<Character, Integer> e : letters.entrySet()) {
        int val = e.getValue();
        char c = e.getKey();
        if (val % 2 != 0) {
            if (middle == null && s.length() % 2 != 0) {
                middle = c;
                val--;
            } else
                return "-1";
        }

        for (int k = 0; k < val / 2; k++) {
            result[i++] = c;
            result[j--] = c;
        }
    }
    if (middle != null)
        result[result.length / 2] = middle;

    System.out.println(result);

    return new String(result);

if（s==null）{
返回null；
}
映射字母=新HashMap（）；
对于（int i=0；i

这有帮助吗？它用随机字母生成回文

这不是我的，我找到的

/**
*递归回文生成器.java
*
*@作者David Roazen
*
*包含递归方法palindrome（）的类，该方法返回
*指定长度的随机生成的回文。
*
*main（）方法还通过try/catch演示了基本的异常处理
*街区。
*/
导入java.util.*；
公共类递归回文生成器{
/**
*回文
*
*返回指定长度的随机回文，包括所有
*大写字母。如果请求，则抛出IllegalArgumentException
*生成长度为负的回文。
*@param长度
*@返回
*/
公共静态字符串回文（整数长度）{
//错误处理：
//我们不能生成长度为负的回文，
//因此，如果长度为负，我们抛出一个IllegalArgumentException：
如果（长度<0）{
抛出新的IllegalArgumentException（“长度必须大于等于0！”）；
}
//否则，我们将在“a”和“Z”之间生成一个随机字母：
char randLetter=（char）（int）（Math.random（）*（'Z'-'A'+1）+'A'）；
//基本情况：
//长度为0的回文只是一个空字符串：
如果（长度==0）{
返回“”；
}//长度为1的回文是包含单个字母的字符串：
else if（长度==1）{
返回字符.toString（随机字母）；
}
//递归情况：
//具有“长度”字符的回文，其中长度>=2，
//是一个包含随机字母的字符串，后跟
//长度为-2个字符的回文，后跟
//我们的随机信是：
返回随机字母+回文（长度-2）+随机字母；
}
/**
*main（）程序提示用户输入要输入的回文长度
*生成，然后尝试通过
*调用palindrome（）。如果palindrome（）引发IllegalArgumentException
*（因为len是负数），我们捕获异常并打印
*其中包含错误消息。
*@param args
*/
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
System.out.print（“输入所需的回文长度：”）；
int len=in.nextInt（）；
试一试{
System.out.println（回文（len））；
}捕获（IllegalArgumentException e）{
System.out.println（e.getMessage（））；
}
}
}

你为什么这么费劲，只要把一个单词颠倒过来就行了。如果一个单词颠倒过来后是一样的，那就是回文。@PradeepSimha他实际上想用给定的字符串创建一个回文。“我不认为这里有人会为他这么做。@PradeepSimha如果我知道怎么做，我不是来寻求帮助的……如果一个单词中的字母数是偶数，你必须有所有的字母对。如果一个单词中的字母数是奇数，您可以有一个字母，其余的字母必须是成对的。您是如何到达

civic

？可能是

icvci

也对吗？。。。其他字符串也一样。链接页面，而不是下载。

/**
 * RecursivePalindromeGenerator.java
 *
 * @author David Roazen
 *
 * A class containing a recursive method palindrome() that returns a
 * randomly-generated palindrome of a specified length.
 *
 * The main() method also demonstrates basic exception handling with a try/catch
 * block.
 */

import java.util.*;

public class RecursivePalindromeGenerator {

    /**
     * palindrome()
     *
     * Returns a random palindrome of the specified length, consisting of all
     * uppercase letters. Throws an IllegalArgumentException if asked to
     * generate a palindrome of a negative length.
     * @param length
     * @return 
     */
    public static String palindrome(int length) {

        // ERROR HANDLING:
        // We cannot generate a palindrome of a negative length,
        // so if length is negative we throw an IllegalArgumentException:
        if (length < 0) {
            throw new IllegalArgumentException("The length must be >= 0!");
        }

        // Otherwise we generate a random letter between 'A' and 'Z':
        char randLetter = (char) (int) (Math.random() * ('Z' - 'A' + 1) + 'A');

        // BASE CASES:
        // A palindrome of length 0 is simply an empty String:
        if (length == 0) {
            return "";
        } // A palindrome of length 1 is a String containing a single letter:
        else if (length == 1) {
            return Character.toString(randLetter);
        }

        // RECURSIVE CASE:
        // A palindrome with "length" characters, where length >= 2, 
        // is a String containing our random letter, followed by
        // a palindrome with length - 2 characters, followed by
        // our random letter again:
        return randLetter + palindrome(length - 2) + randLetter;
    }

    /**
     * The main() program prompts the user for the length of the palindrome to
     * generate, then attempts to generate a palindrome of that length by
     * calling palindrome(). If palindrome() throws an IllegalArgumentException
     * (because len was negative), we catch the exception and print out the
     * error message contained inside of it.
     * @param args
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        System.out.print("Enter the desired length of the palindrome: ");
        int len = in.nextInt();

        try {
            System.out.println(palindrome(len));
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}