You can make your Student override the .equals(Object o) method.

public class Student {

    private int id;
    private int classId;
    private String name;
    private int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (classId != other.classId)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }


}

Then you can compare two students like so:

Student s1 = ...;
Student s2 = ...;

if(s1.equals(s2)) {
   //Do this when they are equal
}

This is a clean way to check for equality and all of Java's functions will call this overrided equals method. You can also use it with lists.

List<Student> studentList = ...;
Student s1 = ...;

if(studentList.contains(s1)) {
   //Do this when s1 is in the list
}

Please let me know if you have any questions or if I misunderstood your question.

I'd make a string id+title for each object, in 2 lists. Then compare the 2 lists

List<String> aList = aObjectList.stream()
   .map(a -> a.getaId() + a.getaTitle())
   .collect(Collectors.toList());
List<String> bList = bObjectList.stream()
   .map(b -> b.getbId() + b.getbTitle())
   .collect(Collectors.toList());

boolean sameElements = aList.size() == bList.size() && 
                       aList.containsAll(bList) && 
                       bList.containsAll(aList);

One solution :

1. Construct a Map of the Local supermarkets using the supermarketId as the key by running through the list once
2. Loop through the cloud list and do you comparison, looking up the local supermarket from your map.

i.e. O(n) instead of O(n²)

Here's a two-line solution:

Map<String, Supermarket> map = getFromLocal().stream()
    .collect(Collectors.toMap(s -> s.supermarketId, s -> s));
List<Supermarket> hasDiffLastItem = getFromCloud().stream()
    .filter(s -> !map.get(s.supermarketId).lastItemBoughtId.equals(s.lastItemBoughtId))
    .collect(Collectors.toList());

I'm not sure I fully understand the question, but you're asking for something like this?

public boolean compare (List<AClass> listA, List<BClass> listB) {
    if (listA.size() != listB.size ()) {
         return false;
    }

    for (int i=0; i<listA.size(); i++) {
        AClass aClass = (AClass) listA.get(i);
        BClass bClass = (BClass) listB.get(i);

        // This is example for numeric comparison
        // For String, use !equals()
        if (aClass.commonField != bClass.commonField) return false;
    }

    return true;
}

Both lists should be sorted by that commonField field

It's not the most efficient solution but the most terse code would be:

boolean equalLists = listA.size() == listB.size() && listA.containsAll(listB);

Update:

@WesleyPorter is right. The solution above will not work if duplicate objects are in the collection.
For a complete solution you need to iterate over a collection so duplicate objects are handled correctly.

private static boolean cmp( List<?> l1, List<?> l2 ) {
    // make a copy of the list so the original list is not changed, and remove() is supported
    ArrayList<?> cp = new ArrayList<>( l1 );
    for ( Object o : l2 ) {
        if ( !cp.remove( o ) ) {
            return false;
        }
    }
    return cp.isEmpty();
}

Update 28-Oct-2014:

@RoeeGavriel is right. The return statement needs to be conditional. The code above is updated.

The approach, algorithm

To find if an object exists in a list, you need to perform a linear search, potentially visiting every single element, in \$O(n)\$ time. More efficient data structures exist:

• Use an ordered data structure: if the values are sorted, then you can find if an element exists using binary search, in \$O(\log n)\$ time.

• Use a hashset: you can find if an element is in the set in constant time, \$O(1)\$

To be to search efficiently, use a hashset instead of a list. However, to be able to use a hashset efficiently, it is required that the objects you put in it have appropriate implementation of hashCode and equals methods.

