Come posso memorizzare più viste di dati in memoria?

Sembra che il problema principale qui è che gli oggetti sono disposti in una gerarchia in base alla loro identità, ma li stanno usando in modo non gerarchico.

Un'analogia sarebbe memorizzare i file nelle directory in base al loro tipo di file, ma cercare in ogni directory e caricarne solo alcuni in base a criteri diversi dal tipo.

I'm looking to somehow break apart data management logic away from the data structure itself, but because of the nesting it's complicated. Here are some other options I've been considering:

Questo è un buon obiettivo e c'è un modo semplice per iniziare a dividere le responsabilità senza un refactoring principale: usa Visitatori .

L'idea è che se hai bisogno di ispezionare o operare solo su determinati elementi della gerarchia, metti questa logica nel visitatore stesso. È quindi possibile scrivere più visitatori, ognuno dei quali opera su elementi diversi ed eseguire azioni diverse.

Ogni unità di logica è ora autonoma per un visitatore specifico . Questo migliora l'SRP-ness del tuo codice. Se è necessario modificare il modo in cui un'operazione viene eseguita, lo si fa solo nel visitatore che implementa tale logica. La gerarchia degli oggetti dovrebbe rimanere la stessa, senza le modifiche superficiali per esporre i dati necessari.

Ci sono molti modi per implementare i visitatori a seconda degli obiettivi specifici, ma l'idea generale è che ogni nodo nella gerarchia accetta un oggetto visitatore. La sua implementazione è simile a questa e può essere inserita in una classe genitore astratta:

public class Node {
  public void accept(Visitor v) {
    v.accept(this);
    for (Node child : children) {
      child.accept(v);
    }
  }
}

Ciò garantisce che, indipendentemente dal modo in cui si collegano i nodi in fase di runtime, ogni nodo verrà elaborato.

Il tuo visitatore assomiglia a questo:

public interface Visitor {
  accept(Node n);
}

Il metodo accept(Node) del visitatore è il luogo in cui viene eseguito il lavoro reale. Dovrai ispezionare il nodo e fare condizionalmente cose diverse (incluso ignorare il nodo).

Ad esempio, potresti essere in grado di effettuare le seguenti operazioni:

Node root = ...;

// Print information on the hierarchy.
root.accept(new DebugVisitor());

// Does stuff with modules, ignores subcategories.
root.accept(new FrobnicateModulesVisitor());

// Eats vegetables, ignores animals and minerals.
root.accept(new EatYourVegetableVisitor());

Ogni visitatore è una classe autonoma che contiene la logica per ogni operazione senza necessità di mescolare le preoccupazioni con altri visitatori o i nodi.

Un livello profondo di nidificazione suggerisce che devi refactoring azioni in funzioni più piccole, che può essere incatenato utilizzando dichiarazioni di ritorno. Se è necessario applicare lo stesso metodo per più input, è possibile usufruire di function.apply() in Java 8.

Supponendo che i diversi elementi non condividano alcuna proprietà, potresti implementare un'interfaccia , che richiede che un vengono implementati specifici set di metodi. Per ogni livello vorrei creare un'interfaccia, che viene poi estesa per ciascun sottonodo, ad esempio: Entity , Phylum , Species . Inoltre, sono necessarie tre classi per ciascuna delle tre entità.

I dati possono essere archiviati come proprietà delle istanze dell'oggetto. Per ottenere un'istantanea piatta, eseguirò l'iterazione sui dati utilizzando function.apply() .