Assuming the expected output is aaa, ccc, eee, fff, xxx (all the not-common items), you can use List#removeAll, but you need to use it twice to get both the items in name but not in name2 AND the items in name2 and not in name:

List<String> list = new ArrayList<> (name);
list.removeAll(name2); //list contains items only in name

List<String> list2 = new ArrayList<> (name2);
list2.removeAll(name); //list2 contains items only in name2

list2.addAll(list); //list2 now contains all the not-common items

As per your edit, you can't use remove or removeAll - in that case you can simply run two loops:

List<String> uncommon = new ArrayList<> ();
for (String s : name) {
    if (!name2.contains(s)) uncommon.add(s);
}
for (String s : name2) {
    if (!name.contains(s)) uncommon.add(s);
}

Is this a method? You can't just plop code anywhere in Java.

The name of the operation is symmetric difference, so you should probably call it that.

Here's a more compact implementation.

private Set<T> symmetricDifference(Set<T> a, Set<T> b) {
    Set<T> result = new HashSet<T>(a);
    for (T element : b) {
        // .add() returns false if element already exists
        if (!result.add(element)) {
            result.remove(element);
        }
    }
    return result;
}

You could do something like this:

public static void main(String[] args) {
    List<Foo> fooList = asList(new Foo("1", "1"), new Foo("2", "2"), new Foo("3", "3"));
    List<Bar> barList = asList(new Bar("4", 4), new Bar("3", 3), new Bar("5", 5));

    Set<Blah> fooSet = fooList.stream().map(Main::fooToBlah).collect(toCollection(HashSet::new));
    Set<Blah> barSet = barList.stream().map(Main::barToBlah).collect(toCollection(HashSet::new));

    barList.stream()
            .filter(bar -> !fooSet.contains(barToBlah(bar)))
            .forEach(System.out::println);
    fooList.stream()
            .filter(foo -> !barSet.contains(fooToBlah(foo)))
            .forEach(System.out::println);
}

static Blah fooToBlah(Foo foo) {
    return new Blah(foo.name, foo.age);
}

static Blah barToBlah(Bar bar) {
    return new Blah(bar.barName, "" + bar.codeBar);
}

static class Blah {
    String name;
    String age;

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

    @Override
    public boolean equals(Object o) {
        ...
    }

    @Override
    public int hashCode() {
        ...
    }
}

1. Take all Foo objects and convert them to Blah (name it appropriately of course) - this is needed because Foo has other fields that we don't care about.
2. Put Blah objects into a HashSet so that you don't end up with O(n*m) time complexity. You could do just collect(toSet()), but I prefer to be explicit about it here as it is important for performance.
3. Go over Bar objects and if an object is not in the above set, that's the uncommon Bar object. It needs to be converted to Blah and unfortunately you cannot use Stream.map as in the end it should still be Stream<Bar>, not Stream<Blah>.
4. Repeat above three steps for the other list to find all uncommon Foo objects.

Remember that equals and hashCode methods are needed on Blah class. Foo and Bar classes don't need them.

EDIT:

You can convert the following code

Set<Blah> fooSet = fooList.stream().map(Main::fooToBlah).collect(toCollection(HashSet::new));

barList.stream()
        .filter(bar -> !fooSet.contains(barToBlah(bar)))
        .forEach(System.out::println);

into something like this

barList.stream()
        .filter(bar -> fooList.stream()
                .map(Main::fooToBlah)
                .noneMatch(foo -> foo.equals(barToBlah(bar)))
        )
        .forEach(System.out::println);

or even remove Blah class completely

barList.stream()
        .filter(bar -> fooList.stream().noneMatch(foo -> Objects.equals(foo.name, bar.barName) && Objects.equals(foo.age, "" + bar.codeBar)
        .forEach(System.out::println);

but you will end up with much worse time complexity and then there is also a question of readability.

These feel like set operations to me: union, overlap, and difference.

Have a look at this:

Classical set operations for java.util.Collection

Works perfectly for me. Here's the code:

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

/**
 * Add something descriptive here.
 * User: mduffy
 * Date: 3/26/2015
 * Time: 1:27 PM
 * @link https://stackoverflow.com/questions/29284061/find-the-uncommon-common-all-elements-from-two-different-array-list-objects-in/29284162?noredirect=1#comment46767251_29284162
 */
public class SetOperationDemo {

    public static void main(String[] args) {
        List<String> setOne = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
            add("D");
            add("E");
        }};
        List<String> setTwo = new ArrayList<String>() {{
            add("D");
            add("E");
            add("F");
            add("G");
        }};

        System.out.println("Set A           : " + setOne);
        System.out.println("Set B           : " + setTwo);
        List<String> base = new ArrayList<String>(setOne);
        base.retainAll(setTwo);
        System.out.println("Intersection A+B: " + base);
        base = new ArrayList<String>(setOne);
        base.removeAll(setTwo);
        System.out.println("Subtraction  A-B: " + base);
        base = new ArrayList<String>(setTwo);
        base.removeAll(setOne);
        System.out.println("Subtraction  B-A: " + base);
        base = new ArrayList<String>(setOne);
        base.addAll(setTwo);
        System.out.println("Union A union B : " + base);
    }
}

