问题：

如何在java中筛选具有公共属性值的嵌套列表[closed]

司空健

2023-03-14

在测试类下面，我想过滤所有部分中的公共语言列表。

例如，测试有药剂列表P1和P2。P1有一个列表

最终输出应该是具有语言Ja和Zh的语言对象列表。

class Test{
List<Portion> portions
}

class Portion{
List<Language> languages
}

class Language {
 String name;
 String code;
}

共有3个答案

容鸿畴

2023-03-14

在语言类中重写equals（），如下所示

class Language {
public String name;
public String code;

@Override
public boolean equals(Object obj) {
    return this.name.equals(((Language) obj).name) && this.code.equals(((Language) obj).code);
}

}

现在就做吧

Portion p1 = test.get(0);
Portion p1 = test.get(1);
List<Language> duplicate = p1.languages.stream()
            .filter(lan1 -> p2.languages.stream()
                    .anyMatch(lan2 -> lan1.equals(lan2)))
                    .collect(Collectors.toList());

您将在重复列表中得到重复的结果。

以下是测试代码：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Test {
    public static void main(String args[]) {
        List<Portion> portions = new ArrayList<Portion>();
        Language l1 = new Language();
        l1.code = "en";
        l1.name = "English";
        Language l2 = new Language();
        l2.code = "Ja";
        l2.name = "Japanese";
        Language l3 = new Language();
        l3.code = "Ch";
        l3.name = "Chinese";
        Language l4 = new Language();
        l4.code = "Ja";
        l4.name = "Japanese";
        Language l5 = new Language();
        l5.code = "Ch";
        l5.name = "Chinese";

        List<Language> languages1 = new ArrayList<>();
        languages1.add(l1);
        languages1.add(l2);
        languages1.add(l3);
        List<Language> languages2 = new ArrayList<>();
        languages2.add(l4);
        languages2.add(l5);

        Portion p1 = new Portion();
        Portion p2 = new Portion();
        p1.languages = languages1;
        p2.languages = languages2;

        List<Language> duplicates = p1.languages.stream()
                .filter(lan1 -> p2.languages.stream()
                        .anyMatch(lan2 -> lan1.equals(lan2)))
                        .collect(Collectors.toList());


        System.out.println(duplicates);
        System.out.println("Result 1 : " + duplicates.get(0).code + " " + duplicates.get(0).name);
        System.out.println("Result 2 : " + duplicates.get(1).code + " " + duplicates.get(1).name);

    }
}
class Portion{
    public List<Language> languages = new ArrayList<Language>();
}

class Language {
    public String name;
    public String code;

    @Override
    public boolean equals(Object obj) {
        return this.name.equals(((Language) obj).name) && this.code.equals(((Language) obj).code);
    }
}

蓝宜

2023-03-14

你需要使用平面图。如果您不需要删除重复项，下面是解决方案。

public class Stream_FlatMap {
public static void main(String[] args) {
    Language lang11 = new Language("English", "en");
    Language lang12 = new Language("Japanese", "Ja");
    Language lang13 = new Language("Chinese", "Zh");

    List<Language> languages1 = new ArrayList<>();
    languages1.add(lang11);
    languages1.add(lang12);
    languages1.add(lang13);
    Portion portion1 = new Portion(languages1);


    Language lang21 = new Language("Japanese", "Ja");
    Language lang22 = new Language("Chinese", "Zh");
    Language lang23 = new Language("Chinese11", "Zh1");

    List<Language> languages2 = new ArrayList<>();
    languages2.add(lang21);
    languages2.add(lang22);
    Portion portion2 = new Portion(languages2);

    List<Portion> portions = new ArrayList<>();
    portions.add(portion1);
    portions.add(portion2);

    Test t = new Test(portions);

    List<Language> languages = t.portions.stream().flatMap(p -> {
        return p.languages.stream().filter(l -> (l.code.equals("Ja") || l.code.equals("Zh")));
    }).collect(Collectors.toList());

    languages.stream().forEach(t1 -> System.out.println(t1));
}

static class Test {
    public Test(List<Portion> portions) {
        this.portions = portions;
    }

    public List<Portion> portions;
}

static class Portion {
    public Portion(List<Language> languages) {
        this.languages = languages;
    }

    public List<Language> languages;
}

static class Language {
    public Language(String name, String code) {
        this.name = name;
        this.code = code;
    }

    public String name;
    public String code;

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Language{");
        sb.append("name='").append(name).append('\'');
        sb.append(", code='").append(code).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

}

万浩淼

2023-03-14

您可以使用hashmap（存储每种语言的频率）并覆盖hashcode和equals方法

算法如何工作：

遍历所有部分
遍历每个部分中的所有语言
通过添加1来更新语言计数
使用频率等于portions.size的语言创建结果列表（）

import java.util.*;

public class CustomFilter {
    public static void main(String args[]) {
        List<Portion> portions = Arrays.asList(
                new Portion(
                        Arrays.asList(
                                new Language("English", "en"),
                                new Language("Japanese", "Ja"),
                                new Language("Chinese", "Zh"))),
                new Portion(
                        Arrays.asList(
                                new Language("Japanese", "Ja"),
                                new Language("Chinese", "Zh"))));

        HashMap<Language, Integer> languageFreqMap = new HashMap<>();
        for (Portion portion : portions)
            for (Language language : portion.languages)
                languageFreqMap.put(language, languageFreqMap.getOrDefault(language, 0) + 1);

        List<Language> commonLanguages = new ArrayList<>();
        for (Map.Entry<Language, Integer> entry : languageFreqMap.entrySet())
            if (entry.getValue() == portions.size())
                commonLanguages.add(entry.getKey());

        System.out.println(commonLanguages);
    }
}

class Test {
    List<Portion> portions;

