Gibt es so etwas wie einen Iterator, aber mit Funktionen wie Streams? ⇐ Java

[Anonymous]

Im Grunde genommen versuche ich Folgendes: < /p>

[*] Laden Sie die Datenanlage aus der Datenbank aus < /li>
Kartieren Sie diese Daten (

Code: Select all

Object[]

Abfrageergebnis) zu einer Klasse, die die Daten in einem lesbaren Format darstellt /li>
< /ol>
Ich habe die Strukturen aufgelistet, mit denen ich vertraut bin, scheinen dem Bedarf zu entsprechen und warum sie nicht zu meinen Anforderungen passen. < /p>

• Iterator → Hat keine Option, ohne als nächstes () < /code>
  
  zu kartieren und zu filtern. Ich muss die Kartenfunktion definieren In einer Unterklasse jedoch ohne die Daten (ähnlich wie ein Stream), damit ich den "Stream" -Stweg bis zu einer Anrufklasse übergeben kann und nur dort als Nächste rufen kann, wodurch alle Kartenfunktionen als als aufgerufen werden Ergebnis < /li>
  < /ul>
  < /li>
  Stream → Alle Daten müssen vor dem Zuordnung und Filterung möglich sein. < /li>
  Beobachtbar → Sendet Daten, sobald sie verfügbar sind. Ich muss es synchronisieren, obwohl

, um das Gefühl zu bekommen, was ich versuche, ein kleines Beispiel:

Code: Select all

// Disclaimer: "Something" is the structure I am not sure of now.
// Could be an Iterator or something else that fits (Thats the question)
public class Orchestrator {
@Inject
private DataGetter dataGetter;

public void doWork() {
FileWriter writer = new FileWriter("filename");

// Write the formatted data to the file
dataGetter.getData()
.forEach(data -> writer.writeToFile(data));
}
}

public class FileWriter {
public void writeToFile(List data) {
// Write to file
}
}

public class DataGetter {
@Inject
private ThingDao thingDao;

public Something getData() {

// Map data to the correct format and return that
return thingDao.getThings()
.map(partialResult -> /* map to object */);
}
}

public class ThingDao {

public Something getThings() {
Query q = ...;
// Dont know what to return
}
}
< /code>
Was ich bisher habe Anforderungen. Dann habe ich einige Methoden hinzugefügt, um die Daten zu kartieren und zu schleifen. Es ist jedoch nicht wirklich ein robustes Design und es wird schwieriger als ich dachte, also wollte ich wissen, ob es schon etwas gibt, das das tut, was ich brauche.  < /P>
public class QIterator implements Iterator {
public static String QUERY_OFFSET = "queryOffset";
public static String QUERY_LIMIT = "queryLimit";

private Query query;

private long lastResultIndex = 0;
private long batchSize;

private Function mapper;

public QIterator(Query query, long batchSize) {
this.query = query;
this.batchSize = batchSize;
}

public QIterator(Query query, long batchSize, Function mapper) {
this(query, batchSize);
this.mapper = mapper;
}

@Override
public boolean hasNext() {
return lastResultIndex % batchSize == 0;
}

@Override
public List next() {
query.setParameter(QueryIterator.QUERY_OFFSET, lastResultIndex);
query.setParameter(QueryIterator.QUERY_LIMIT, batchSize);

List result = (List) query.getResultList(); // unchecked
lastResultIndex += result.size();

List mappedResult;
if (mapper != null) {
mappedResult = mapper.apply(result);
} else {
mappedResult = (List) result; // unchecked
}

return mappedResult;
}

public  QIterator map(Function appendingMapper) {
return new QIterator(query, batchSize, (data) -> {
if (this.mapper != null) {
return appendingMapper.apply(this.mapper.apply(data));
} else {
return appendingMapper.apply((List) data);
}
});
}

public void forEach(BiConsumer consumer) {
for (int i = 0; this.hasNext(); i++) {
consumer.accept(this.next(), i);
}
}
}

Dies funktioniert bisher, hat jedoch einige nicht überprüfte Zuweisungen, die mir nicht wirklich gefallen Nicht schwer von selbst, aber es sollte auch die folgenden Karten aufnehmen, die nach dem Anhang folgen.