Recursive Programming for Text Predictive text

I want to make a program that takes a set of numbers like 234, and at the moment, print out every combination of letters possible that are on a mobile phone keypad.

(1 - nothing, 2 - abc, 3- def and so on)

I currently have:

import java.util.*;

public class testCombo {
    static String str="217";
    static ArrayList<String> list=new ArrayList<String>();

    static void addLet(String seg){
        if(seg.length()==str.length()){
            list.add(seg);
            return;
        }
        char currentChar=str.charAt(seg.length());
        if(currentChar==1 || currentChar==0)
        {
            String str1=seg+" ";
            addLet(str1);
        }
        if(currentChar=='2'){
            addLet(seg+"a");
            addLet(seg+"b");
            addLet(seg+"c");
        }
        else if(currentChar=='3'){
            addLet(seg+"d");
            addLet(seg+"e");
            addLet(seg+"f");
        }   
        else if(currentChar=='4'){
            addLet(seg+"g");
            addLet(seg+"h");
     开发者_JAVA百科       addLet(seg+"i");
        }   
        else if(currentChar=='5'){
            addLet(seg+"j");
            addLet(seg+"k");
            addLet(seg+"l");
        }   
        else if(currentChar=='6'){
            addLet(seg+"m");
            addLet(seg+"n");
            addLet(seg+"o");
        }   
        else if(currentChar=='7'){
            addLet(seg+"p");
            addLet(seg+"q");
            addLet(seg+"r");
            addLet(seg+"s");
        }   
        else if(currentChar=='8'){
            addLet(seg+"t");
            addLet(seg+"u");
            addLet(seg+"v");
        }   
        else if(currentChar=='9'){
            addLet(seg+"w");
            addLet(seg+"x");
            addLet(seg+"y");
            addLet(seg+"z");
        }   
    }

    public static void main(String[] args){
        addLet("");
        for(String str:list) //Sets str to each value in list during each iteration
            System.out.println(str);
    }
}

as my code as we are supposed to be using recursive programming, but I can't get it to work for 1s and 0s. (this is only a practice class, I have another one which allows input from user and it already verifies that it only contains digits)

Would this way of finding then printing out every combination count as recursive?

---

Yes it's recursive (it works by calling itself), but it's unnecessarily verbose. You can skip the temporary variables, thus saving a lot of space, and making it more readable. It took me a few moments to grok why you had several string variables in each case:

    if(currentChar==1 || currentChar==0)
    {
        addLet(seg+" ");
    }
    if(currentChar=='2'){
        addLet(seg+"a");
        addLet(seg+"b");
        addLet(seg+"c");
    } ...

WRT 1's and 0's, you should be comparing currentChar to '1' and '0', not 1 and 0.

---

You can simplify the code and reduce chances of error by using a mapping of digits to candidate letters:

import java.util.*;
import static java.util.Arrays.asList;

public class TestCombo {

    private static Map<Character, List<Character>> lettersByDigit = 
        new HashMap<Character, List<Character>>() {{
           put('0', asList(' '));
           put('1', asList(' '));
           put('2', asList('a', 'b', 'c'));
           put('3', asList('d', 'e', 'f'));

           // and so on - add all candidates per digit in this fashion
        }};

    private static List<String> candidates = new Vector<String>();

    private static void enumerate(String digits, String prefix) {
        if (prefix.length() == digits.length()) {
          candidates.add(prefix);
          return;
        }

        char nextDigit = digits.charAt(prefix.length());

        for (Character nextLetter : lettersByDigit.get(nextDigit)) {
            enumerate(digits, prefix + nextLetter.toString());
        }
    }

    public static void main(String[] args){
        enumerate("217", "");
        for(String candidate : candidates) {
            System.out.println(candidate);
        }
    }
}

Note that this is not tested, but hopefully you get the idea.