web-dev-qa-db-fra.com

Ajouter ArrayList à un autre ArrayList dans java

J'ai le code Java) suivant, dans lequel je tente de copier ArrayList dans un autre ArrayList.

 ArrayList<String> nodes = new ArrayList<String>();
 ArrayList NodeList=new ArrayList();
 ArrayList list=new ArrayList();

        for(int i=0;i<PropertyNode.getLength()-1;i++){
            Node childNode =  PropertyNode.item(i);
                NodeList Children = childNode.getChildNodes();

                if(Children!=null){
                    nodes.clear();
                    nodes.add("PropertyStart");
                    nodes.add(Children.item(3).getTextContent());
                    nodes.add(Children.item(7).getTextContent());
                    nodes.add(Children.item(9).getTextContent());
                    nodes.add(Children.item(11).getTextContent());
                    nodes.add(Children.item(13).getTextContent());
                    nodes.add("PropertyEnd");

                }   
                NodeList.addAll(nodes);
                list.add(NodeList);
        }

Je veux que le tableau "list" soit dans ce format:

[[PropertyStart,a,b,c,PropertyEnd],[PropertyStart,d,e,f,PropertyEnd],[PropertyStart,......]]

Mais à partir du code ci-dessus, la sortie du tableau "list" se présente comme suit:

[PropertyStart,a,b,c,PropertyEnd,PropertyStart,d,e,f,PropertyEnd,PropertyStart,....PropertyEnd]

Je pense que vous avez peut-être remarqué la différence. Je ne parviens pas à obtenir le résultat au format attendu. S'il vous plaît me suggérer une solution !! Merci d'avance!!

javaarraylist
29
Mahe

Alors vous avez besoin d'un ArrayList de ArrayLists:

ArrayList<ArrayList<String>> nodes = new ArrayList<ArrayList<String>>();
ArrayList<String> nodeList = new ArrayList<String>();
nodes.add(nodeList);

Notez que NodeList a été remplacé par nodeList. Dans Conventions de dénomination Java , les variables commencent par une minuscule. Les cours commencent par une majuscule.

41
Kai

Ton problème

Principalement, vous avez 2 problèmes majeurs:

Vous utilisez l'ajout d'un List de Strings. Vous voulez un List contenant Lists de Strings.

Notez également que lorsque vous appelez ceci:

NodeList.addAll(nodes);

... tout ce que vous dites est d'ajouter tous les éléments des nœuds (qui est une liste de chaînes) au (mal nommé) NodeList, qui utilise des objets et n'ajoute donc que les chaînes qu'il contient. Ce qui m'amène au point suivant.

Vous semblez confus entre vos nodes et NodeList. Votre NodeList continue de croître avec le temps, et c'est ce que vous ajoutez à votre liste.

Donc, même si nous faisions bien les choses, si nous examinions la fin de chaque itération avec votre nodes, nodeList et list, nous verrions:

  • i = 0 

    nodes: [PropertyStart,a,b,c,PropertyEnd]
nodeList: [PropertyStart,a,b,c,PropertyEnd]
list: [[PropertyStart,a,b,c,PropertyEnd]]

  • i = 1 

    nodes: [PropertyStart,d,e,f,PropertyEnd]
nodeList: [PropertyStart,a,b,c,PropertyEnd, PropertyStart,d,e,f,PropertyEnd]
list: [[PropertyStart,a,b,c,PropertyEnd],[PropertyStart,a,b,c,PropertyEnd, PropertyStart,d,e,f,PropertyEnd]]

  • i = 2 

    nodes: [PropertyStart,g,h,i,PropertyEnd]
nodeList: [PropertyStart,a,b,c,PropertyEnd,PropertyStart,d,e,f,PropertyEnd,PropertyStart,g,h,i,PropertyEnd]
list: [[PropertyStart,a,b,c,PropertyEnd],[PropertyStart,a,b,c,PropertyEnd, PropertyStart,d,e,f,PropertyEnd],[PropertyStart,a,b,c,PropertyEnd,PropertyStart,d,e,f,PropertyEnd,PropertyStart,g,h,i,PropertyEnd]]

  • et ainsi de suite ...

Quelques autres corrections

Suivez les Java Conventions de dénomination

N'utilisez pas de noms de variables commençant par des lettres majuscules. Donc ici, remplacez NodeList par nodeList).

En savoir un peu plus sur les types

Vous dites "je veux la" liste "tableau [...]". C'est déroutant pour qui que ce soit avec qui vous communiquerez: ce n'est pas un tableau. C'est une implémentation de List sauvegardée par un tableau.

Il y a une différence entre un type, une interface et une implémentation.

Utiliser des génériques pour renforcer la dactylographie dans les collections

Utilisez des types génériques, car le typage statique aide vraiment à résoudre ces erreurs. De plus, utilisez des interfaces si possible, sauf si vous avez une bonne raison d'utiliser le type concret.

Donc, votre code devient:

