Java Stream-Code-Verbesserung

Question

Ich habe eine Karte von Autos Map<String, List<Car>>, die von getCarsMap() Methode zurückgegeben werden kann, wo Schlüssel Modell des Autos ist, und Wert ist eine Liste der Autos des gleichen Modells.

Ich möchte Car addCar(Car car) Funktion verbessern. Denn jetzt habe ich dieses ein bisschen hässlich Frieden Code

public Car addCar(Car car) { 
    if(getCarsMap().entrySet().stream().anyMatch(es -> es.getKey().equals(car.getModel()))){ 
     if(!getCarsMap().get(car.getModel()).contains(car)){ 
      getCarsMap().get(car.getModel()).add(car); 
     } 
    }else{ 
     List<Car> tmpList = new ArrayList<Car>(); 
     tmpList.add(car); 
     getCarsMap().put(car.getModel(), tmpList) ; 
    } 
    return car; 
} 

Außerdem müssen etwas ähnliches für removeCar(Car car) schreiben, aber hoffe, es wird mit einigen netten addCar Methode als Vorlage einfacher sein.

Answer 1

Meine Idee - verlassen Sie sich auf berechnen method von Map.

So meiner Methode populateMapWith Prozess aktuelle Karte nach Ihrem Fall:

• wenn Werteliste ist leer - neue erstellen, Element, fügt

• falls vorhanden, kartieren Elemente nur hinzufügen zur aktuellen Liste

sowie removeFromMap nach dem Entfernen.

I illustriert es mit Objektklasse, nur um den Fall zu vereinfachen

public class BaseTest { 

    private Map<String, List<Object>> myMap = new HashMap<>(); 

    @Test 
    public void testName() throws Exception { 
     Object car1 = new Object() { 
      @Override 
      public String toString() { 
       return "car1"; 
      } 
     }; 

     Object car2 = new Object() { 
      @Override 
      public String toString() { 
       return "car1"; 
      } 
     }; 

     populateMap(car1); 
     populateMap(car2); 

     assertEquals(2, myMap.get("car1").size()); 

     removeFromMap(car2); 

     assertEquals(1, myMap.get("car1").size()); 
    } 

    private void populateMap(Object o) { 
     myMap.computeIfAbsent(o.toString(), key -> new ArrayList<>()).add(o); 
    } 

    private void removeFromMap(Object o) { 
     myMap.computeIfPresent(o.toString(), (key,list) -> { list.remove(o); return list;}); 
    } 
} 

UPD: verbesserte Methoden nach einer Diskussion mit Holger

Answer 2

if(!getCarsMap().get(car.getModel()).contains(car)) 

Es scheint, dass Sie nicht wünschen, zu Duplikate haben. Also statt einer Liste, müssen Sie eine Set verwenden, die keine doppelten Elemente hinzufügt, wie:

Map<String, Set<Car>> carmap = getCarsMap(); 

getBoatsMap().put(car.getModel(), tmpList) ;

Das macht keinen Sinn. Ein Auto in eine Karte zu legen, die Boote haben soll, ist verwirrend. Allerdings gehe ich davon aus, damit zu gehen.

So können wir haben:

Set<Cars> tempcar = new HashSet<>(); 
tempcar.add(car); 
getBoatsMap().put(car.getModel(),tempcar); 

public Car addCar(Car car)

Der Rückgabetyp addCar Methode. Eine Methode gibt das Objekt zurück, das sie bearbeitet. Hier wird die Karte manipuliert und nicht das Objekt. Es sollte etwas sein wie:

public Map<String,Set<Car>> addCar(Car car) 

So können wir den folgenden Code haben:

public HashMap<String,Set<Car>> addCar(Car car){ 
     Map<String, Set<Car>> carmap = getCarsMap(); 
     if(carmap.containsKey(car.getModel())){ 
      HashSet<Car> carset = carmap.get(car.getModel()); 
      carset.add(car); 
      map.put(car.getModel(),carset); 
     }else{ 
      carmap = getBoatsMap(); 
      Set<Cars> tempcar = new HashSet<>(); 
      tempcar.add(car); 
      carmap.put(car.getModel(),tempcar); 
     } 
     return carmap; 
    } 

Dies kann die grundlegende Vorlage für Sie, sich zu bewegen. Dies kann jedoch auch weiter optimiert werden. Eine tiefere Untersuchung von Java Collections API und Java 8 kann Ihnen bessere Ideen liefern.

Denn removeCar() kann die Signatur der Methode sein:

public Car removeCar(Car) 

UPDATE ich in Kommentar, dass getBoatsMap() ein Fehler. So ist der Code:

public Map<String, Set<Car>> addCar(Car car){ 
    Map<String, Set<Car>> carmap = getCarsMap(); 
    if(carmap.containsKey(car.getModel())){ 
     HashSet<Car> carset = carmap.get(car.getModel()); 
     carset.add(car); 
     map.put(car.getModel(),carset); 
    }else{ 
     Set<Cars> tempcar = new HashSet<>(); 
     tempcar.add(car); 
     carmap.put(car.getModel(),tempcar); 
    } 
    return carmap; 
} 

Answer 3

Die Spitzen:

• Verwenden Set statt List weil Set keine Duplikate erlauben.

• Verwenden contains zu überprüfen, ob ein Element in einer Sammlung ist, unabhängig davon, ob es ein List oder ein Set ist. (Car Klasse muss eine equals Methode, die die Feldwerte vergleicht.)

• eine boolean Rückkehr, um anzuzeigen, wenn die Sammlung als Ergebnis der Operation geändert. Das machen Java-Sammlungen.

Der Code:

public boolean addCar(Car car) { 
    Map<String, Set<Car>> carsMap = getCarsMap(); 
    if (!carsMap.containsKey(car.getModel())) { 
     carsMap.put(car.getModel(), new HashSet<>(Arrays.asList(car))); 
     return true; 
    } 
    if (!carsMap.get(car.getModel()).contains(car)) { 
     return carsMap.get(car.getModel()).add(car); 
    } 
    return false; 
}