Ayuda con el Map Collection ...

Yo tengo:
 LinkedHashMap<String, Element> elements

En la clase 'Core'

Quedaría así:

Core coreParent = new Core();
coreParent.elements.put(strNameA, elementA);

Yo quiero crear un "árbol de herencia", donde cada vez que se cree un 'Core' (hijo), en el constructor le pueda pasar como argumento el 'Core' (padre).

Core coreChild = new Core(coreParent);
Y todos los 'element' que tienen valor en el coreParent, sean referenciados desde el coreChild
algo así como:

coreChild.elements.get(strNameA);

Ahora bien, cuando se agregan elementos en el Map del padre (o hijo):

coreParent.elements.put(strNameA, elementA)
coreChild.elements.put(strNameA, elementA)

No hay problema.

PERO... cuando quiero obtener los 'elementos' del LinkedHashMap 'hijo':

Element element = coreChild.elements.get(strNameA)

me gustaría recibirlos del coreParent.
Y así evitar que se dupliquen los datos (cuando se crea el hijo) y que cada vez que le agrege elementos al 'hijo', entonces se agreguen únicamente al hijo y no al 'padre'.

Yo he buscado (en internet) sobre cómo poder hacer un overload (overwrite) del método 'get(key)' del Map (HashMap) pero no he encontrado y me gustaría saber si por aquí, alguien tiene alguna idea.

Gracias por su apoyo.

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Pues no me queda muy claro

Pues no me queda muy claro que quieres hacer, pero ahí te va un programa que esconde los detalles de como se agregan los hijos y donde. A esto se le llama encapsulamiento.

Fíjate en lo que hace el programa y nos dices si se parece a lo que tienes en mente.

Saludos.

import java.util.Map;
import java.util.LinkedHashMap;
import static java.lang.System.out;

public class Core {
   
   private final Core parent;
   private final String name;
   private final Map<String,Core> children;
   
   public static Core newRoot() {
      return new Core( "root", null );
   }
   public static Core namedWithParent( String name , Core parent ) {
      Core child = new Core( name, parent );
      parent.add( child );
      return child;
     
   }
   
   public Iterable<Core> children() {
      return this.children.values();
   }
   
   public String toString()  {
      return String.format("Core(name: %s, children.count:%s)", this.name, this.children.size());
   }
   private Core( String name, Core parent ) {
      this.name = name;
      this.parent = parent;
      this.children = new LinkedHashMap<>();
   }
   private void add( Core child  ) {
      this.children.put( child.name, child );
   }
   public static void main( String ... args) {
      // Crear la raíz
      Core parent = Core.newRoot();
     
      // Crearle tres hijos...
      Core a  = Core.namedWithParent("a", parent );
      Core b  = Core.namedWithParent("b", parent );
      Core c  = Core.namedWithParent("c", parent );
     
      // Crearle hijos al primer elemento
      Core aa = Core.namedWithParent("a.a", a);
      Core ab = Core.namedWithParent("a.b", a);
     
      // y así ..
      Core aaa = Core.namedWithParent("a.a.a", aa);
   
      // imprimir solo los hijos del primer elemento  
      printChildren( aa );
      out.println();
      // print all the hierarchy
      printHierarchy(parent, "");
   }
   public static void printHierarchy( Core node, String space ) {
      out.print(space);

      out.println( node);
      for( Core child : node.children() ) {
         printHierarchy( child , space + "|   ");
      }
   }
   public static void printChildren( Core node ) {
      for( Core child : node.children() ) {
         out.println( child );
      }
   }
}

Salida:

java Core
Core(name: a.a.a, children.count:0)

Core(name: root, children.count:3)
|   Core(name: a, children.count:2)
|   |   Core(name: a.a, children.count:1)
|   |   |   Core(name: a.a.a, children.count:0)
|   |   Core(name: a.b, children.count:0)
|   Core(name: b, children.count:0)
|   Core(name: c, children.count:0)

Imagen de Hepale

Apenas voy a ver tu

Apenas voy a ver tu respuesta, pero en la noche se me ocurrió esto:

Saludos y gracias por tu ayuda.

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;

