Java流代码改进

我有一个汽车地图

map

，可以通过

getCarsMap（）

方法返回，其中键是汽车型号，值是相同型号的汽车列表

我想改进

caraddcar（Car-Car）

功能。现在，我写了一个有点丑陋的代码和平

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;
}

公共汽车添加车（汽车）{
if（getCarsMap（）.entrySet（）.stream（）.anyMatch（es->es.getKey（）.equals（car.getModel（）））{
如果（！getCarsMap（）.get（car.getModel（））.contains（car））{
getCarsMap（）.get（car.getModel（））.add（car）；
}
}否则{
List tmpList=new ArrayList（）；
tmpList.add（car）；
getCarsMap（）.put（car.getModel（），tmpList）；
}
返回车；
}

另外，需要为removeCar（Car-Car）编写类似的东西，但希望使用一些不错的addCar方法作为模板会更容易。

我的想法-依赖地图的计算

因此，我的方法

populateMapWith

根据您的案例处理当前地图：

• 如果值列表为空-创建新的值列表，添加元素，添加到映射

• 如果存在，只需将元素添加到当前列表中即可

以及根据“删除”从地图中删除

我用对象类演示了它，只是为了简化这个例子

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;});
    }
}

公共类基类测试{
私有映射myMap=newhashmap（）；
@试验
public void testName（）引发异常{
对象car1=新对象（）{
@凌驾
公共字符串toString（）{
返回“car1”；
}
};
对象car2=新对象（）{
@凌驾
公共字符串toString（）{
返回“car1”；
}
};
人口地图（car1）；
populateMap（car2）；
assertEquals（2，myMap.get（“car1”）.size（））；
从地图上移除（car2）；
assertEquals（1，myMap.get（“car1”）.size（））；
}
私有void populateMap（对象o）{
computeIfAbsent（o.toString（），key->newArrayList（））.add（o）；
}
私有void removeFromMap（对象o）{
myMap.ComputeiPresent（o.toString（），（键，列表）->{list.remove（o）；return list；}）；
}
}

UPD：与客户讨论后改进的方法

看来你不希望有重复的。因此，您必须使用不会添加重复元素的集合，而不是列表，如：

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

公共汽车添加车（小汽车）

addCar方法的返回类型。方法返回它所处理的对象。在这里，操作的是贴图，而不是对象。应该是这样的：

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

更新 我在评论中看到

getBoatsMap（）

是一个错误。 因此，代码是：

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;
}

公共地图添加车（车）{
Map carmap=getCarsMap（）；
if（carmap.containsKey（car.getModel（）））{
HashSet carset=carmap.get（car.getModel（））；
carset.add（car）；
map.put（car.getModel（），carset）；
}否则{
Set tempcar=new HashSet（）；
tempcar.add（car）；
carmap.put（car.getModel（），tempcar）；
}
返回carmap；
}

提示：

• 使用

  Set

  而不是

  List

  ，因为

  Set

  不允许重复

• 使用

  contains

  检查元素是否在集合中，而不考虑 无论是

  列表

  还是

  集合

  。（

  Car

  类必须有一个比较字段值的

  equals

  方法。）

• 返回一个

  布尔值

  ，指示集合是否被修改为 手术结果。这就是Java集合所做的

守则：

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;
}

public boolean addCar（Car-Car）{
Map carsMap=getCarsMap（）；
如果（！carsMap.containsKey（car.getModel（）））{
carsMap.put（car.getModel（），新的HashSet（Arrays.asList（car））；
返回true；
}
如果（！carsMap.get（car.getModel（））.contains（car））{
返回carsMap.get（car.getModel（））.add（car）；
}
返回false；
}

也在这里发布这个问题@ΦXocę웃Пepeúpaツ 不，不要建议交叉张贴。顺便说一句：

if（getCarsMap（）.entrySet（）.stream（）.anyMatch（es->es.getKey（）.equals（car.getModel（））

这只是编写

getCarsMap（）.containsKey（car.getModel（））

的一种更糟糕的方法。如果您不想重复，为什么要使用

列表

？为什么在

else

块中使用

getBoatsMap（）

？是的，我是初学者，这就是为什么：）好的，这个列表是错误的，我将使用Set。getBoatsMap（）是getCarsMap（）……对不起，你应该下定决心。。。使用

HashMap

或

Map

（或者更好的

Map

），但两者都不起作用。您不需要重新放置映射中已经存在的映射。此外，

.add（car）

是两种情况下执行的常见代码。因此改进的代码是

HashSet carset=carmap.get（car.getModel（））；如果（carset==null）{carmap.put（car.getModel（），carset=newhashset（））；}carset.add（car）。现在，如果您在这一点上，您可以使用Java8的强大功能来改进它：
carmap.computeifassent（car.getModel（），key->newhashset（））.add（car）具有相同的逻辑，但是一个单行程序…请注意，如果专门的
compute…
方法用于添加：
myMap.ComputeFabSent（o.toString（），key->new ArrayList（））。添加（o）和用于删除：
myMap.computeIfPresent（o.toString（），（键，列表）->{list.remove（o）；return list；}）或如果要清理空列表：
myMap.computeIfPresent（o.toString（），（键，列表）->{list.remove（o）；return list.isEmpty（）？null:list；}）
@Holger是的，我已经检查了这两种方法，但情况确实如此-我们不知道
缺席
或
存在
，所以我决定使用更通用的方法
计算
，这两种方法同时涵盖了两种情况显然，您没有得到逻辑。你不必知道钥匙是否丢失
 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;
   }

public Car removeCar(Car) 

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;
}

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;
}