Frage nach eventuellem syntaktischen Zucker bei der Konkatenation von ArrayLists

[pkm]

Wenn über ein Stringarray iteriert wird, lässt sich bei der Iteration über diesen locker jeder einzelne String auslesen. Wenn man nun einen Resultstring hat (sagen wir String res = "", dann kann man jeden einzelnen String, der bei der Iteration über das Array ausgelesen wird, wie folgt an diesen String res dranhängen:

res += foo;

usw.

Wenn ich nun eine ArrayList have, welche aus ArrayLists besteht, und ich über diese iteriere:

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {

 ArrayList<String> res = new ArrayList<>();
        
 
 ArrayList<ArrayList<String>> auxiliary = new ArrayList<ArrayList<String>>;
 
 
      ArrayList<String> al1 = new ArrayList<>();
      al1.add("foo");
      al1.add("bar");
      al1.add("test");
      
      
      ArrayList<String> al2 = new ArrayList<>();
      al2.add("foo");
      al2.add("test");
      al2.add("test");
      
      ArrayList<String> al3 = new ArrayList<>();
      al3.add("foo");
      al3.add("bar");
      al3.add("test");
      
      auxiliary.add(al1);  auxiliary.add(al2);  auxiliary.add(al3);
    
      for(int i=0;i<auxiliary.size();i++) {
         res+=res.addAll(auxiliary.get(i)); // -> Das geht nicht.
         //Gibt es eine Möglichkeit (ohne iteration / for-Schleife usw., um res jedesmal JEWEILS um auxiliary.get(i) zu erweitern? 
      }
           }
         
    }

... gibt es da einen syntaktischen Zucker, wie ich eine ArrayList mit dem Inhalt der jeweils bei der Iteration ausgelesenen ArrayLists erweitern lässt? Vielleicht hat jemand in diesem Forum schon einmal so etwas bewerkstelligt, daher poste ich mein Ansinnen mal hier ins Forum; bislang habe ich noch keinen eleganten Weg gefunden

All best
pkm

 

[temi]

for (var list : auxiliary) {
    res.addAll(list);
}

Dein Code funktionert auch, du musst nur res+= weglassen, denn res.addAll() hängt ja schon die gesamte Liste an res an.

 

[temi]

Oder syntaktisch noch etwas mehr gezuckert:

auxiliary.forEach(res::addAll);

 

[pkm]

        public static ArrayList<Node> getAllChildrenOfNode(Node node, ArrayList<Node> res){
                
                //node ist der Knoten, dessen Kinder ich haben will.
                
                 if(!node.hasChildNodes()){
                    
                    //... wenn er keine Kinder hat, soll er den Knoten zurückgeben.
                     return res;
                    
                 } else{
                                      
                       NodeList nl = node.getChildNodes();
                      
                      //Ansonsten will ich über dessen unmittelbare Kinder iterieren.
                       for(int j=0;j<nl.getLength();j++) {
                        
                         //Wenn es keine Kindknoten gibt, dann will ich kinderlose Knoten einer ArrayList<Node> hinzufügen, die ich dann
                         // returnen will.                         
                           if(!nl.item(j).hasChildNodes()) {
                                  res.add(nl.item(j));
                          
                           } else {
                              
                           //... und wenn ich hier eine Rekursion basteln will, geht es irgendwie schief.       
                                res.addAll(getAllChildrenOfNode(nl.item(j),  res));
                                return res;
                           }                           
                       }
                   //return res;
                 }
               }

 

[pkm]

        public static ArrayList<Node> getAllChildrenOfNode(Node node, ArrayList<Node> res){
               
                //node ist der Knoten, dessen Kinder ich haben will.
               
                 if(!node.hasChildNodes()){
                   
                    //... wenn er keine Kinder hat, soll er den Knoten zurückgeben.
                     return res;
                   
                 } else{
                                     
                       NodeList nl = node.getChildNodes();
                     
                      //Ansonsten will ich über dessen unmittelbare Kinder iterieren.
                       for(int j=0;j<nl.getLength();j++) {
                       
                         //Wenn es keine Kindknoten gibt, dann will ich kinderlose Knoten einer ArrayList<Node> hinzufügen, die ich dann
                         // returnen will.                        
                           if(!nl.item(j).hasChildNodes()) {
                                  res.add(nl.item(j));
                         
                           } else {
                             
                           //... und wenn ich hier eine Rekursion basteln will, geht es irgendwie schief.      
                                res.addAll(getAllChildrenOfNode(nl.item(j),  res));
                                return res;
                           }                          
                       }
                   //return res;
                 }
               }

... ich habe es nun so gelöst, scheint zu tun:

        private static ArrayList<Node> extractChildNodes(ArrayList<Node> allChildren, NodeList nl) {
            Node n = null;
                for(int k=0;k<nl.getLength();k++){

                    n = nl.item(k);
                    if(!n.hasChildNodes()) {
                    
                        allChildren.add(n);
                    
                    } else {
                        
                        while(n.getFirstChild() != null) {
                            allChildren.add(n);   
                            n = n.getFirstChild();
                        }
                    }
                    
                 }
                
                return allChildren;
        }