Here's a plain implementation without using any third-party library. Main advantage over retainAll, removeAll and addAll is that these methods don't modify the original lists input to the methods.

public class Test {

    public static void main(String... args) throws Exception {

        List<String> list1 = new ArrayList<String>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<String>(Arrays.asList("B", "C", "D", "E", "F"));

        System.out.println(new Test().intersection(list1, list2));
        System.out.println(new Test().union(list1, list2));
    }

    public <T> List<T> union(List<T> list1, List<T> list2) {
        Set<T> set = new HashSet<T>();

        set.addAll(list1);
        set.addAll(list2);

        return new ArrayList<T>(set);
    }

    public <T> List<T> intersection(List<T> list1, List<T> list2) {
        List<T> list = new ArrayList<T>();

        for (T t : list1) {
            if(list2.contains(t)) {
                list.add(t);
            }
        }

        return list;
    }
}

You could make it easier to understand by writing it like this:

/**
 * Computes the intersection of two Lists of Strings, returning it as a new ArrayList of Strings
 *
 * @param list1 one of the Lists from which to compute an intersection
 * @param list2 one of the Lists from which to compute an intersection
 *
 * @return a new ArrayList of Strings containing the intersection of list1 and list2
 */
public ArrayList<String> intersection( List<String> list1, List<String> list2) {   
    ArrayList<String> result = new ArrayList<String>(list1);

    result.retainAll(list2);

    return result;
}

Approaching programming interview questions

One of the most important things during programming interviews is clarifying the problem. If the task is intersection of lists as opposed to sets, an important question is how to handle duplicate values.

For example, the current implementation is buggy. The intersection method will return a,a,a for the input a,a,a and a,a, but it will give a,a for the input a,a and a,a,a. The logical assumption would be that it should always return a,a regardless of the order of parameters. Then again, you should not just assume things, you should ask for the expected behavior, or at least state your assumptions loud and clear.

And if there can be no duplicates in the inputs, then why aren't they sets instead of lists?

Why is ArrayList specified instead of just List? ArrayList is a specific implementation, when List is the general concept.

Generic type tokens

String, the name of a common class in the JDK, and written in PascalCase, is a terrible choice for a generic type token in this code:

public <String> List<String> intersection(List<String> list1, List<String> list2) {
    List<String> list = new ArrayList<String>();

    for (String t: list1) {
        if(list2.contains(t)) {
            list.add(t);
        }
    }

    return list;
}

It should have been written like this:

public static <T> List<T> intersection(List<T> list1, List<T> list2) {
    List<T> list = new ArrayList<>();

    for (T t : list1) {
        if (list2.contains(t)) {
            list.add(t);
        }
    }

    return list;
}

Intersection of many lists

But how do I make it work for multiple ArrayLists inside one ArrayList?

I'm not sure I get what's blocking you. Perhaps you mean, instead of the intersection of 2 lists, how to intersect more than 2?

In that case, that's an interesting question to discuss about, and consider different alternatives, starting from simple (brute force) techniques, and then trying to improve.

Simple solution: if you have n lists, you could intersect the first 2, then intersect the result with the 3rd, then intersect the result with the 4th, and so on, until the last. The final result will be the intersection of all the lists, reachable in n - 1 steps.

Is it possible to do better?

• Hint 1: consider the concept of divide and conquer.
• Hint 2: how does merge sort work?

Ok so as per my understanding you need to intersect all arraylists contain under arrayList2D.

public <T> List<T> intersection(List<T> list1, List<T> list2) {
    list1.retainAll(list2);
    return list1;
}

make other method which you need to call

public static List<Integer> getAllIntersection(ArrayList<ArrayList<Integer>> arrayList2D) {
    List<Integer> finalList = arrayList2D.get(0);
    for (int i=1; i<arrayList2D.size(); i++) {
        finalList=intersection(finalList,arrayList2D.get(i));
    }
    System.out.println("firstList"+finalList);
    return finalList;
}

then finaly call getAllIntersection(arrayList2D) to get desire result

The intersection of two lists is done using the retainAll() method.

It update the list, so if you don't want that, you should copy the list first.

If you have more than 2 lists, you copy the first and then call retainAll() for each of the remaining lists.

ArrayList<ArrayList<String>> lists = ...

List<String> intersection = new ArrayList<>(lists.get(0));
for (List<String> list : lists.subList(1, lists.size()))
    intersection.retainAll(list);

However performance will be a bad O(n*m), where n and m are the sizes of the two largest lists.

That is because retainAll() does a contains() against the list given in the parameter, which is a sequential search, for each element in the intersection list.

Performance can be improved to O(n), where n is the largest list, by converting the lists to sets.

List<String> intersection = new ArrayList<>(lists.get(0));
for (List<String> list : lists.subList(1, lists.size()))
    intersection.retainAll(new HashSet<>(list));

In Java 8+, the for loop can be simplified to one of these:

lists.subList(1, lists.size()).stream().map(HashSet::new).forEach(intersection::retainAll);

lists.subList(1, lists.size()).forEach(list -> intersection.retainAll(new HashSet<>(list)));