See the official tutorial on the Object class, especially the sections on the equals and hashCode methods. Note that IDEs like IntelliJ and Eclipse can generate these methods for you easily (they are boring to write by hand, and usually there's little reason to do so).

With correct implementation of the equals and hashCode methods, for example as in the other answer by @Teddy, your main program could be reduced to this:

public static void main(String[] args) {

    Set<Person> originalPeople = new HashSet<>();
    Set<Person> newPeople = new HashSet<>();

    originalPeople.add(new Person("William", "Tyndale"));
    originalPeople.add(new Person("Jonathan", "Edwards"));
    originalPeople.add(new Person("Martin", "Luther"));

    newPeople.add(new Person("Jonathan", "Edwards"));
    newPeople.add(new Person("James", "Tyndale"));
    newPeople.add(new Person("Roger", "Moore"));

    for (Person original : originalPeople) {
        if (!newPeople.contains(original)) {
            System.out.printf("%s %s is not in the new list!%n",
                    original.getFirstName(), original.getLastName());
        }
    }
}

You can use this:

boolean isMatchs = list1.stream()
        .allMatch(el1 -> list2.stream().anyMatch(el2 -> equals(el1, el2)));

with static method equals like this:

static boolean equals(Object1 a, Object2 b) {
    return Objects.equals(a.getField1(), b.getField1());// && ...
}

Override the equals and hashcode method based on first five keys. Then you can just use equals method to compare the objects and use Collections bulk operations like retainAll etc.

Something like this. Feel free to ask questions.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class App6 {
    public static final String ADDED = "ADDED";
    public static final String DELETED = "DELETED";
    public static final String MODIFIED = "MODIFIED";
    public static final String NOT_MODIFIED = "NOT_MODIFIED";

    public static void main(String[] args) {
        List<A> originalObjectList = Arrays.asList(new A("a"), new A(""), new A("a"), new A("a"));
        List<A> modifiedObjectList = Arrays.asList(new A("a"), new A("b"), new A("b"), new A(""));

        List<Result> results = IntStream
                .range(0, originalObjectList.size())
                .mapToObj(i -> {
                    A original = originalObjectList.get(i);
                    A modified = modifiedObjectList.get(i);
                    return compare(original, modified);
                })
                .collect(Collectors.toList());
        System.out.println(results);
    }

    public static Result compare(A or, A mod) {
        if (or == null || mod == null) {
            throw new IllegalArgumentException("Comparable objects should not be null");
        }
        if (or.field == null || mod.field == null) {
            throw new IllegalArgumentException("Comparable fields of objects should not be null");
        }
        if (or.field.equals(mod.field)) {
            return new Result(NOT_MODIFIED, or.field);
        } else if (or.field.isEmpty() && !mod.field.isEmpty()) {
            return new Result(ADDED, mod.field);
        } else if (!or.field.isEmpty() && mod.field.isEmpty()) {
            return new Result(DELETED, or.field);
        } else {
            return new Result(MODIFIED, mod.field);
        }
    }
}

class A {
    String field;

    public A(String field) {
        this.field = field;
    }
}

class Result {
    String status;
    String value;

    public Result(String status, String value) {
        this.status = status;
        this.value = value;
    }

    @Override
    public String toString() {
        return "Result{" +
                "status='" + status + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
}

Give a try to AssertJ recursive comparison and use ignoringCollectionOrder, ex:

public class Person {
   String name;
   List<Person> friends = new ArrayList<>();
   // no equals method
 }

 Person sherlock1 = new Person("Sherlock Holmes");
 sherlock1.friends.add(new Person("Dr. John Watson"));
 sherlock1.friends.add(new Person("Molly Hooper"));

 Person sherlock2 = new Person("Sherlock Holmes");
 sherlock2.friends.add(new Person("Molly Hooper"));
 sherlock2.friends.add(new Person("Dr. John Watson"));

 // assertion succeeds as friends collection order is ignored in the comparison
 assertThat(sherlock1).usingRecursiveComparison()
                      .ignoringCollectionOrder()
                      .isEqualTo(sherlock2);

 // assertion fails as friends collection order is not ignored in the comparison
 assertThat(sherlock1).usingRecursiveComparison()
                      .isEqualTo(sherlock2);

With Java 8:

Comparator.comparing((Person p)->p.firstName)
          .thenComparing(p->p.lastName)
          .thenComparingInt(p->p.age);

If you have accessor methods:

Comparator.comparing(Person::getFirstName)
          .thenComparing(Person::getLastName)
          .thenComparingInt(Person::getAge);

If a class implements Comparable then such comparator may be used in compareTo method:

@Override
public int compareTo(Person o){
    return Comparator.comparing(Person::getFirstName)
              .thenComparing(Person::getLastName)
              .thenComparingInt(Person::getAge)
              .compare(this, o);
}