Java : comment regrouper des chaînes de caractères similaires (éléments) dans un tableau (groupe) respectif ?

Question

J'ai la chaîne suivante "0#Aitem, 0#Aitem2, 0#Aitem3, 1#Bitem, 1#Bitem2, 2#Citem, Nitem, Nitem2".

le 0# indique le numéro de groupe. donc Aitem, Aitem2, Aitem3 appartiendra au groupe 0 . Bitem, Bitem2 en groupe 1 . Citem en groupe 2 . S'il n'y a pas de numéro de groupe, ils seront tous placés dans un groupe distinct. Donc Nitem, Nitem2 sera placé dans le groupe 3 .

Je voudrais créer un tableau pour chaque groupe, et placer les "éléments" dans le groupe (tableau) correspondant. Je me retrouverais donc avec quelque chose comme

[array("Aitem,Aitem2,Aitem3"), array("Bitem, Bitem2"), array("Citem"), array("Nitem, Nitem2")]

Je suppose que j'ai besoin d'une arrayList pour contenir tous les groupes (tableaux) qui ont respectivement les éléments appropriés (items).

C'est ce que j'ai commencé à faire, mais je ne sais pas si c'est la meilleure approche. La chaîne est dynamique, il peut donc y avoir n'importe quel nombre de groupes et elle doit respecter les critères ci-dessus.

String[] x = Pattern.compile(",").split("0#item, 0#item2, 0#item3, 1#item, 1#item2, 2#item, item");
   for (int ii=0; ii<x.length; ii++) {
       System.out.println(i + " \"" + x[ii] + "\"");
   }

Answer 1

Ma réponse montre comment vous pouvez utiliser un simple regex pour extraire à la fois le groupe et l'élément. Vous pouvez ensuite les stocker dans une carte.

    String s =  "0#Aitem, 0#Aitem2, 0#Aitem3, 1#Bitem, 1#Bitem2, 2#Citem, Nitem, Nitem2";
    Pattern p = Pattern.compile("(\\d*)[#]{0,1}(\\w+?)(,|$)");        
    Matcher m = p.matcher(s);
    Map<String, List<String>> map = new TreeMap<String, List<String>>();
    while(m.find()){
        String group = m.group(1);
        String item = m.group(2);
        List<String> items = map.get(group);
        if(items == null){
            items = new ArrayList<String>();
            map.put(group, items);
        }
        items.add(item);
    }
    //let's print it out
    for(String key : map.keySet()){
        System.out.println(key + " : " + map.get(key));
    }

des empreintes :

 : [Nitem, Nitem2]
0 : [Aitem, Aitem2, Aitem3]
1 : [Bitem, Bitem2]
2 : [Citem]

Pour l'instant, les éléments sans groupe sont associés à une chaîne vide. Je vous laisse le soin de gérer ce scénario. Il devrait simplement s'agir de trouver la clé maximale et de l'incrémenter.

Je suis sûr que le regex peut être amélioré aussi car il a été écrit à la hâte.

Answer 2

//Create a map for storing groups
Map<String, Collection<String>> groupMap = new HashMap<String, Collection<String>>();

String[] parts = yourString.split("[, ]+"); //Split by each word
for (String part : parts) {   //Go over all words
    String[] subparts = part.split("#"); //Split to index and value

    String groupKey;
    String value;
    if (subparts.length == 1) { //There is no '#' sign
        groupKey = null;
        value = subparts[0];
    } else if (subparts.length == 2) { //There is one '#'sign
        groupKey = subparts[0];
        value = subparts[1];
    } else {
        throw new IllegalArgumentException("Can not parse string");
    }

    Collection<String> groupContents = groupMap.get(groupKey); //Extract list of items in this group
    if (groupContents == null) { //If there was no such group yet - create one
        groupMap.put(groupKey, groupContents = new ArrayList<String>());
    }
    groupContents.add(value); //Add item to group
}

Answer 3

HashMap<String,List<String> myItems = new HashMap<String,List<String>);

Ensuite, vous pouvez utiliser n'importe quelle classe avec un alias sting et stocker autant d'éléments que vous le souhaitez.

Answer 4

Vous êtes sur la bonne voie mais j'aimerais vous corriger un peu.

Utilisez la regex suivante pour diviser : str.split("\\s*,\\s*") . Cela permettra de prendre en charge tous les espaces possibles.

Lorsque vous obtenez un article séparé, vous devez le diviser à nouveau : item.split("#") .

Pour stocker tout cela, créez une structure de données comme List<List<String>> . Ensuite, faites ce qui suit :

String[] parts = item.split("#");
int group = Integer.parseInt(parts[0]);
String itemName = parts[1];
List<String> groupList = allGroups.get(group);
if (groupList == null) {
   groupList = new ArrayList<String>();
   allGroups[group] = groupList;
}
groupList.add(itemName);

Je suis désolé si l'exemple de code contient des erreurs de syntaxe. Il est écrit ici, sur le site et devrait juste vous aider à voir l'idée.

Answer 5

Une autre solution basée sur les cartes.

    System.out.println("###Parsing results and populating map");
    String[] x = Pattern.compile("\\s*,\\s*").split(
            "0#item, 0#item2, 0#item3, 1#item, 1#item2, 2#item, item");

    Map<String, List<String>> result = new TreeMap<String, List<String>>();

    for (int i = 0; i < x.length; i++) {
        String y[] = x[i].split("#");

        if (y.length > 1) {
        System.out.println("group: '" + y[0] + "' item: '" + y[1] + "'");
            List<String> l = result.get(y[0]);
            if(l==null){
                l = new ArrayList<String>();
                result.put(y[0], l);
            }
            l.add(y[1]);
        }
    }

    System.out.println("###Returning values stored in map, as separate arrays");
    for(Entry<String,List<String>> entry: result.entrySet()){
        System.out.println("Group:" + entry.getKey());
        //System.out.println("Items:");
        List <String> l = entry.getValue();
        // This is where the final array is
        String[] finalArray = l.toArray(new String[1]);
        for (int i = 0; i < finalArray.length; i++) {
            System.out.println(finalArray[i]);
        }

    }