how to compare two Lists of a class and return an instance of that class when appearing in both lists

I wrote the below code in Java with the following condition:

• I created a class for named Employee with two properties Name and Age for employees.
• An employee’s name and age can be generated randomly (the name doesn’t need to make sense)
• Employees are equal if their name and age are the same.
• I created 2 lists made of 100 random instances of the Employee class each.
• The purpose is to compare both lists and return the instances of Employee that appear in both lists.

I don't know my approach is correct and I don't know how I can improve my code (I mean I wanna make it professional). please help me to correct my approach and make it professional. Thank you in advance.

This is for Employee Class:

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

and the main class is:

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

Here's an example of how to intersect two "lists". What you really want to do here is use Set objects instead of List objects. This will make the code more efficient, but there's a bigger reason to use Sets over Lists. I assume that you want to create two lists that truly have 100 unique items in, right? If you use Lists, you will inevitably get duplicates in your two lists of 100 Employees. This can't happen with a Set, as items in a Set must be unique. If you produce 100 random Employee objects and put them in a Set, you'd end up with fewer than 100 Employees in the set. But that can be fixed.

The actual magic of producing the list of Employees that are in both lists is the retainAll method. This can be called on both Sets and Lists, so if you did happen to have two Lists already created, you could call retainAll on one of them, passing the other, and the list you made the call on would then contain just the Employees common to both lists. This is the answer to your direct question...use retainAll!

To allow the Set magic to happen, we had to implement equals and hashCode methods in the Employee object. We would have to do this with Lists too, for the retainAll method to work right.

To create the two lists/Sets, rather than iterating 100 times, we iterate as many times as we have to until we've created 100 unique Employees in each Set, by continually checking the size() of the Set.

Here's a complete example using Sets:

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

Sample result:

Sue    34
Sue    40
Sam    51
Steve  48
Sue    48
Kathy  22
Steve  16
Jack   28
Mary   44
Jack   26
Sue    15
Kathy  28
Sue    27
Kathy  32
Mary   31
Jack   39
Jack   40
Kathy  42
Jim    31
Mary   22
Jim    34
Sam    16
Kathy  50
Jim    43
Jim    45
Sam    42
Jim    15
Jim    16
Sam    35
Sam    31
Count: 30