Liste mit generics zurück liefern

[perlenfischer1984]

Hallo zusammen,

ich habe einige Klassen, die aus einer NodeList Node - Elemente extrahieren. Dies gehscieht immer durch eine Schleife.
Hier mein Code zum einfügen eines Season Objektes:

NodeList nodeList = Utils.getNodeListFromDocument(document, "seasons");
      
        for (int item = 0; item < nodeList.getLength(); item++) {
            list.add(new Season((Element) nodeList.item(item)));
        }

Hier mein Code zum einfügen eines Result Objektes:

NodeList nodeList = Utils.getNodeListFromDocument(document, "results");
      
        for (int item = 0; item < nodeList.getLength(); item++) {
            list.add(new Result((Element) nodeList.item(item)));
        }

Wie ihr seht unterscheidet sich die Schleife nur um den Objekt Typen (Season oder Result). Gibt es eine Möglichkeit die For Schleife als Funktion zu extrahieren. Soetwas in dieser Art :

List<SamsDataObject> getDataObjectList(@NonNull NodeList nodeList, Class className) {
       List<DataObject> dataObjectList = Lists.newArrayList();
   
       for (int item = 0; item < nodeList.getLength(); item++) {
          
           dataObjectList.add(new className((Element) nodeList.item(item)));
       }

Vielen Dank für eure Hilfe

 

[VfL_Freak]

List<SamsDataObject> getDataObjectList(@NonNull NodeList nodeList, Class className) 
{
       List<DataObject> dataObjectList = Lists.newArrayList();
       for (int item = 0; item < nodeList.getLength(); item++) 
      {
           dataObjectList.add(new className((Element) nodeList.item(item)));
      }
}

Die Methode soll List<SamsDataObject> zurückgeben, Du gibt aber List<DataObject> zurück 🙄

Gruß Klaus

 

[Joose]

@VfL_Freak er hat ja geschrieben "soetwas in dieser Art" 😉

@perlenfischer1984 ja mit einer generischen Methode könnte man soetwas machen

    public <M> List<M> getDataObjectList(NodeList nodeList, Class<M> clazz) {
       List<M> dataObjectList = new ArrayList<M>();
       for(int i = 0; i < nodeList.getLength(); i++) {
           try {
               Element e = (Element) nodeList.item(i);
               Constructor<M> constr = clazz.getDeclaredConstructor(e.getClass());
               constr.setAccessible(true);
               M dataObject = constr.newInstance(e);
               dataObjectList.add(dataObject);
           } catch (InstantiationException e) {
               e.printStackTrace();
           } catch (IllegalAccessException e) {
               e.printStackTrace();
           } catch (IllegalArgumentException e) {
               e.printStackTrace();
           } catch (InvocationTargetException e) {
               e.printStackTrace();
           } catch (NoSuchMethodException e) {
               e.printStackTrace();
           } catch (SecurityException e) {
               e.printStackTrace();
           }
       }
       return dataObjectList;
   }

Kann man sicher noch optimieren, aber die Richtung sollte stimmen.

 

[Flown]

Zig Arten gibt es hier wie man das lösen könnte und Reflections ist keine davon!
Java 8 Voodoozeug:

List<Result> list = getDataObjectList(emptyNodeList, Result::new);
List<Season> list2 = getDataObjectList(emptyNodeList, Season::new);

Mit:

public <T> List<T> getDataObjectList(NodeList nodeList, Function<Element, T> generator) {
  return IntStream.range(0, nodeList.getLength()).mapToObj(i -> (Element) nodeList.item(i)).map(generator)
      .collect(Collectors.toList());
}

Jetzt mal Pre Java 8 Ära (ich meine < Java 8 wird nicht mal mehr supportet):

List<Result> list = getDataObjectList(emptyNodeList, new Function<Element, Result>() {
  @Override
  public Result apply(Element e) {
    return new Result(e);
  }
});
List<Season> list2 = getDataObjectList(emptyNodeList, new Function<Element, Season>() {
  @Override
  public Season apply(Element e) {
    return new Season(e);
  }
});

Mit dem Interface Function<T, R>:

public interface Function<T, R> {
  R apply(T t);
}

Natürlich noch den Code mit der for-Schleife:

public <T> List<T> getDataObjectList(NodeList nodeList, Function<Element, T> generator) {
  List<T> result = new ArrayList<>();
  for (int i = 0; i < nodeList.getLength(); i++) {
    Element e = (Element) nodeList.item(i);
    result.add(generator.apply(e));
  }
  return result;
}

 

[VfL_Freak]

Moin,

"soetwas in dieser Art"

ok, das habe ich dann wohl überlesen/verdrängt .... 😉

gruß Klaus

 

[Kababär]

@Flown ich glaube du bist hier so ziemlich der einzige der dieses ganz Utility.function Gedöhns drauf hat 😱😀

 

[Flown]

@Kababär Das kann und will ich nicht glauben. Mit etwas Übung und kurzes Überlegen würden schon einige auf äquivalente Lösungen kommen.

 

[Kababär]

@Flown also ich persönlich tue ich mich schwer damit, gerade was Fuction, Consumer und Supplier angeht. Sehe hier auch wenige Beispiele. Wird Zeit dass ich mich damit befasse 😀

 

[Flown]

@Kababär Hat das wirklich etwas mit den gegebenen Interfaces/Klassen zu tun? Man kann die ja selbst schreiben oder nicht?