Java 查找应至少为每行的一个参数定义一个值的记录

我有以下列表->

名单地址

雇员

名字， 年龄 公司 薪水

我希望这些记录中，相同的姓名，年龄，公司，我应该有至少和只有一个工资定义。 因为这个重复记录代表同一个员工，他们必须有一份工资

请注意，逻辑将获取符合此条件的记录，以及不符合此条件的记录，如D/E员工的最后两行没有为工资和工资定义任何值

---

我也应该得到这些值。

将列表转换为流，删除重复项并收集回新列表。 您有两个选项，分别是distinct（按所有字段删除重复项）和distinctByKey （根据特定条件或某些字段删除重复项）

import java.util.ArrayList；
导入java.util.List；
导入java.util.stream.collector；
公共类FindR{
公共静态void main（字符串[]args）
{
ArrayList l=新的ArrayList（）；
l、 添加（new FindR（）.new Employee（“A”，21，“comp_A”，100.0））；
l、 添加（new FindR（）.new Employee（“A”，21，“comp_A”，100.0））；
l、 添加（new FindR（）.新员工（“A”，21，“comp_A”，null））；
l、 添加（new FindR（）.新员工（“A”，21，“comp_A”，null））；
l、 添加（new FindR（）.新员工（“B”，22，“comp_B”，null））；
l、 添加（new FindR（）.new Employee（“B”，22，“comp_B”，200.0））；
l、 添加（新FindR（）.新员工（“C”，23，“comp_C”，300.0））；
l、 添加（new FindR（）.新员工（“D”，24，“comp_D”，null））；
l、 添加（new FindR（）.新员工（“E”，25，“comp_E”，null））；
List l_salaryNotNull=l.stream（）.filter（p->p.salary！=null）.collect（collector.toList（））；
System.out.println（“'u salalary defined'”）；
l_salaryNotNull.stream（）.forEach（System.out:：println）；
System.out.println（“名称、年龄、公司唯一”）；
List l_uByNAC=l.stream（）.map（p->p.name+”：“+p.age+”：“+p.company）.distinct（）.collect（Collectors.toList（））；
//或者删除第一个空值，然后获取密钥
//List l_uByNAC=l.stream（）.filter（p->p.salary！=null）.map（p->p.name+“：“+p.age+”：“+p.company）.distinct（）.collect（Collectors.toList（））；
l_uByNAC.stream（）.forEach（System.out:：println）；
//处理第一个记录
字符串aux[]=l_uByNAC.get（0）.split（“：”）；
System.out.println（“初始列表中的搜索键| name=“+aux[0]+”，age=“+aux[1]+”，company=“+aux[2]）；
}
公营雇员
{
公共字符串名称；
公众年龄；
上市公司；
公共双薪；
公共雇员（字符串n、整数a、字符串c、双s）
{
name=n；
年龄=a；
公司=c；
工资=s；
}
公共字符串toString（）
{
return“name:+name+”：年龄：“+age+”：公司：“+company+”：工资：“+salary；
}
}
}
//输出
//_色情定义_
//姓名：A:年龄：21:公司：公司A:工资：100.0
//姓名：A:年龄：21:公司：公司A:工资：100.0
//姓名：B：年龄：22：公司：薪酬：200.0
//姓名：C:年龄：23:公司：公司C:工资：300.0
//_名字、年龄、公司都是独一无二的_
//A:21:comp_A
//B:22:comp_B
//C:23:comp_C
//D:24:comp\D
//E:25:comp_E
//（第一）在初始列表中搜索的键|姓名=A，年龄=21，公司=公司A

太宽了。试过了吗？请查看我的评论，包括姓名、年龄、公司等。问题是我需要根据姓名、年龄、公司来检查副本，但我可以有10个副本记录，其中5个记录定义了工资值，5个记录没有定义，所以我将根据什么来收集这些记录。在收集时，我还应该有每一行的薪资计数，如果它是否具有薪资值，并且当我们以唯一性结束时，我应该有为该行定义的薪资计数的记录，然后我可以检查该唯一行的薪资计数是否为0。就像在同一示例中，我应该得到一个A，其中薪资计数为1我看到一种方法是使用java8 stream，因为您有不同的方法，可以根据任何标准（使用谓词）获取所需的记录。非常感谢您的建议，我找到了一条基于姓名、年龄和，如果在相同的逻辑中，我如何仅使用Java 8在相同的逻辑中维护每个员工的工资发生计数？我在这里做了一些事情，请看一下，也许它可以帮助您。它并不完美，但您可以进一步研究它。当然，您可以跟踪事件，但可以查看存储位置。可以使用复合对象Employee（count）上的另一个字段，稍后再计算。也许您还可以查看java8中的groupBy。另外，如果在记录（1,2,3）上放置一个计数器，则可以使用HashMap，并基于计数器（类似于db）抓取/链接记录

Name                    Age             Company     Salary    
A                       21              comp_A       100        
A                       21              comp_A              
A                       21              comp_A          
B                       22              comp_B              
B                       22              comp_B       200        
C                       23              comp_C       300        
D                       24              comp_D          
E                       25              comp_E         

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

public class FindR {

public static void main(String[] args)
{
    ArrayList<Employee> l = new ArrayList();
    l.add(new FindR().new Employee("A",21,"comp_A",100.0));
    l.add(new FindR().new Employee("A",21,"comp_A",100.0));
    l.add(new FindR().new Employee("A",21,"comp_A",null));
    l.add(new FindR().new Employee("A",21,"comp_A",null));
    l.add(new FindR().new Employee("B",22,"comp_B",null));
    l.add(new FindR().new Employee("B",22,"comp_B",200.0));
    l.add(new FindR().new Employee("C",23,"comp_C",300.0));
    l.add(new FindR().new Employee("D",24,"comp_D",null));
    l.add(new FindR().new Employee("E",25,"comp_E",null));

    List<Employee> l_salaryNotNull = l.stream().filter(p->p.salary !=null).collect(Collectors.toList());
    System.out.println("_salalary defined_");
    l_salaryNotNull.stream().forEach(System.out::println);

    System.out.println("_unique by name,age,company_");
    List<String> l_uByNAC = l.stream().map(p->p.name+":"+p.age+":"+p.company).distinct().collect(Collectors.toList());

    //or remove first null values and then get keys
    //List<String> l_uByNAC = l.stream().filter(p->p.salary !=null).map(p->p.name+":"+p.age+":"+p.company).distinct().collect(Collectors.toList());

    l_uByNAC.stream().forEach(System.out::println);
    //eg: process first record 
    String aux[] = l_uByNAC.get(0).split(":");
    System.out.println("keys for search in initial list | name="+aux[0]+",age="+aux[1]+",company="+aux[2]);
}


public class Employee 
{
    public String name;
    public Integer age;
    public String company;
    public Double salary;
    public Employee(String n, Integer a,String c, Double s)
    {
        name = n;
        age = a;
        company = c;
        salary = s;
    }

    public String toString()
    {
        return "name:"+name+":age:"+age+":company:"+company+":salary:"+salary;
    }
}
}
//output
//_salalary defined_
//name:A:age:21:company:comp_A:salary:100.0
//name:A:age:21:company:comp_A:salary:100.0
//name:B:age:22:company:comp_B:salary:200.0
//name:C:age:23:company:comp_C:salary:300.0
//_unique by name,age,company_
//A:21:comp_A
//B:22:comp_B
//C:23:comp_C
//D:24:comp_D
//E:25:comp_E
//(first)key for search in initial list | name=A,age=21,company=comp_A