How do I add non-existing values in from arrayList2 to arrayList1?

Question

Let's say I have an arrayList1 of Points. The data structure is like this :

(1,2)->(2,2)->(3,2)->(4,2)->(5,2)

I have another arrayList2 of Points :

(2,2)->(1,2)->(8,5)->(9,3)

How do I compare the two lists and add non-existing values from arrayList2 to arrayList1?

current solution

The only method I can think of now is using a for loop to compare each of the Points in arrayList1 such as, if(!arrayList1.contains(arrayList2.get(i))){ arrayList1.add(arrayList2.get(i)); } i++;.

Is there a more efficient way or already prepared method from a class? Because I have arrayList1 until arrayList6 to compare and replace....

Answer 1

1. For one-liner lovers (running demo):

   List<Point> list3 = new ArrayList<Point>(new HashSet<Point>(list1){{ addAll(list2); }});
   

2. Safe version * (running demo):

   Set<String> tmpSet = new HashSet<String>(arrayList1);
   tmpSet.addAll(arrayList2);
   List<String> mergedList = new ArrayList<String>(tmpSet);
   

   * As correctly pointed out by Bruce Wayne, Double Brace initialization (the one-liner example, also used in both examples to populate the first two lists) should be used with care, due to the potential drawbacks described in the following article:

   Don’t be “Clever”: The Double Curly Braces Anti Pattern

Explanation: Sets can't contain duplicates, so use one as transition vector.

Example 1 code:

List<String> arrayList1 = new ArrayList<String>(){{ add("One"); add("Two");   }};
List<String> arrayList2 = new ArrayList<String>(){{ add("Two"); add("Three"); }};   
List<String> mergedList = new ArrayList<String>(new HashSet<String>(arrayList1){{ addAll(arrayList2); }});
System.out.println(mergedList);

Output: [One, Two, Three]

Example 2 code:

List<String> arrayList1 = new ArrayList<String>(){{ add("One"); add("Two");   }}; 
List<String> arrayList2 = new ArrayList<String>(){{ add("Two"); add("Three"); }}; 
Set<String> tmpSet = new HashSet<String>(arrayList1);
tmpSet.addAll(arrayList2);
List<String> mergedList = new ArrayList<String>(tmpSet);
System.out.println(mergedList);

Output: [One, Two, Three]

Answer 2

If time complexity is your main priority, add all the points in List1 to a HashSet<Point>.

Then, for each list thereafter, loop through it and see if the set contains each point and if not, add it to List1.

Set<Point> pointsInList1 = new HashSet<>(list1);
for(Point p : list2)
{
    if(!pointsInList1.contains(p)) {
        list1.add(p);
        pointsInList1.add(p);
    }
}

//Repeat for other lists

This solution is linear with respect to the size of the largest list.

Answer 3

You should use a Set. It is a collection with no duplicates. So you can add the same value twice, it will be present only one time.

It means you can add many List in your Set, you will not have duplicates in it.

    Set setA = new HashSet(); 

    ArrayList<Point> points1 = new ArrayList<Point>();
    ArrayList<Point> points2 = new ArrayList<Point>();

    Point element1 = new Point(0,0);
    Point element2 = new Point(0,1);
    Point element3 = new Point(0,0);
    Point element4 = new Point(0,2);

    points1.add(element1); 
    points1.add(element2); 
    points1.add(element3);

    points2.add(element1);
    points2.add(element4);

    setA.addAll(points1);
    setA.addAll(points2);

    Iterator<Point> it = setA.iterator();
    while(it.hasNext())
        System.out.println(it.next());

Output :

java.awt.Point[x=0,y=0]
java.awt.Point[x=0,y=1]
java.awt.Point[x=0,y=2]

Answer 4

It can have multiple solutions. As you are using java.awt.Point class which already has equals method overridden(based on the coordinates). So, you can easily use contains method of List class.

for(Point point : list2){
     if(!list1.contains(point)){
         list1.add(point);
     }
}

Make sure to use for each loop for a better performance (Do not use index based loop (It makes a difference if you are using LinkedList)).

ii) Another alternative is to use java.util.Set and use its method addAll(Set). As Set does not all duplicates and hence will merge the elements efficiently.

Answer 5

You can do something like this

    list2.removeAll(list1);
    list1.addAll(list2);

Answer 6

You have to override your equal function in your Point Class

and then you could iterate over these two list, and compare their values.

Answer 7

How do I compare the two lists

That one is easy, just use equals.

add non-existing values from arrayList2 to arrayList1

• remove all elements of arrayList1 from arrayList2 and add it to the arrayList2. That way only the new elements will be added to arrayList2
• get the difference (arrayList1 - arrayList2) and add these to arrayList2 (for instance with CollectionUtils)

Your current solution is probably wrong (it will either skip one element or run forever, depending on your loop):

if(arrayList1.contains(arrayList2.get(i))) {
  i++; // this shouldn't be there if done in the loop
} else {
  arrayList1.add(arrayList2.get(i)); // here a ++ is needed if not in the loop
}

Is there a more efficient way

A little advice:
First, make it work (and have a good UnitTest coverage). Then (and only then!) optimize if needed!