Java 如何根据字符串'；s组合？

我想比较

getA

（例如：123）和

getB

（例如：456）并找到重复的记录

P1   getA           getB 
1    000123000      456      
P2   getA           getB 
2    000123001      456 

我在下面进行了尝试，但它根据

getA

和

getB

组合找到了重复项：

Map<Object, Boolean> findDuplicates = productsList.stream().collect(Collectors.toMap(cm -> Arrays.asList(cm.getB(),cm.getA().substring(3, cm.getCode().length() - 3)), cm -> false, (a, b) -> true));

---

非常感谢您的帮助。

您可以将字符串设置为数组列表，并在数组列表中循环，如果您正试图这样做，则将其与其他数组列表进行比较。

您可以通过两个步骤来完成此操作

Function<Product,Object> dupKey = cm ->
    Arrays.asList(cm.getB(), cm.getA().substring(3, cm.getA().length() - 3));

Map<Object, Boolean> duplicates = productsList.stream()
    .collect(Collectors.toMap(dupKey, cm -> false, (a, b) -> true));

Map<Object,Product> minDuplicates = productsList.stream()
    .filter(cm -> duplicates.get(dupKey.apply(cm)))
    .collect(Collectors.toMap(dupKey, Function.identity(),
        BinaryOperator.minBy(Comparator.comparing(Product::getA))));

productsList.removeAll(minDuplicates.values());

然后使用该方法而不是

Map.entry

该逻辑与第一个变量中的逻辑相同，它将值映射到

false

和元素本身，并将它们合并到

true

和最小元素，但现在只需一次。之后必须进行过滤，以跳过

false

元素，然后映射到最小元素并将其收集到

集合中

然后，使用
removeAll
是相同的。
也可以使用复制键和树集的映射，而不是将复制键映射为布尔值。这将一步到位。与树集中一样，元素始终保持排序，您不需要在下一步中对其进行排序以找到最小值

公共类ProductDups{
公共静态void main（字符串[]args）{
List productsList=new ArrayList（）；
产品列表添加（新产品（“000123000”、“456”）；
产品列表添加（新产品（“000123001”、“456”）；
产品列表添加（新产品（“000124003”、“567”）；
产品列表添加（新产品（“000124002”、“567”）；
List minDuplicates=productsList.stream（）
.收集(
汤姆(
p->Arrays.asList（p.getB（），
p、 getA（）.substring（3，p.getA（）.length（）-3）），
p->{
TreeSet ts=新的TreeSet（Comparator.comparing（Product:：getA））；
ts.addAll（Arrays.asList（p））；
返回ts；
},
（a、b）->{
a、 阿道尔（b）；
返回a；
}
)
)
.entrySet（）
.stream（）
.filter（e->e.getValue（）.size（）>1）
.map（e->e.getValue（）.first（））
.collect（Collectors.toList（））；
System.out.println（一式两份）；
}
}
类产品{
字符串a；
b串；
公共产品（字符串a、字符串b）{
这个a=a；
这个.b=b；
}
公共字符串getA（）{
返回a；
}
公共空集a（字符串a）{
这个a=a；
}
公共字符串getB（）{
返回b；
}
公共无效立根（字符串b）{
这个.b=b；
}
@凌驾
公共字符串toString（）{
返回“产品{”+
“a=”+a+“\”+
“，b=”+b+“\”+
'}';
}
}
什么是
getCode（）
？它与
getA（）
有什么关系？@Holger抱歉，我从另一个问题中引用了与我的场景相关的内容。您能否详细说明一下“哪个
cm.getA
值最低”？你的意思是所有具有相同
数组.asList（cm.getB（），cm.getA（）.substring（3，cm.getA（）.length（）-3））的产品中最低的一个吗？
key？首先，我想根据getA（）中间数字（例如：123）和getB……找到重复的产品，然后我想比较getA（）中的重复产品并找到代码最低的产品（例如：000123000）@HolgerI假设，如果您有，例如，
000123000
，
000123001
，
00012400
，
00012401
，您想删除
000123000
和
00012400
，这是他们组中最低的。
Function<Product,Object> dupKey = cm ->
    Arrays.asList(cm.getB(), cm.getA().substring(3, cm.getA().length() - 3));

Map<Object, Boolean> duplicates = productsList.stream()
    .collect(Collectors.toMap(dupKey, cm -> false, (a, b) -> true));

Map<Object,Product> minDuplicates = productsList.stream()
    .filter(cm -> duplicates.get(dupKey.apply(cm)))
    .collect(Collectors.toMap(dupKey, Function.identity(),
        BinaryOperator.minBy(Comparator.comparing(Product::getA))));

productsList.removeAll(minDuplicates.values());

BinaryOperator<Product> min = BinaryOperator.minBy(Comparator.comparing(Product::getA));

Set<Product> minDuplicates = productsList.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(dupKey, cm -> Map.entry(false,cm),
            (a, b) -> Map.entry(true, min.apply(a.getValue(), b.getValue()))),
        m -> m.values().stream().filter(Map.Entry::getKey)
              .map(Map.Entry::getValue).collect(Collectors.toSet())));

productsList.removeAll(minDuplicates);

static <K, V> Map.Entry<K, V> entry(K k, V v) {
    return new AbstractMap.SimpleImmutableEntry<>(k, v);
}