public class Main {
        public static void main(String[] args) {
                // Creating Soybean market
                Core coreParent = new Core();
                coreParent.setName("Soybean");
                coreParent.setElements(new LinkedHashMap<String, Element>());
               
                // Getting Soybean elements
                List<Element> elements = gettingFromDB();
                        // Values from Soybean
                        Integer[] valuesA = {1,2,3,4,5,6,7,8,9,0};
                        elements.get(0).setValues(valuesA);
                        Integer[] valuesB = {0,9,8,7,6,5,4,3,2,1};
                        elements.get(1).setValues(valuesB);

               
                // Adding element(0) and element(1) to Soybean market
                coreParent.getElements().put(elements.get(0).getName(),elements.get(0));
                coreParent.getElements().put(elements.get(1).getName(),elements.get(1));
               
                // Creating Child from Soybean
                Core coreChildA = new Core(coreParent, "ATR");
                // Calculating ATR Values
                Integer[] valuesC = {5,4,3,2,1};
                elements.get(2).setValues(valuesC);
                // Adding ATR Values to Child
                coreChildA.getElements().put(elements.get(2).getName(),elements.get(2));
               
                // Creating Child from Soybean
                Core coreChildB = new Core(coreParent, "Pyramid");
                // Calculating Pyramid Values
                Integer[] valuesD = {9,8,7,6,5};
                elements.get(3).setValues(valuesD);
                // Adding Pyramid Values to Child
                coreChildB.getElements().put(elements.get(3).getName(),elements.get(3));

                // Creating Gold market
                Core core = new Core();
                core.setName("Gold");
                core.setElements(new LinkedHashMap<String, Element>());
               
                // Getting elements
                elements = gettingFromDB();
                        // Values from Gold market
                        Double[] doubleA = {1.5,1.4,1.3,3.1,2.0};
                        elements.get(0).setValues(doubleA);
                        Double[] doubleB = {2.0,2.1,2.2,1.3,2.4};
                        elements.get(1).setValues(doubleB);

                // Adding element(0) and element(1) to Gold market
                core.getElements().put(elements.get(0).getName(),elements.get(0));
                core.getElements().put(elements.get(1).getName(),elements.get(1));

               
                /* ***************
                 * DISPLAYING PART
                 * ***************/

                // Displaying values before change
                displayValues(core);
                displayValues(coreParent);
                displayValues(coreChildA);
                displayValues(coreChildB);
               
                // Changing values
                System.out.println("\n\n -------- Changing 'Soybean - Open'    values  (from ATR child)--------");
                System.out.println(" -------- Changing 'Soybean - Pyramid' values  --------\n");
                Object[] newOpenValues = {1,1};
                coreChildA.getElements().get("Open").setValues(newOpenValues);
                Object[] newPyramidValues = {2,2};
                coreChildB.getElements().get("Pyramid").setValues(newPyramidValues);
               
                // Displaying values after change
                displayValues(core);
                displayValues(coreParent);
                displayValues(coreChildA);
                displayValues(coreChildB);
               
                System.out.println("\n\n ********* Ending ********* ");
        }

        // Method to display values from Core as parameter
        private static void displayValues(Core core) {
                Object[] values;
                System.out.print("\nCore Name: \"" + core.getName() + "\" ");
                System.out.println("("+(core.isChild()?"Child":"Parent") + ")");
                if (core.isChild()){
                        System.out.println("\tParent: " + core.getParent().getName());
                }
                for (Element element : core.getElements().values()) {
                        if (element.hasValues()){
                                values = element.getValues();
                                System.out.print("\tElement: " + element.getName() + "\tColor:" + element.getColor() + "\n\tValues: ");
                                for (int i = 0; i < values.length; i++) {
                                        System.out.print(values[i] + ", ");
                                }
                                System.out.println("");
                        }
                }
        }

        // Method to get all 'elements' from Database - SIMULATES
        private static List<Element> gettingFromDB() {

                //Elements in Database
                Element elementA = new Element();
                elementA.setColor("Blue");
                elementA.setName("Open");

                Element elementB = new Element();
                elementB.setColor("Yellow");
                elementB.setName("Close");

                Element elementC = new Element();
                elementC.setColor("Red");
                elementC.setName("ATR");

                Element elementD = new Element();
                elementD.setColor("White");
                elementD.setName("Pyramid");

                // After Query
                List<Element> result = new ArrayList<Element>();
                result.add(elementA);
                result.add(elementB);
                result.add(elementC);
                result.add(elementD);
               
                return result;
        }
}

/* ************************
 * **** Entity classes ****
 * ************************
 */

class Core {
        // Property = 'name'
        private String name;
        public String getName() {return name;}
        public void setName(String name) {this.name = name;}

        // Property = 'elements'
        private LinkedHashMap<String, Element> elements = new LinkedHashMap<String, Element>();
        public LinkedHashMap<String, Element> getElements() {return elements;}
        public void setElements(LinkedHashMap<String, Element> elements) {this.elements = elements;}
       
        // Property = 'child'
        private boolean child;
        public boolean isChild(){return child;}
        private Core parent;
        public Core getParent(){return parent;}

        // Default constructor
        public Core(){}
       
        /* Constructor
         * TRICKY PART */

        public Core(Core parent, String lastName){
                this.child = true;
                this.name = parent.getName() + " - " + lastName;
                this.parent = parent;
                for (Element element : parent.getElements().values()) {
                        if (element.hasValues()){
                                this.elements.put(element.getName(), element);
                        }
                }
        }
}

class Element {
        // Property = 'name'
        private String name;
        public String getName() {return name;}
        public void setName(String name) {this.name = name;}

        // Property = 'color'
        private String color;
        public String getColor() {return color;}
        public void setColor(String color) {this.color = color;}

        // Property = 'values'
        private Object[] values;
        public Object[] getValues() {return values;}
        public void setValues(Object[] values) {this.values = values;}
        public boolean hasValues() {return (values==null)?false:true;}

}

Imagen de Hepale

Saludos

Yo pensaba resolverlo con Collections o algo por el estilo, pero es con algo tan sencillo como el uso de "Objetos".
Me compliqué la existencia :P pero la solución era tan sencilla, gracias por tu ayuda ;)