Java 如何比较一个类的两个列表，并在出现在两个列表中时返回该类的实例

我在以下条件下用Java编写了以下代码：

• 我为命名的Employee创建了一个类，它有两个属性

  Name

  和

  Age

• 员工的姓名和年龄可以随机生成（姓名不需要有意义）
• 姓名和年龄相同的员工是平等的
• 我创建了两个列表，每个列表由100个Employee类的随机实例组成
• 其目的是比较两个列表并返回两个列表中出现的Employee实例

我不知道我的方法是否正确，也不知道如何改进我的代码（我的意思是我想让它专业化）。请帮助我纠正我的做法，使之专业化。先谢谢你

这是针对员工类的：

public class Employee {

    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

主要课程是：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Main {

    public static Employee employee;

    public static void main(String[] args) {

        List<Employee> list_1 = nameList(100);
        List<Employee> list_2 = nameList(100);


        for(int i =0; i<list_1.size(); i++) {
            for(int j =0; j<list_1.size(); j++) {
                if (list_1.get(i).getName().equals(list_2.get(j).getName()) &&
                        list_1.get(i).getAge() == list_2.get(j).getAge()) {

                    System.out.println("first employee name: " + list_1.get(i).getName() + " first employee age " + list_1.get(i).getAge() + " second employee name: " +
                            list_2.get(j).getName() + " second employee age: " + list_2.get(j).getAge());
                }
            }
        }

    }

    public static List<Employee> nameList(int size) {

        List<String> nameList  = new ArrayList<>();
        List<Integer> ageList = new ArrayList<>();
        List<Employee> employeeList = new ArrayList<>();

        Random randomNumberGenerator = new Random();
        String[] randomName = new String[size];

        for(int i = 0; i <randomName.length; i++) {
            char[] name = new char[randomNumberGenerator.nextInt(5-2)+3];

            for(int j = 0; j < name.length; j++) {
                name[j] = (char)('a' + randomNumberGenerator.nextInt(26));
            }
            randomName[i] = new String(name);
            nameList.add(randomName[i] );

            int sss  = randomNumberGenerator.nextInt(20-10) + 12;
            ageList.add(sss);
        }
        for (int i = 0; i < 100; i++) {
            employee = new Employee(nameList.get(i),ageList.get(i));
            employeeList.add(employee);
        }
        return employeeList;
    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
公共班机{
公共静态员工；
公共静态void main（字符串[]args）{
列表_1=名称列表（100）；
列表2=名称列表（100）；
对于（inti=0；i，这里有一个如何将两个“列表”相交的示例。您真正想做的是使用集合对象而不是列表对象。这将使代码更高效，但使用集合而不是列表有更大的原因。我假设您想创建两个列表，其中真正包含100个唯一项，对吗？如果您使用列表，您将不可避免地在两个100名员工的列表中获得重复项。这不能发生在集合中，因为集合中的项目必须是唯一的。如果生成100个随机员工对象并将其放入集合中，则集合中的员工数将少于100人。但这是可以解决的

生成两个列表中的员工列表的实际魔法是
retainal
方法。这可以在集合和列表上调用，因此如果您碰巧已经创建了两个列表，您可以对其中一个调用
retainal
，传递另一个，然后调用的列表将只包含这是对您的直接问题的回答…使用
retainal

为了让设置魔法发生，我们必须在Employee对象中实现
equals
和
hashCode
方法。我们还必须对列表执行此操作，以便
retainal
方法正常工作

为了创建这两个列表/集合，而不是迭代100次，我们通过不断检查集合的
size（）
，尽可能多地迭代，直到在每个集合中创建了100个唯一的雇员

下面是使用集合的完整示例：

package com.inlet.ifserver;

import java.util.*;
import java.util.Random;

public class Test {

    static class Employee {

        private final String name;
        private final int age;

        public Employee(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public boolean equals(Object obj) {
            if (!(obj instanceof Employee))
                return false;
            return name.equals(((Employee)obj).name) && age == ((Employee)obj).age;
        }

        public int hashCode() {
            return (name + age).hashCode();
        }
    }

    private static final Random random = new Random();
    private static final String[] names = {"Jim", "Jack", "Sam", "Mary", "Kathy", "Sue", "Steve"};

    public static Set<Employee> nameSet(int size) {
        Set<Employee> employeeSet = new HashSet<>();

        while(employeeSet.size() < size) {
            String name = names[random.nextInt(names.length)];
            int age = 12 + random.nextInt(40);
            Employee employee = new Employee(name, age);
            employeeSet.add(employee);
        }
        return employeeSet;
    }

    public static void main(String[] args) {
        Set<Employee> set1 = nameSet(100);
        Set<Employee> set2 = nameSet(100);
        set1.retainAll(set2);
        for (Employee emp: set1)
            System.out.printf("%-6s %2d\n", emp.name, emp.age);
        System.out.printf("Count: %d\n", set1.size());
    }
}

下面是一个如何将两个“列表”相交的示例。您真正想做的是使用集合对象而不是列表对象。这将使代码更高效，但使用集合而不是列表有更大的原因。我假设您想创建两个列表，其中真正包含100个唯一项，对吗？如果您使用列表，您将不可避免地在两个100名员工的列表中获得重复项。这不能发生在集合中，因为集合中的项目必须是唯一的。如果生成100个随机员工对象并将其放入集合中，则集合中的员工数将少于100人。但这是可以解决的

生成两个列表中的员工列表的实际魔法是
retainal
方法。这可以在集合和列表上调用，因此如果您碰巧已经创建了两个列表，您可以对其中一个调用
retainal
，传递另一个，然后调用的列表将只包含这是对您的直接问题的回答…使用
retainal

为了让设置魔法发生，我们必须在Employee对象中实现
equals
和
hashCode
方法。我们还必须对列表执行此操作，以便
retainal
方法正常工作

为了创建这两个列表/集合，而不是迭代100次，我们通过不断检查集合的
size（）
，尽可能多地迭代，直到在每个集合中创建了100个唯一的雇员

下面是使用集合的完整示例：

package com.inlet.ifserver;

import java.util.*;
import java.util.Random;

public class Test {

    static class Employee {

        private final String name;
        private final int age;

        public Employee(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public boolean equals(Object obj) {
            if (!(obj instanceof Employee))
                return false;
            return name.equals(((Employee)obj).name) && age == ((Employee)obj).age;
        }

        public int hashCode() {
            return (name + age).hashCode();
        }
    }

    private static final Random random = new Random();
    private static final String[] names = {"Jim", "Jack", "Sam", "Mary", "Kathy", "Sue", "Steve"};

    public static Set<Employee> nameSet(int size) {
        Set<Employee> employeeSet = new HashSet<>();

        while(employeeSet.size() < size) {
            String name = names[random.nextInt(names.length)];
            int age = 12 + random.nextInt(40);
            Employee employee = new Employee(name, age);
            employeeSet.add(employee);
        }
        return employeeSet;
    }

    public static void main(String[] args) {
        Set<Employee> set1 = nameSet(100);
        Set<Employee> set2 = nameSet(100);
        set1.retainAll(set2);
        for (Employee emp: set1)
            System.out.printf("%-6s %2d\n", emp.name, emp.age);
        System.out.printf("Count: %d\n", set1.size());
    }
}

你的问题是什么？你测试过这个类吗？他生成了两个员工列表，然后希望收到一个包含两个员工共同点的列表。我认为，你的名字列表将创建你想要的列表，但如果你添加一个
equals（）
方法，然后将您的员工放在一个集合而不是列表中。比较两个集合会更容易，您只需使用他们的
contains
方法。两个随机生成的实例具有相同姓名和年龄的可能性确实很小。您可以从相同的非常短的硬编码列表中选择姓名或者是随机生成的（我只是硬核它们——代码要少得多）姓名和年龄。你的问题是什么？你测试过这个类吗？他生成了两个员工列表，然后希望收到一个包含两个员工共同点的列表。我认为，你的姓名列表将创建你想要的列表，但如果你添加一个
equals（），你会更容易、更快
方法，然后将您的员工放在一个集合而不是列表中。比较两个集合会更容易，您只需使用他们的
contains
方法。两个随机生成的实例具有相同姓名和年龄的可能性确实很小。您可以从相同的非常短的硬编码列表中选择姓名或者随机生成（我只需要硬编码——代码要少得多）姓名和年龄。