You don't need two loops to do this, One loop is sufficient to fix it

ArrayList<String>> buttonresourceIds = new ArrayList<String>>();
ArrayList<String>> buttonresourceIds2 = new ArrayList<String>>();
int common=0;
for(int j=0;j<buttonresourceIds2.size();j++){
    if(buttonresourceIds.contains(buttonresourceIds2.get(j))){
        System.out.println("Exist : "+buttonresourceIds2.get(j));
        common++;
    }else{
        System.out.println("Not Exist : "+buttonresourceIds2.get(j));
    }
}
return common;

Convert Lists to Collection and use removeAll

    Collection<String> listOne = new ArrayList(Arrays.asList("a","b", "c", "d", "e", "f", "g"));
    Collection<String> listTwo = new ArrayList(Arrays.asList("a","b",  "d", "e", "f", "gg", "h"));


    List<String> sourceList = new ArrayList<String>(listOne);
    List<String> destinationList = new ArrayList<String>(listTwo);


    sourceList.removeAll( listTwo );
    destinationList.removeAll( listOne );



    System.out.println( sourceList );
    System.out.println( destinationList );

Output:

[c, g]
[gg, h]

[EDIT]

other way (more clear)

  Collection<String> list = new ArrayList(Arrays.asList("a","b", "c", "d", "e", "f", "g"));

    List<String> sourceList = new ArrayList<String>(list);
    List<String> destinationList = new ArrayList<String>(list);

    list.add("boo");
    list.remove("b");

    sourceList.removeAll( list );
    list.removeAll( destinationList );


    System.out.println( sourceList );
    System.out.println( list );

Output:

[b]
[boo]

Only iterate on first arraylist with larger length and check for contains in second arraylist , if found set one else do nothing

for(int counter = 0; counter < firstList.size(); counter++) {
    if(secondList.contains(firstList.get(counter))) {
          comparingList.set(counter,1);
      }
  }

Whole java program

Just try to run the below program in http://www.compileonline.com/compile_java_online.php

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

public class CompareArrayListTest{

 public static void main(String[] args) {

    ArrayList<String> firstList = new ArrayList<String>();

    firstList.add("book1");
    firstList.add("book2");
    firstList.add("book3");
    firstList.add("book4");

    ArrayList<String> secondList = new ArrayList<String>();

    secondList.add("book1");
    secondList.add("book2");
    secondList.add("book3");

    List<Integer> comparingList = new ArrayList<Integer>();
    // adding default values as one
    for (int a = 0; a < firstList.size(); a++) {
        comparingList.add(0);

    }

    for (int counter = 0; counter < firstList.size(); counter++) {
        if (secondList.contains(firstList.get(counter))) {
            comparingList.set(counter, 1);
        }
    }

    System.out.println(comparingList);

}

BitSet bitset = new BitSet();
// adding default values as one
for (int a = 0; a < firstList.size(); a++) {
    comparingList.add(0);

}

for (int counter = 0; counter < firstList.size(); counter++) {
    for (int counter2 = 0; counter < secondList.size(); counter++) {
        if (secondList.get(counter2).equals(firstList.get(counter))) {
            bitset.set(counter, 1);
        }
    }
}

Try this code.

char[] firstArray = {'a', 'b', 'c'};
char[] secondArray = {'a', 'b', 'c'};

if (firstArray.length != secondArray.length) {
    System.out.println("False.they are not equal");
} else {
    boolean isEqual = true;
    for (int i = 0; i < firstArray.length; i++) {
        if (firstArray[i] != secondArray[i]) {
            System.out.println("False.they are not equal");
            isEqual = false;
            break;
        }
    }
    if (isEqual)
        System.out.println("true.they are equal");
}

This only answers part of your question. I could not understand the question completely, please edit it and I can edit my answer.

You should not remove items from a list whilst in a for loop, therefore you can, for example, create another boolean list with the same size divided by 3 and just fill it with true Booleans then set the position divided by 3 to false if you want to delete the three items. Then you can create a new list, iterate over the boolean list and add 3 "Objects" which are actually Strings (thanks @JB Nizet) at a time, every time the boolean list element is true. When it is false you just don't add the elements and by doing so you are practically deleting the two elements before that element together with that element.

You casted a String to an int, that does not work you have to parse the Strings.

I corrected some of your code and added the boolean list here:

    ArrayList<String> lisM = new ArrayList<>();  // here I initialise the list as an array list with strings. 

    ArrayList<Boolean> booleanList = new ArrayList<>();
    for (int i = 0; i < lisM.size() / 3; i++) {
        booleanList.add(true);
    }

    for(int i = 3; i < lisM.size();i+=3) {
        int m = Integer.parseInt(lisM.get(i)); // here I changed the casting to parsing and moved it out of the for loop, there is no need to initialize it again every single time since you do not change it in the second for loop.
        for (int j = 6; j < lisM.size(); j += 6) {
            int m1 = Integer.parseInt(lisM.get(j));// here I changed the casting to parsing again.
            if (m > m1) { // this makes no sense here because you are going over all of the elements of the list and comparing them to all of them. But I kept it here for the sake of example.
                booleanList.set(i/3,false); 
            }

// if you want to go over the whole list you will have to clear the list and start over again for every element. } } and here is how you could create the new list without the elements you do not want:

ArrayList<String> newLisM = new ArrayList<>();

for (int i = 0; i <booleanList.size(); i++) {
        if(booleanList.get(i))
            for (int j = 0; j < 3; j++) {
                newLisM.add(lisM.get(i+j));
            }
    }

for (int i = 0; i < list.size(); i++) {
  for (int j = i+1; j < list.size(); j++) {
    // compare list.get(i) and list.get(j)
  }
}

you should use CollectionUtils.retainAll : Returns a collection containing all the elements in collection1 that are also in collection2.

ArrayList commonList = CollectionUtils.retainAll(list1,list2);

It is explicitly clear what your intent is with the C-like for loops - loop over every pair exactly once, so that the same pair with reversed members, e.g. (a, b) and (b, a) doesn't get processed again. That is what I would recommend; it works in Java just as well.

However, if you absolutely have to have the enhanced for loop, you can have the inner for loop operate over a sublist, with List's subList method, starting with the next element.

for (Object o1 : list) {
    List<Object> subList = list.subList(list.indexOf(o1) + 1, list.size());
    for (Object o2 : subList) {
         //Do something with o1 and o2
    }
}