    public Test(List<Portion> portions) {
        this.portions = portions;
    }
}

class Portion {
    List<Language> languages;

    public Portion(List<Language> languages) {
        this.languages = languages;
    }
}

class Language {
    String name;
    String code;

    public Language(String name, String code) {
        this.name = name;
        this.code = code;
    }

    @Override
    public String toString() {
        return "{" +
                " name='" + name + "'" +
                ", code='" + code + "'" +
                "}";
    }

    @Override
    public boolean equals(Object o) {
        Language lang = (Language) o;
        return this.code.equals(lang.code);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, code);
    }

}

通过@Vikas解决方案后更新我意识到flatmaps可以使代码更加优雅。这是我的平面图版本

import java.util.*;
import java.util.stream.*;
import java.util.function.*;

public class CustomFilter {
    public static void main(String args[]) {
        List<Portion> portions = Arrays.asList(
                new Portion(
                        Arrays.asList(
                                new Language("English", "en"),
                                new Language("Japanese", "Ja"),
                                new Language("Chinese", "Zh"))),
                new Portion(
                        Arrays.asList(
                                new Language("Japanese", "Ja"),
                                new Language("Chinese", "Zh"))));

        List<Language> commonLanguages = portions.stream()
                .flatMap(p -> p.languages.stream())
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                .entrySet()
                .stream()
                .filter(entry -> entry.getValue() == portions.size())
                .map(e -> e.getKey())
                .collect(Collectors.toList());

        System.out.println(commonLanguages);
    }
}

class Test {
    List<Portion> portions;

    public Test(List<Portion> portions) {
        this.portions = portions;
    }
}

class Portion {
    List<Language> languages;

    public Portion(List<Language> languages) {
        this.languages = languages;
    }
}

class Language {
    String name;
    String code;

    public Language(String name, String code) {
        this.name = name;
        this.code = code;
    }

    @Override
    public String toString() {
        return "{" +
                " name='" + name + "'" +
                ", code='" + code + "'" +
                "}";
    }

    @Override
    public boolean equals(Object o) {
        Language lang = (Language) o;
        return this.code.equals(lang.code);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, code);
    }

}

类似资料：

如何在java中过滤具有公共属性值的嵌套列表列表

在测试类下面，我想过滤所有部分中的公共语言列表。例如，测试有药剂列表P1和P2。P1有一个列表最终输出应该是包含Ja和Zh语言的语言对象列表。
在嵌套筛选器中引用顶级属性

在Elasticsearch中，是否可以在嵌套筛选器中引用顶级（非嵌套）属性？我有一种情况，我需要一个条件在全局级别或在任何数量的关联嵌套对象中的一个中为真。在嵌套筛选器内部，我有一个或筛选器来检查其中一个或另一个，但似乎忽略了外部属性。这里有一个例子。我有一种感觉，我需要的东西不受支持，嵌套筛选器内部的所有内容都必须在指定的路径上或以下应用（从文档开始，“对嵌套对象/文档执行查询，就像它们被
如何按属性名筛选类列表？

我想通过作为字符串的属性名筛选类的集合。假设我有一个名为Person的类，我有它的一个集合，或者是IEnumerable或者是List，我想过滤这个集合，但是我不知道确切的过滤器，我的意思是我不能使用：让我举一个例子。
如果使用angular js具有值列表，如何在一列中生成嵌套表？

问题内容： index.js index.html 它给了我完美的表，但问题出在一栏中。我有数据列表，并想创建具有所有List值的嵌套表。我该如何实现？要检查是否有列具有列表（如果是），然后生成嵌套表。检查这个矮人http://plnkr.co/edit/Ixvp8B0dRwOBDHflmu2j?p=preview 问题答案：您可以这样编写标记：完整代码：https : //gist.git
从嵌套在具有lambda的嵌套贴图中的一组列表中构建最大值列表

我是Java8新手，需要重写一段旧代码来实现一个新的alghoritm。任务是过滤每个列表具有最大速度的对象。列表嵌套在地图中：道路的根地图，其中包含道路段的地图，每个道路段的地图包含对象列表，每个对象以时间间隔降低测量的速度。我需要找到每个列表的所有最大速度。我发现以下链接看起来像我的问题，但我不能适应他们，我不确定我的尝试解决我的问题正确。如何使用Java8流和过滤器过滤嵌套循环？ Jav
在Java中使用流从嵌套的对象列表中筛选/删除

假设我们有一个三维的物体列表。假设我想过滤“l5”，这样如果最里面的列表中的任何元素是奇数，那么整个列表都应该被删除，如果这使得第二级列表为空，那么作为回报应该被删除。因此，对于给定的示例，在过滤之前，如果：过滤后，它应该是：如何使用Java中的流来实现这一点？

如何在java中筛选具有公共属性值的嵌套列表[closed]

共有3个答案

相关问答

相关文章

相关阅读

相关工具

相关文档