find out the elements of an arraylist which is not present in another arraylist

I have to find a best way to find out that elements which is not presented in the second arraylist. suppose

Arraylist a,b, 

Arraylist a={1,2,3,4,5};
Arraylist b={2,3,4};

     

So basically what I want is to find out that elements of a which is not present in arraylist b.

So what is the best solutions to do that?

List<Integer> c = new ArrayList<>(a);
c.removeAll(b);

Also consider to use Sets instead of Lists.

here is another approach using java 8 -

a.stream().filter(b::contains).collect(Collectors.toList());

You could use Apache Commons Collections, which has a method explicitly for this purpose:

public static void main(String[] args) {
	List<Integer> a = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
	List<Integer> b = Arrays.asList(new Integer[] { 2, 3, 4 });
	Collection<Integer> aMinusB = CollectionUtils.subtract(a, b);
	System.out.println(aMinusB);
}

The printed result is: [1, 5].

The Apache Commons libs are well tested and commonly used to extend standard Java functionalities. This particular method accepts Iterable as parameters, so you can use any Collection you want. You can also mix different collection types:

public static void main(String[] args) {
    List<Integer> a = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
    Set<Integer> b = new HashSet<Integer>(Arrays.asList(new Integer[] { 2, 3, 4 }));
    Collection<Integer> aMinusB = CollectionUtils.subtract(a, b);
    System.out.println(aMinusB);
}

The printed result is the same, [1, 5].

Check out the Javadoc here.

---

For sake of completeness, Google's Guava library does not have this feature:

>Collection *subtract*(Collection, Collection)
No equivalent--create an ArrayList containing a and then call remove on it for each element in b.

However, it implements a method called Sets.difference() method, which you could use if you prefer Guava and work with sets:

public static void main(String[] args) {
	Set<Integer> a = new HashSet<Integer>(Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 }));
	Set<Integer> b = new HashSet<Integer>(Arrays.asList(new Integer[] { 2, 3, 4 }));
	Set<Integer> aMinusB = Sets.difference(a, b);
	System.out.println(aMinusB);
}

The result is all elements in a that doesn't exist in b (i.e. [1, 5] again). Of course, the order is not determined since it operates on sets.

You can try removeAll:

List<Integer> notPresent = new ArrayList<Integer>(a);
notPresent.removeAll(b);

Use org.apache.commons.collections4.ListUtils

Given

List<Integer> a = Arrays.asList(new Integer[]{  1,2,3,4,5});
List<Integer> b = Arrays.asList(new Integer[]{0,1,2,3});

Action

List<Integer> c = ListUtils.removeAll(b, a)

Result in List c

4, 5

Please try like this

for (Object o : a) {  
  if (!b.contains(o)) {  
    // this is not present
  }  
}  

Loop through one list, then check if each element in other list using contains.

Something like this. If you think there may be duplicates in a you can try another type of Collection, like a Set for notPresent.

   List<Integer> notPresent = new ArrayList<Integer>();
    
    for (Integer n : a){
     if (!b.contains(n)){
       notPresent.add(n);
     }
    }

Try this:

 public static void main(String[] args) {
        List<Integer> a = new ArrayList<Integer>();
        List<Integer> b = new ArrayList<Integer>();
        List<Integer> exclusion = new ArrayList<Integer>();

        a.add(1);
        a.add(2);
        a.add(3);
        a.add(4);

        b.add(1);
        b.add(2);
        b.add(3);
        b.add(5);

        for (Integer x : a) {
            if (!b.contains(x)) {
                exclusion.add(x);
            }
        }

        for (Integer x : exclusion) {
            System.out.println(x);
        }

    }

Try this...

Use the contains() method of List.

ArrayList<Integer> aList = new ArrayList<Integer>();

for (Integer i : a){

      if (!(b.contains(i))){

             aList.add(i);

       }

     else{
             continue;

      }

 }