Comment pouvez-vous convertir un tableau en 2 dimensions 1 dimensions tableau en Java

Je voudrais savoir comment convertir un 2 dimensions tableau 1 tableau multidimensionnel. Je viens avec un peu de code, mais il n'est pas exactement l'air de fonctionner. Quelqu'un peut-il m'aider? Merci.

public class TESTER1 {

    /**
     * @param args
     */

    static String[][] data = new String[][] {{"Dum","Dumer","Dumbest"}};

    public static void main(String[] args) {

        convertData(data);
    }

    public static void convertData(String[][]data) {
        String[] toReturn = new String[data.length];
        for(int i = 0;i<data.length;i++) {
            for(int j = 0;j<3;j++){
                toReturn[i] = data[i][j];
            }
        }
        for(String s:toReturn) {
            System.out.println(s);
        }
    }
}

[edit]Merci beaucoup. Est-il possible de convertir chaque ligne dans la Chaîne de caractères[][] en
un index dans une Chaîne de caractères[] par exemple, si l'on convertit la Chaîne de caractères[][] (code ci-dessus), puis quand
j'ai imprimer array[0] il devrait imprimer dum,dummer,plus bête [modifier]

OriginalL'auteur Jeel Shah | 2011-03-29

  1. 8
    public static String[] flatten(String[][] data) {
    ArrayList<String> list = new ArrayList<String>();

    for(int i = 0; i < data.length; i++) {
        for(int j = 0; j < data[i].length; j++){
            list.add(data[i][j]);
        }
    }

    return list.toArray(new String[0]);
}

    Ou ajouter des lignes à la fois:

        for(int i = 0; i < data.length; i++) {
        list.addAll( Arrays.asList(data[i]) );
    }

    Edit:
    Les commentaires sur ma réponse, il semble que c'est ce que l'OP voulait (c'est à dire la conversion de chaque ligne de tableau 2d certaine représentation de chaîne de caractères):

    public static String[] rowsToString(String[][] data) {
    ArrayList<String> list = new ArrayList<String>();

    for(int i = 0; i < data.length; i++) {
        String row = Arrays.toString(data[i]);
        list.add( row.substring(1, row.length()-1) );
    }

    return list.toArray(new String[0]);
}
    Ce n'est qu'une des voies possibles. Il pourrait être encore plus simple à la coût de la mémoire ou plus compliqué, mais plus efficace.
    +1 pour l'utilisation de la liste de tableaux et d'éviter de jouer avec les indices!
    merci beaucoup, j'ai une question.. Comment puis-je le modifier de sorte que chaque ligne est égale à un index dans la Chaîne de caractères[]?
    Ravi de vous aider. Qu'entendez-vous par ligne est égale à l'index? Ligne ne peut pas être égal à l'indice de...
    Quand je dis que la ligne est égale à l'index, je veux dire, c'est que prendre la toute l'information sur la ligne et l'ajouter à l'index, comme le code ci-dessus chaque élément et qui s'ajoute au tableau, je veux la ligne à ajouter et non pas de chaque élément.

    OriginalL'auteur pajton

  2. 1

    Une version plus propre:

    public static String[] flatten(String[][] data) {
    List<String> toReturn = new ArrayList<String>();
    for (String[] sublist : Arrays.asList(data)) {
        for (String elem : sublist) {
            toReturn.add(elem);
        }
    }
    return toReturn.toArray(new String[0]);
}

    OriginalL'auteur Travis Webb

  3. 1

    La longueur de la 1-dimensions de la matrice doit être la somme des longueurs de toutes les lignes dans le tableau en 2 dimensions. Bien sûr, Java n'a pas vraiment de "vrai" 2-dimensions des tableaux, mais des tableaux de tableaux. Ce code fonctionne, et est enveloppé dans un programme simple démonstration.

    public class ArrayFlattening {

    public static final String[][] STRINGS2 = {
{"my", "dog", "has", "fleas"},
{"how", "now", "brown", "cow"},
{"short", "row"},
{"this", "is", "a", "final", "row", "in", "this", "test"},
};
public static String[] flatten(String[][] a2) {
String[] result = new String[totalSize(a2)];
int index = 0;
for (String[] a1 : a2) {
for (String s : a1) {
result[index++] = s;
}
}
return result;
}
public static int totalSize(String[][] a2) {
int result = 0;
for (String[] a1 : a2) {
result += a1.length;
}
return result;
}
public static void main(String[] args) {
System.out.println("" + STRINGS2.length + " rows");
for (String[] strings1 : STRINGS2) {
System.out.println("" + strings1.length + " strings");
for (String s : strings1) {
System.out.print("\t" + s);
}
System.out.println();
}
String[] strings1 = flatten(STRINGS2);
System.out.println(strings1.length + " strings");
for (String s : strings1) {
System.out.print("\t" + s);
}
System.out.println();
}

    }

    Hey, Joel. Coincé dans SF sans mon Knuth. Est-il une généralisation (même un Théorème) que vous êtes au courant? Je suis en train de projet à partir de 2-dimensions en 1 réversible et de la mémoire de manière efficace. J'ai l'avantage de commencer avec un pré-ordonné de taille. Peut-être cela mérite un autre post...

    OriginalL'auteur joel.neely

  4. 0

    Aplatir est devenu beaucoup plus facile dans Java 8 avec le flux de données de l'API. La fonction peut être exprimée comme: 

    private static String[] flatten(String[][] data) {
return Stream.of(data).flatMap(Stream::of).toArray(String[]::new);
}

    OriginalL'auteur leo