Here's the output:

Set A           : [A, B, C, D, E]
Set B           : [D, E, F, G]
Intersection A+B: [D, E]
Subtraction  A-B: [A, B, C]
Subtraction  B-A: [F, G]
Union A union B : [A, B, C, D, E, D, E, F, G]

Process finished with exit code 0

If your Lists contain custom classes, you have to be sure that they override equals and hashCode properly or they won't give the expected behavior. Here's my code using a custom class that shows how it's done.

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

/**
 * Add something descriptive here.
 * User: mduffy
 * Date: 3/26/2015
 * Time: 1:27 PM
 * @link https://stackoverflow.com/questions/29284061/find-the-uncommon-common-all-elements-from-two-different-array-list-objects-in/29284162?noredirect=1#comment46767251_29284162
 */
public class SetOperationDemo {

    public static void main(String[] args) {
        List<DemoPerson> setOne = new ArrayList<DemoPerson>() {{
            add(new DemoPerson("Andy", "A"));
            add(new DemoPerson("Bob", "B"));
            add(new DemoPerson("Carl", "C"));
            add(new DemoPerson("David", "D"));
            add(new DemoPerson("Ernie", "E"));
        }};
        List<DemoPerson> setTwo = new ArrayList<DemoPerson>() {{
            add(new DemoPerson("David", "D"));
            add(new DemoPerson("Ernie", "E"));
            add(new DemoPerson("Frank", "F"));
            add(new DemoPerson("Gary", "G"));
        }};

        System.out.println("Set A           : " + setOne);
        System.out.println("Set B           : " + setTwo);
        List<DemoPerson> base = new ArrayList<DemoPerson>(setOne);
        base.retainAll(setTwo);
        System.out.println("Intersection A+B: " + base);
        base = new ArrayList<DemoPerson>(setOne);
        base.removeAll(setTwo);
        System.out.println("Subtraction  A-B: " + base);
        base = new ArrayList<DemoPerson>(setTwo);
        base.removeAll(setOne);
        System.out.println("Subtraction  B-A: " + base);
        base = new ArrayList<DemoPerson>(setOne);
        base.addAll(setTwo);
        System.out.println("Union A union B : " + base);
    }
}

class DemoPerson {
    private final String firstName;
    private final String lastName;

    public DemoPerson(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        DemoPerson that = (DemoPerson) o;

        return !(firstName != null ? !firstName.equals(that.firstName) : that.firstName != null) && !(lastName != null ? !lastName.equals(that.lastName) : that.lastName != null);

    }