List<String> nodes = new ArrayList<String>();
List<String> nodeList = new ArrayList<String>();
List<List<String>> list = new ArrayList<List<String>>();

Supprimer le code inutile

Vous pouvez supprimer complètement nodeList et écrire ce qui suit une fois que vous avez corrigé vos types:

list.add(nodes);

Utilisez la bonne portée

Sauf si vous avez une très bonne raison de le faire, préférez utiliser la portée la plus interne pour déclarer des variables, limiter leur durée de vie pour leurs références et faciliter la séparation des problèmes dans votre code.

Ici, vous pouvez alors déplacer List<String> nodes Pour être déclaré dans la boucle (puis oublier l'invocation nodes.clear()).

Une bonne raison de ne pas faire cela pourrait être la performance, car vous voudrez peut-être éviter de recréer un ArrayList à chaque itération de la boucle, mais il est très peu probable que cela vous préoccupe (et le code propre, lisible et maintenable a la priorité sur le code préoptimisé ).

SSCCE

Dernier point mais non le moindre, si vous souhaitez obtenir de l’aide, donnez-nous le cas exactement reproductible avec un exemple court, correct, complet .

Ici, vous nous donnez les résultats de votre programme, mais ne mentionnez pas comment vous les avez obtenus, nous devons donc supposer que vous avez fait une System.out.println(list). Et vous avez confondu beaucoup de gens, car je pense que les résultats que vous nous donnez ne sont pas ceux que vous avez obtenus.

14
haylem

Ne serait-ce pas juste un cas de:

ArrayList<ArrayList<String>> outer = new ArrayList<ArrayList<String>>();
ArrayList<String> nodeList = new ArrayList<String>();

// Fill in nodeList here...

outer.add(nodeList);

Répéter au besoin.

Cela devrait vous retourner une liste dans le format que vous avez spécifié.

3
Lawrence Andrews

Le problème que vous avez est que vous utilisez le même ArrayList NodeList sur toutes les itérations dans la boucle principale pour. Chaque itération NodeList est agrandie par de nouveaux éléments.

  1. Après la première boucle, NodeList a 5 éléments (PropertyStart, a, b, c, PropertyEnd) et liste a 1 élément (NodeList: (PropertyStart, a, b, c, PropertyEnd))

  2. Après la deuxième boucle NodeList a 10 éléments (PropertyStart, a, b, c, PropertyEnd, PropertyStart, d, e, f, PropertyEnd) et liste a 2 éléments (NodeList ( avec 10 éléments), NodeList (avec 10 éléments))

Pour obtenir vos attentes, vous devez remplacer

NodeList.addAll(nodes);
list.add(NodeList)

par

List childrenList = new ArrayList(nodes);
list.add(childrenList);

PS Votre code n'est pas lisible, conservez Java doivent avoir un code lisible. Par exemple, il est difficile de reconnaître si NodeList est une classe ou un objet

1
michaldo

Initiez la liste de noeuds dans la boucle for et vous obtiendrez la sortie souhaitée.

ArrayList<String> nodes = new ArrayList<String>();
 ArrayList list=new ArrayList();

        for(int i=0;i<PropertyNode.getLength()-1;i++){
            ArrayList NodeList=new ArrayList();
            Node childNode =  PropertyNode.item(i);
                NodeList Children = childNode.getChildNodes();

                if(Children!=null){
                    nodes.clear();
                    nodes.add("PropertyStart");
                    nodes.add(Children.item(3).getTextContent());
                    nodes.add(Children.item(7).getTextContent());
                    nodes.add(Children.item(9).getTextContent());
                    nodes.add(Children.item(11).getTextContent());
                    nodes.add(Children.item(13).getTextContent());
                    nodes.add("PropertyEnd");

                }   
                NodeList.addAll(nodes);
                list.add(NodeList);
        }

Explication: NodeList est un objet qui reste identique tout au long de la boucle. L'ajout de la même variable à la liste d'une boucle ne l'ajoutera donc qu'une seule fois. La boucle n’ajoute que ses variables dans un seul tableau NodeList, vous devez donc voir

[/*list*/    [  /*NodeList*/   ]   ]

et NodeList contient [prostart, a, b, c, proend, prostart, d, e, f, proend ...]

0
novomanish

Tout d'abord, déclarera Arraylist externe qui contiendra un autre Arraylist interne

ArrayList> CompletesystemStatusArrayList; ArrayList systemStatusArrayList

CompletesystemStatusArrayList = new ArrayList

systemStatusArrayList = new ArrayList ();

    systemStatusArrayList.add("1");
    systemStatusArrayList.add("2");
    systemStatusArrayList.add("3");
    systemStatusArrayList.add("4");
    systemStatusArrayList.add("5");
    systemStatusArrayList.add("6");
    systemStatusArrayList.add("7");
    systemStatusArrayList.add("8");

    CompletesystemStatusArrayList.add(systemStatusArrayList);
0
Neelam Singh