Java 键盘组合电话号码

我知道这个问题已经被问过一百次了，但我正在寻找一个不涉及任何字符串函数或外部类的解决方案

我已经编写了一些实际工作的类，但它们都使用String.substring或String.replace、Arraylists等，这在我的情况下是不允许的

我已经做了一个多星期了，似乎没有任何进展

我就是不能把字符串方法放在一个很大的循环中

有什么想法吗

这是我到现在为止写的东西

public class Oldie {
    public static void main(String[] args) {
        char[][] array = {
            { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
            { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
            { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' }
        };

        String num = "222";
        int[] number = new int[num.length()];
        char[] permutations = new char[num.length()];

        for (int i = 0; i < num.length(); i++) {
            number[i] = Character.getNumericValue(num.charAt(i));
        }

        char First, Second, Third;

        for (char i = array[number[0]][0]; i <= array[number[0]][array[number[0]].length - 1]; i++) {
            First = i;

            for (char j = array[number[1]][0]; j <= array[number[1]][array[number[1]].length - 1]; j++) {
                Second = j;

                for (char k = array[number[2]][0]; k <= array[number[2]][array[number[2]].length - 1]; k++) {
                    Third = k;

                    System.out.println("" + First + "" + Second + "" + Third);
                }
            }
        }
    }
}

公共类旧版本{
公共静态void main（字符串[]args）{
字符[][]数组={
{'0'}，{'1'}，{'A'，'B'，'C'}，{'D'，'E'，'F'}，
{'G'，'H'，'I'}，{'J'，'K'，'L'}，{'M'，'N'，'O'}，
{'P'，'Q'，'R'，'S'}，{'T'，'U'，'V'}，{'W'，'X'，'Y'，'Z'}
};
字符串num=“222”；
int[]number=新int[num.length（）]；
char[]排列=新字符[num.length（）]；
对于（int i=0；i对于（char i=array[number[0]][0]；i我建议您使用递归方法：

private String givePerm(String givenPerm, char[][] array, int position, int[] number){
    if(array.length!=number.length)
        return null;
    for (char c = array[number[position]][0]; c <= array[number[position]][array[number[position]].length - 1]; c++) {
        String permString;
        if(position<array.length-1)
             permString = givePerm(c+givenPerm, array, position+1);
        else
             permString = ""+c; 
        return permString;
     }
}

private String givePerm（String givenPerm，char[][]数组，int位置，int[]编号）{
if（array.length！=number.length）
返回null；
for（char c=array[number[position]][0]；c我不太清楚你的循环是什么意思，但是当你修复它时，这应该是另一个不保存字符串的解决方案（现在这抛出了一个“java.lang.ArrayIndexOutOfBoundsException”，因为我不太明白，你想用for循环实现什么）。此代码更应该被视为如何解决问题的提示，而不是完整的解决方案！这也会保存旧字符串。相反，您还可以删除每个for循环末尾的字符串的最后一个字符：

public class Oldie {
    char[][] array = {
            { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
            { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
            { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' }
        };
    String num = "222";
    String savedPerm;
    int[] number = new int[num.length()];

    public static void main(String[] args) {
        Oldie oldie = new Oldie();
        oldie.givePerm(0);
    }

    Oldie(){
        for (int i = 0; i < num.length(); i++) {
            number[i] = Character.getNumericValue(num.charAt(i));
        }
    }

    private void givePerm(int position){
        String oldSavedPerm=savedPerm;
//      if(array.length!=number.length){
//          System.out.println("Different length!");
//          System.out.println(array.length+";"+number.length);
//          return;
//      }
        for (char c = array[number[position]][0]; c <= array[number[position]][array[number[position]].length - 1]; c++) {
            savedPerm=c+oldSavedPerm;
            if(position<array.length-1)
                givePerm(position+1);
            else
                System.out.println(savedPerm);
        }
    }
}

公共类旧版本{
字符[][]数组={
{'0'}，{'1'}，{'A'，'B'，'C'}，{'D'，'E'，'F'}，
{'G'，'H'，'I'}，{'J'，'K'，'L'}，{'M'，'N'，'O'}，
{'P'，'Q'，'R'，'S'}，{'T'，'U'，'V'}，{'W'，'X'，'Y'，'Z'}
};
字符串num=“222”；
字符串savedPerm；
int[]number=新int[num.length（）]；
公共静态void main（字符串[]args）{
旧的=新的旧的（）；
旧的givePerm（0）；
}
老话{
对于（int i=0；i对于（char c=array[number[position]][0]；c这是我解决您问题的方法

char[][] array = {
    { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
    { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
    { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' }
};
String num = "123";

// creates an combination Array
// for 123 this is {{1},{ABC},{DEF}}
char[][] combinationArr = new char[num.length()][];         
for(int ix = 0; ix < num.length(); ix++)
    combinationArr[ix] = array[Character.getNumericValue(num.charAt(ix))];

// now print all permutations of combination Array
// ics holds the actual index at each position
int[] ics = new int[num.length()];
boolean end = false;
while(!end){ // while there are combinations left       
    // print the actual combination
    for(int i = 0; i < combinationArr.length; i++)
        System.out.print(combinationArr[i][ics[i]]);
    System.out.println();               
    // increases one index, starting with the last one.
    // If there is no char left it starts again at 0
    // and the index before will get increased.
    // If the first one could not get increased
    // we have all combinations.
    for(int i = ics.length - 1; i >= 0; i--){
        ics[i]++;
        if(ics[i] == combinationArr[i].length)
            if(i == 0) end = true;
            else ics[i] = 0;
        else break;
    }               
}

char[][]数组={
{'0'}，{'1'}，{'A'，'B'，'C'}，{'D'，'E'，'F'}，
{'G'，'H'，'I'}，{'J'，'K'，'L'}，{'M'，'N'，'O'}，
{'P'，'Q'，'R'，'S'}，{'T'，'U'，'V'}，{'W'，'X'，'Y'，'Z'}
};
字符串num=“123”；
//创建一个组合数组
//对于123，这是{{1}、{ABC}、{DEF}
char[][]组合arr=新字符[num.length（）][]；
对于（int ix=0；ix=0；i--）{
ics[i]++；
if（ics[i]==组合arr[i].长度）
如果（i==0）end=true；
else ics[i]=0；
否则就断了；
}               
}
以下是对我有效的方法！！感谢ctst

public class Oldie {
private static char[][] array = { { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
        { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
        { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' } };
private static String num = "2222";
private static char[] savedPerm = new char[num.length];
private static int[] number = new int[num.length()];

public static void main(String[] args) {

    for (int i = 0; i < num.length(); i++) {
        number[i] = Character.getNumericValue(num.charAt(i));
    }
    givePerm(0);
}


private static void givePerm(int position) {
    for (char c = array[number[position]][0]; c <= array[number[position]][array[number[position]].length - 1]; c++) {
        savedPerm[position] = c;
        if (position < number.length - 1)
            givePerm(position + 1);
        else{
            for(char text: savedPerm){
                 System.out.print(""+text);
            }
            System.out.println();
        }
    }
}
}

公共类旧版本{
私有静态字符[][]数组={{{'0'}，{'1'}，{'A'，'B'，'C'}，{'D'，'E'，F'}，
{'G'，'H'，'I'}，{'J'，'K'，'L'}，{'M'，'N'，'O'}，
{'P'，'Q'，'R'，'S'}，{'T'，'U'，'V'}，{'W'，'X'，'Y'，'Z'}；
私有静态字符串num=“2222”；
私有静态字符[]savedPerm=新字符[num.length]；
私有静态int[]number=新int[num.length（）]；
公共静态void main（字符串[]args）{
对于（int i=0；i对于（char c=array[number[position]][0]；c使用递归，您可以调用
permutations
方法，并通过抓取头部数字并将尾部传递到下一次调用来不断减少输入位数

public class Oldie {
    private static final char[][] KEYS = {
        { '0' },
        { '1' },             { 'A','B','C' }, { 'D','E','F' },
        { 'G','H','I' },     { 'J','K','L' }, { 'M','N','O' },
        { 'P','Q','R','S' }, { 'T','U','V' }, { 'W','X','Y','Z' }
    };

    public static void main(String[] args) {
        try {
            permutations("222");
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
    }

    public static void permutations(String inputNumber) throws IllegalArgumentException {
        permutations(toDigitArray(inputNumber), "");
    }

    private static void permutations(int[] inputDigits, String outputLetters) throws IllegalArgumentException {
        int headDigit = inputDigits[0];
        int[] tailDigits = tail(inputDigits);
        char[] letters = KEYS[headDigit];

        for (int i = 0; i < letters.length; i++) {
            char letter = letters[i];
            String result = outputLetters + letter;

            if (tailDigits.length == 0) {
                System.out.println(result);
            } else {
                permutations(tailDigits, result);
            }
        }
    }

    private static int[] toDigitArray(String str) throws IllegalArgumentException {
        return toDigitArray(str.toCharArray());
    }

    private static int[] toDigitArray(char[] arr) throws IllegalArgumentException {
        int[] intArr = new int[arr.length];

        for (int i = 0; i < intArr.length; i++) {
            if (!Character.isDigit(arr[i])) {
                throw new IllegalArgumentException("Character is not a valid digit");
            }

            intArr[i] = Character.digit(arr[i], 10);
        }

        return intArr;
    }

    private static int[] tail(int[] arr) {
        int[] dest = new int[arr.length - 1];
        System.arraycopy(arr, 1, dest, 0, dest.length);
        return dest;
    }
}

上面的解决方案只针对3位数字，这也不好。我想让它动态化，这样它就不局限于电话号码的长度。你能解释一下，你的代码应该做什么吗？它应该给出给定号码的所有可能组合。例如，111-532-532有以下111-KFC-KFC和111-LFC LFC人们为什么开始他们的que我知道这个问题已经被问了上百次了……？@Hackerdarshi为了避免一些人告诉我这是废话的重复-有时已经回答的问题不是我们想要做的，但有些人永远不会理解-看看你上面的评论，看看一个实际的例子。需要声明
I
还有。啊，这是用复制粘贴的方式…i f
AAA
AAB
AAC
ABA
ABB
ABC
ACA
ACB
ACC
BAA
BAB
BAC
BBA
BBB
BBC
BCA
BCB
BCC
CAA
CAB
CAC
CBA
CBB
CBC
CCA
CCB
CCC