    @Override
    public int hashCode() {
        int result = firstName != null ? firstName.hashCode() : 0;
        result = 31 * result + (lastName != null ? lastName.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("{");
        sb.append("'").append(firstName).append('\'');
        sb.append(" '").append(lastName).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

And here's the output, still behaving as it should:

Set A           : [{'Andy' 'A'}, {'Bob' 'B'}, {'Carl' 'C'}, {'David' 'D'}, {'Ernie' 'E'}]
Set B           : [{'David' 'D'}, {'Ernie' 'E'}, {'Frank' 'F'}, {'Gary' 'G'}]
Intersection A+B: [{'David' 'D'}, {'Ernie' 'E'}]
Subtraction  A-B: [{'Andy' 'A'}, {'Bob' 'B'}, {'Carl' 'C'}]
Subtraction  B-A: [{'Frank' 'F'}, {'Gary' 'G'}]
Union A union B : [{'Andy' 'A'}, {'Bob' 'B'}, {'Carl' 'C'}, {'David' 'D'}, {'Ernie' 'E'}, {'David' 'D'}, {'Ernie' 'E'}, {'Frank' 'F'}, {'Gary' 'G'}]

Process finished with exit code 0

If you want to ignore the requirement of using a Set, you could use Java 8 Streams to solve the problem.

public static int numInCommon(List<Integer> list1, List<Integer> list2) {
    return (int) list1.stream()
        .distinct()
        .filter(i -> list2.contains(i))
        .count()
}

This is a four-step process:

• Get a stream of list1 (if you are not used to streams you can think of this as a loop, but in reality a call to .stream() by itself is not looping)
• Use .distinct() to ignore duplicate elements (that is, if the first list contains a number multiple times, it only processes it once. The .distinct() part uses a Set internally to keep track of which elements it has seen.
• Use .filter to only keep the numbers that also occur in the second list.
• .count() to count the number of seen elements. This returns a long which is why the entire result is typecast to an int here.

It's not until you call .count() that the loop is actually performed, this is because .count() is a "terminal operation".

I would recommend to read more about Streams on Oracle's website

It depends whether you're concerned about memory/time or both of them.

1. You're concerned about memory

   Go with the brute force N² solution because it uses no extra memory at all(only the memory required to keep the common elements), and N² in practice is not that bad for small size lists. Anyway, fetching the phone numbers from database is more likely to cause a bigger performance hit than your N² algorithm.

2. You're concerned about time but you can use extra memory

   Wrap your phone numbers into a wrapper class, and add all the phone numbers from the 1st list to a HashSet. Then, iterate over your 2nd list and check if set is containing the wrapped phone number or not. This will guarantee you a O(m+k*n) time ( you have to iterate each list just once , and HastSet's contains method is a constant k - where k represents the average number of Strings having the same hashCode.) . This tends to O(n) because 2 and k(should be 1 because String's hashSet() collisions are quite rare) are constant factors which can be discarded.

   class PhoneNumber { 
   
        private final String val;
   
        public PhoneNumber(final String val){
            this.val = val;
        }
   
        @Override
        public int hashCode(){
            return this.getVal().hashCode();
        }
   
        @Override
        public boolean equals(Object obj){
            if (this == obj) {
              return true;
            }
            if (obj == null) {
              return false;
            }
            if (this.getClass() != obj.getClass()) {
              return false;
            }
   
            PhoneNumber other = (PhoneNumber )obj;
            return PhoneNumberUtils.compare(this.getVal(), other.getVal()) == 0;
        }
   
        public String getVal(){
           return this.val;
        }
   } 
   
   private Set<PhoneNumber> getCommonPhoneNumbers(List<String> dbPhoneNumbers , List<String> userPhoneNumbers){
       Set<PhoneNumber> common = new HashSet<PhoneNumber>();
   
       Set<PhoneNumber> phoneNumbers = new HashSet<PhoneNumber>();
       for(String s : userPhoneNumbers){
           phoneNumbers.add(new PhoneNumber(s));
       }
   
       for(String s : dbPhoneNumbers ){
           PhoneNumber phoneNo = new PhoneNumber(s);
           if(phoneNumbers.contains(phoneNo)){
               common.add(phoneNo);
           }
       }
   
       return common;
   }
   

3. You're concerned about both the memory and the time complexity.

   Sort the 2 lists by using a custom comparator based on PhoneNumberUtils.compare(String,String) (this should take O(n log n)) and then iterate over both of the lists at once ( O(min(m,n)) ):

     private static final Comparator<String> phoneNoComp = new Comparator<String>(){
         @Override
         public int compare(final String s1, final String s2) {
           return PhoneNumberUtils.compare(s1,s2);
         }
     };
   
     private Set<String> getCommonPhoneNumbers(final List<String> list1 , final List<String> list2){
   
         Set<String> common = new HashSet<String>();
   
         Collections.sort(list1, phoneNoComp);
         Collections.sort(list2, phoneNoComp);
   
         int size1 = list1.size();
         int size2 = list2.size();
         int i = 0, j = 0;
   
         while(i < size1 && j < size2){
             int comparison = PhoneNumberUtils.compare(list1.get(i) , list2.get(j));
             if( comparison == 0) { // found a common element.
                 common.add(list1.get(i));
                 i++;
                 j++;
             }
             else if(comparison == 1){
                 j++;
             }
             else{
                 i++;
             }
         }
   
         return common;
     } 
   

Your code is O(n^2), i.e. has bad performance characteristic for large arrays.

For better performance, use Set instead of array. Set then provides nice helper methods.

Here is example code (see Wikipedia for set operators):

public static void main(String[] args) {
    int a[] = {1,2,3};
    int b[] = {3,4,5};

    Set<Integer> setA = toSet(a);
    Set<Integer> setB = toSet(b);

    // common = A ∩ B
    Set<Integer> common = new TreeSet<>(setA); // use TreeSet for sorted result
    common.retainAll(setB); // intersection: ∩
    System.out.println("common: " + common);

    // uncommon = (A ∪ B) \ common
    Set<Integer> uncommon = new TreeSet<>(setA); // use TreeSet for sorted result
    uncommon.addAll(setB); // union: ∪
    uncommon.removeAll(common); // asymmetric difference: \
    System.out.println("uncommon: " + uncommon);
}
private static Set<Integer> toSet(int... arr) {
    Set<Integer> set = new HashSet<>(arr.length * 4 / 3 + 1);
    for (int v : arr)
        set.add(v);
    return set;
}

Output

common: [3]
uncommon: [1, 2, 4, 5]

Use a hash table.

Iterate through the first linked list, entering the values you come across into a hash table.

Iterate through the second linked list, adding any element not found into the hash table into your list of non-common elements.

This solution should be O(n), assuming no collisions in the hash table.

You may use a set. Contains for a HashSet is O(1) compared to O(n) for a list, therefore you should never use a list if you often need to run contains.

Set<String> bSet = new HashSet<>(bListb);
aLista.stream().filter(a -> !bSet.contains(a)).collect(Collectors.toList());

to explain this in logic format(not Java):

UncommonRows = (currentRow union newErrorRow ) - (currentRow intersection newErrorRow)

here is a quick and dirty way of doing it in Java. hope the comments explains what I've done.

Set<Row> uncommonRows=new HashSet<Row>(currentRow);
uncommonRows.addAll(newErrorRow); //at this point uncommonRows contains all the Rows
Set<Row> retained=new HashSet<Row>(currentRow);
retained.retainAll(newErrorRow); //retained contains all rows that are in both sets.
uncommonRows.removeAll(retained) ; // at this point uncommonRows contains the uncommon Rows