Java - How can I merge 2 lists based on a third?

private static List<String> mergeListsUsingRef(List<String> listRefRaw, List<String> listA, List<String> listB) { List<String> listRef = uniques(listRefRaw); Set<String> common = new HashSet<>(); common.addAll(listA); common.addAll(listB); List<String> result = new ArrayList<>(listRef); result.retainAll(common); return result; } 

If the reference list is huge compared to both lists:

 return listRef.stream() .filter(common::contains) .collect(Collectors.toList()); 

This will keep the order of the reference list. The main problem here is that both listA and listB are not sets, so there is no fast contains-check possible.

private static List<String> uniques(List<String> listRefRaw) { Set<String> uniqueValues = new HashSet<>(); return listRefRaw.stream() .filter(s -> !uniqueValues.contains(s)) .peek(uniqueValues::add) .collect(Collectors.toList()); } 

The Stream.distinct() unfortunately is not stable on unordered collections, so the above should do.

The first two tests fail, because your expected lists are missing the second 4. There are two 4s present in the lists to be merged.

Well anyways, I just went through the ref and removed any matching items from the lists that are attempting to be merged.

public static <E extends Comparable<E>>List<E> merge(List<E> refList, List<E>... lists) { List<E> result = new ArrayList<E>(); Iterator<E> ref = refList.iterator(); boolean found = false; while (ref.hasNext()) { E curr = ref.next(); found = false; // Reset for (List<E> list : lists) { if (found) continue; // If already found, skip the next list for (Iterator<E>it = list.iterator(); !found && it.hasNext();) { E term = it.next(); boolean equal = term.equals(curr); if (equal) { result.add(term); list.remove(term); found = true; } } } } return result; } 

Full Example

import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.ListIterator; public class ListReferenceJoiner { public static final boolean DEBUG = true; public static void main(String[] args) { System.out.printf("Equal? %b%n", test1()); System.out.println("==================="); System.out.printf("Equal? %b%n", test2()); System.out.println("==================="); System.out.printf("Equal? %b%n", test3()); System.out.println("==================="); System.out.printf("Equal? %b%n", test4()); } private static boolean test1() { List<Integer> refList = asArrayList(1, 2, 3, 4, 5, 6, 4, 7, 8); List<Integer> listA = asArrayList(2, 3, 5, 4, 7); List<Integer> listB = asArrayList(4, 7, 8); List<Integer> expected = asArrayList(2, 3, 5, 4, 7, 8); return testRunner(refList, listA, listB, expected); // 2, 3, 4, 5, 4, 7, 8 } private static boolean test2() { List<Integer> refList = asArrayList(1, 2, 3, 4, 5, 6, 4, 7, 8); List<Integer> listA = asArrayList(2, 3, 4, 5, 7); List<Integer> listB = asArrayList(4, 7, 8); List<Integer> expected = asArrayList(2, 3, 4, 5, 7, 8); return testRunner(refList, listA, listB, expected); // 2, 3, 4, 5, 4, 7, 8 } private static boolean test3() { List<Integer> refList = asArrayList(1, 2, 3, 4, 5, 6, 4, 7, 8); List<Integer> listA = asArrayList(2, 3, 4, 5, 7); List<Integer> listB = asArrayList(6, 4, 7, 8); List<Integer> expected = asArrayList(2, 3, 4, 5, 6, 4, 7, 8); return testRunner(refList, listA, listB, expected); // 2, 3, 4, 5, 6, 4, 7, 8 } private static boolean test4() { List<Integer> refList = asArrayList(1, 2, 3, 4, 5, 6, 4, 7, 8); List<Integer> listA = asArrayList(2, 3, 4, 5, 7); List<Integer> listB = asArrayList(6, 7, 8); List<Integer> expected = asArrayList(2, 3, 4, 5, 6, 7, 8); return testRunner(refList, listA, listB, expected); // 2, 3, 4, 5, 6, 7, 8 } private static boolean testRunner(List<Integer> ref, List<Integer> listA, List<Integer> listB, List<Integer> expected) { if (DEBUG) { System.out.printf("Expecting: %s%n", expected); } List<Integer> actual = merge(ref, listA, listB); // 2, 3, 4, 5, 6, 7, 8 if (DEBUG) { System.out.printf("Actual: %s%n", actual); } return expected.equals(actual); } @SuppressWarnings("unchecked") public static <E extends Comparable<E>>List<E> merge(List<E> refList, List<E>... lists) { List<E> result = new ArrayList<E>(); Iterator<E> ref = refList.iterator(); boolean found = false; while (ref.hasNext()) { if (DEBUG) { printLists(lists); } E curr = ref.next(); found = false; // Reset for (List<E> list : lists) { if (found) continue; // If already found, skip the next list for (Iterator<E>it = list.iterator(); !found && it.hasNext();) { E term = it.next(); boolean equal = term.equals(curr); if (equal) { if (DEBUG) { System.out.printf("Found '%s'%n", term); } result.add(term); list.remove(term); found = true; } } } if (DEBUG && !found) { System.out.printf("Could not find '%s'%n", curr); } } return result; } private static <E> void printLists(List<E>... lists) { for (ListIterator< List<E>>it = Arrays.asList(lists).listIterator(); it.hasNext();) { printList(it.next(), getCharForNumber(it.nextIndex())); } } private static <E> void printList(List<E> list, String label) { System.out.printf("%s: ", label); for (Iterator< E>it = list.iterator(); it.hasNext();) { System.out.print(it.next()); if (it.hasNext()) { System.out.print(" | "); } } System.out.print(System.lineSeparator()); } @SuppressWarnings("unchecked") private static <E> List<E> asArrayList(E... values) { return new ArrayList<E>(Arrays.asList(values)); } protected static String getCharForNumber(int i) { return i > 0 && i < 27 ? String.valueOf((char) (i + 64)) : null; } } 

Here is a version of Maurice Perry's response, but it still does not preserve order.

private static <E> List<E> merge(final List<E> listRef, final List<E>... lists) { final List<E> res = new ArrayList<E>(); final List<List<E>> copies = Arrays.stream(lists).map(ArrayList::new).collect(Collectors.toList()); for (E ref : listRef) { boolean found = false; for (Iterator<List<E>> it = copies.iterator(); !found && it.hasNext();) { if (it.next().remove(ref)) { res.add(ref); found = true; } } if (found) { continue; } } return res; } 

Example Output

Testing: [2, 3, 5, 4, 7, 8] A: 2 | 3 | 5 | 4 | 7 B: 4 | 7 | 8 Could not find '1' A: 2 | 3 | 5 | 4 | 7 B: 4 | 7 | 8 Found '2' A: 3 | 5 | 4 | 7 B: 4 | 7 | 8 Found '3' A: 5 | 4 | 7 B: 4 | 7 | 8 Found '4' A: 5 | 7 B: 4 | 7 | 8 Found '5' A: 7 B: 4 | 7 | 8 Could not find '6' A: 7 B: 4 | 7 | 8 Found '4' A: 7 B: 7 | 8 Found '7' A: B: 7 | 8 Found '8' Actual: [2, 3, 4, 5, 4, 7, 8] Equal? false =================== Testing: [2, 3, 4, 5, 7, 8] A: 2 | 3 | 4 | 5 | 7 B: 4 | 7 | 8 Could not find '1' A: 2 | 3 | 4 | 5 | 7 B: 4 | 7 | 8 Found '2' A: 3 | 4 | 5 | 7 B: 4 | 7 | 8 Found '3' A: 4 | 5 | 7 B: 4 | 7 | 8 Found '4' A: 5 | 7 B: 4 | 7 | 8 Found '5' A: 7 B: 4 | 7 | 8 Could not find '6' A: 7 B: 4 | 7 | 8 Found '4' A: 7 B: 7 | 8 Found '7' A: B: 7 | 8 Found '8' Actual: [2, 3, 4, 5, 4, 7, 8] Equal? false =================== Testing: [2, 3, 4, 5, 6, 4, 7, 8] A: 2 | 3 | 4 | 5 | 7 B: 6 | 4 | 7 | 8 Could not find '1' A: 2 | 3 | 4 | 5 | 7 B: 6 | 4 | 7 | 8 Found '2' A: 3 | 4 | 5 | 7 B: 6 | 4 | 7 | 8 Found '3' A: 4 | 5 | 7 B: 6 | 4 | 7 | 8 Found '4' A: 5 | 7 B: 6 | 4 | 7 | 8 Found '5' A: 7 B: 6 | 4 | 7 | 8 Found '6' A: 7 B: 4 | 7 | 8 Found '4' A: 7 B: 7 | 8 Found '7' A: B: 7 | 8 Found '8' Actual: [2, 3, 4, 5, 6, 4, 7, 8] Equal? true =================== Testing: [2, 3, 4, 5, 6, 7, 8] A: 2 | 3 | 4 | 5 | 7 B: 6 | 7 | 8 Could not find '1' A: 2 | 3 | 4 | 5 | 7 B: 6 | 7 | 8 Found '2' A: 3 | 4 | 5 | 7 B: 6 | 7 | 8 Found '3' A: 4 | 5 | 7 B: 6 | 7 | 8 Found '4' A: 5 | 7 B: 6 | 7 | 8 Found '5' A: 7 B: 6 | 7 | 8 Found '6' A: 7 B: 7 | 8 Could not find '4' A: 7 B: 7 | 8 Found '7' A: B: 7 | 8 Found '8' Actual: [2, 3, 4, 5, 6, 7, 8] Equal? true 

Your code works correctly!

There are however 2 issues:

• Your logic doesn't need the null checks.

  Since equals(null) is required to return false, you can safely reduce if (a != null && ref.equals(a)) to just if (ref.equals(a))

• Your expectation for EX 1 is incorrect.

  The values match up like this:

  ref: "1", "2", "3", "4", "5", "6", "4", "7", "8" --------------------------------------------------- A: "2", "3", "5", "4", "7" B: "4", "7", "8" =================================================== result: "2", "3", "4", "5", "4", "7", "8" 

  But you're expecting

   "2", "3", "5", "4", "7", "8" 

  As you can see, you should be expecting the first 4 too.