2010-07-29 19 views
5

Me preguntaba cuál sería la mejor estructura (s) de datos que se utilizará para el siguiente escenario:Java pregunta estructura de datos

tengo 2 tipos de objetos A y B

A puede contener muchos casos de B

A.name es único. B.name es único dentro de su instancia de A (aunque no globalmente único)

Me gustaría poder proporcionar métodos de acceso como getA (String aName) devuelve a; getB (String aName, bName) devuelve b;

Toda ayuda es muy apreciada,

Chris

Respuesta

1
public class DataStructure{ 
     private Map<String, A> aMap = new HashMap<String, A>(); 
     public getA(String name){ 
      return aMap.get(name); 
     } 
     public getB(String aName, String bName){ 
      A anA = getA(aName); 
      if(null != anA){ 
       return anA.getB(bName); 
      }else{ 
       return null; 
      } 
    } 
} 
public class A{ 
    String name; 
    Map<String, B> myBs = new HashMap<String, B>(); 
    public A(String name){ 
     this.name = name; 
    } 
    public void putB(B foo){ 
     myBs.put(foo.getName(), foo); 
    } 
    public B getB(String bName){ 
     return myBs.get(bName); 
    } 

} 


public class B{ 
    String name; 
    public B(String name){ 
     this.name=name; 
    } 
} 
+0

Gracias a todos por todas sus respuestas - esto ha sido de gran ayuda !! La gente aquí en la regla de stackoverflow :) – QuakerOat

0

Si A mantenido un mapa interno de este modo:

Map<String, B> bMap = new LinkedHashMap<String, B>(); 

y que tenía una funciones miembro para insertar instancias de B y obtener instancias de B y me gusta:

public void addB(B b) { 
    bMap.put(b.getName(), b); 
} 

public B getB(String name) { 
    return bMap.get(name); 
} 

Entonces puede estar seguro de que el mapa contienen claves con nombres B únicos.

Puede extender esta misma lógica para mantener un mapa que está enchavetado por nombres únicos A:

A a = new A("someAName"); 
a.addB(new B("someName")); 
a.addB(new B("someOtherName")); 

Map<String, A> aMap = new LinkedHashMap<String, A>(); 
aMap.put(a.getName(), a); 

Usted puede poner aMap dentro de otra clase y poner en práctica un método getB:

public B getB(String aName, String bName) { 
    return aMap.get(aName).getB(bName); 
} 
6

Se parece que necesita algo como esto (excepto con mejores nombres, inicialización, manejo de errores, etc. - esto es solo un esqueleto):

public class AContainer 
{ 
    private Map<String, A> map; 

    public A getA(String name) 
    { 
     return map.get(name); 
    } 

    public B getB(String nameA, String nameB) 
    { 
     return getA(nameA).getB(nameB); 
    } 
} 

public class A 
{ 
    private Map<String, B> map; 

    public B getB(String name) 
    { 
     return map.get(name); 
    } 
} 
0
class a { 
    String name 
    List<B> bList 

    public getName() {....} 
    public getBByName(String name) { 
    .... 
    } 


}