Accesso a una HashMap da una diversa classe

Question

Ho un HashMap nella mia classe DataStorage dal titolo:

HashMap<String, Integer> people = new HashMap<String, Integer>(); 

people.put("bob", 2); 
people.put("susan", 5); 

Come posso accedere ai dati in questo HashMap in una classe diversa?

Answer 1

Creare la HashMap come una variabile di istanza e fornire un metodo per accedere nella tua classe API:

public class DataStorage { 
    private HashMap<String, Integer> people = new HashMap<String, Integer>(); 

    public HashMap<String, Integer> getPeopleMap() { 
     return people; 
    } 
} 

public class AnotherClass { 
     DataStorage x = new DataStorage();  

     private void someMethod() { 
      HashMap<String, Integer> people = x.getPeopleMap(); 
      //work with your map here... 
     } 
} 

Answer 2

È possibile accedervi:

DataStorage storage = new DataStorage(); 
HashMap<String, Integer> people = storage.people; 

Answer 3

È possibile rendere il vostro HashMap pubblica, o creare un getter per esso:

public HashMap<String, Integer> getPeople() { 
    return people; 
} 

poi si può accedere mediante un'istanza della DataStor classe di età, in questo modo:

DataStorage dataStorage = new DataStorage(); 
dataStorage.getPeople() 

o, se anche si effettua sia il getter e la HashMap statica:

DataStorage.getPeople() 

EDIT: nota, che se le variabili di istanza non sono specificamente indicati modificatori di accesso , hanno l'accesso predefinito a package, il che significa che è possibile accedervi da altre classi definite nello stesso pacchetto. Maggiori informazioni su modificatori di accesso possono essere trovati nel documentation, ecco un breve riassunto:

livelli di accesso

Modifier Class Package Subclass World 
public   Y   Y  Y  Y 
protected  Y   Y  Y  N 
no modifier  Y   Y  N  N 
private   Y   N  N  N 

Answer 4

Come un sostenitore di tell don't ask mi piacerebbe mostrare come questo può essere fatto senza alcun getter.

public class TellDontAsk { 

    interface MapSetter { 
     public void setMap(Map map); 
    } 

    interface MapGiver { 
     public void giveMap(MapSetter acceptMap); 
    } 

    public static void main(String[] args) { 
     HashMap<String, Integer> people = new HashMap<String, Integer>(); 

     people.put("bob", 2); 
     people.put("susan", 5); 

     DataStorage ds = new DataStorage(); 
     ds.setMap(people); 

     AnotherClass ac = new AnotherClass(); 
     ds.giveMap(ac); 

     ac.displayMap(); 
    } 

    public static class DataStorage implements MapSetter, MapGiver { 
     private Map map; 

     @Override 
     public void setMap(Map map) { 
      this.map = map;    
     } 

     @Override 
     public void giveMap(MapSetter acceptMap) { 
      acceptMap.setMap(map); 

     } 
    } 

    public static class AnotherClass implements MapSetter { 
     private Map map; 

     public void displayMap() { 
      System.out.println(map); 

     } 

     @Override 
     public void setMap(Map map) { 
      this.map = map;    
     } 
    } 
} 

Uscite:

{bob=2, susan=5} 

notare come DataStorage non ha knowlege di AnotherClass s esistenza? AnotherClass non conosce nemmeno lo DataStorage. Tutto ciò che condividono è un'interfaccia. Ciò significa che sei libero di fare ciò che vuoi in entrambe le classi, purché continui a supportare quell'interfaccia.

BTW, le classi sono statiche solo perché sono stato pigro per spostarle nei propri file. :)

Answer 5

Questo è Eazy

public class ListDataStorage { 

      public static LinkedHashMap getHmapCashType(){ 

       LinkedHashMap<String, String> hMapCashType = new LinkedHashMap<String, String>(); 
       hMapCashType.put("A", "Cash"); 
       hMapCashType.put("B", "Credit"); 

       return hMapCashType; 
      } 
    } 

i dati di accesso HashMap da un'altra classe

String value = ListDataStorage.getHmapCashType().get("A").toString()