First, you should fix:

if(list[i]=  list[k]){

To be:

if(list.get(i) == list.get(k)){

Second, you should add a condition to make sure i != k (or in other words - you're not comparing an element to itself.

And third, you can't access a list like you do: list[i] you should use list.get(i)

palacsint's answer is good, but it's missing just a few things.

All in-built Java collection classes I can think of has copy-constructors, and an addAll method. So your addEverything method can be a one liner, when using a Set<GameState>:

public void addEverything() {
    opened.addAll(current.neighbours);
}

Or, if you would like to reset the contents and create an entirely new Set, use the copy-constructor:

public void replaceEverything() {
    opened = new LinkedHashSet<GameState>(current.neighbours);
}

Since it can become a one-liner, you might not need to have it in it's own method.

Most importantly, if you are not interested in the order of the opened set, use a HashSet rather than a LinkedHashSet.

You can try intersection() and subtract() methods from CollectionUtils.

intersection() method gives you a collection containing common elements and the subtract() method gives you all the uncommon ones.

They should also take care of similar elements

First of all, let me point out that removing elements from a list that you're iterating over is pretty dangerous in general.

The outer loop itself isn't a problem, since you're going over the indices starting at the end and going to the start. Removing the item at the current index doesn't have any effect on the indices that will be handled in the next iterations.

However, when we nest 2 for loops iterating over all the elements we would run into problems.

Let's say you have the list {A,B,C,D}. We ignore comparing D to D. Next we compare D to C and conclude that C can be removed. Next we compare D to B and conclude B can be removed. Finally compare D to A and do nothing. Now the next x will be 2. But since we removed B and C from our list the function list.get(2) will throw an IndexOutOfBoundsException.

It seems you tried to solve this problem by using a break statement to jump out of the inner for loop whenever you remove an item. But this has introduced a new mistake.

Let's say in the same list you are comparing C to D and conclude that D can be removed. You now break out of the inner loop and continue with B. But by doing so you skipped comparing C to B and comparing C to A.

So then what can we do to solve this correctly? Instead of directly removing the VG's from the list we should just mark the VG's for removal in the first pass.

Then after the outer for loop has ended, we loop over all the marked VG's again and safely remove them from the list.

We can also simplify the loops a little bit if we check the contains both ways at once. The code will look like this:

List<TreeDataGroup> markedForRemoval = new ArrayList<>();
for (int x = treeDataGroups.size()-1; x >= 0; x--) {
    TreeDataGroup treeDg1 = treeDataGroups.get(x);
    //**important** notice the y>x instead of y>=0
    for (int y = treeDataGroups.size()-1; y > x; y--) {
        TreeDataGroup treeDg2 = treeDataGroups.get(y);
        if (treeDg1 fully contains treeDg2) {
            markedForRemoval.add(treeDg2);
        }
        if (treeDg2 fully contains treeDg1) {
            markedForRemoval.add(treeDg1);
        } 
    }
}

for(TreeDataGroup group : markedForRemoval){
    treeDataGroups.remove(group);
}

If I understood your initial explanation correctly the lists inside the datagroups are sorted. So I think we can do both checks at the same time with something like this: (disclaimer: I did not test this code, you might have to correct it to get it to work). Note that I'm also assuming the lists are non-null but default to an empty list like @cHao suggested in his answer.

private void markGroupForRemoval(TreeDataGroup group1, TreeDataGroup group2, List<TreeDataGroup> markedGroups){
    boolean markg1 = true;
    boolean markg2 = true;

    int i1 = 0;
    int i2 = 0;
    while(i1 < group1.getDataAndVar().length 
                && i2 < group2.getDataAndVar().length 
                && (markg1 || markg2)){
        if(group1.getDataAndVar().get(i1) == group2.getDataAndVar().get(i2)){
            i1++;
            i2++;
        } else if(group1.getDataAndVar().get(i1) < group2.getDataAndVar().get(i2)){ //note, you should change this to a string comparison I believe
            //group 1 contains an element that group2 does not.
            markg1 = false;
            i1 ++;
        } else {
            //group 2 contains an element that group1 does not.
            markg2 = false;
            i2 ++;
        }
    }

    //do the same thing for getDataNotVar, but mark the oposite.
    i1 = 0;
    i2 = 0;
    while(i1 < group1.getDataNotVar().length 
                && i2 < group2.getDataNotVar getDataNotVar().length 
                && (markg1 || markg2)){
        if(group1.getDataNotVar().get(i1) == group2.getDataNotVar().get(i2)){
            i1++;
            i2++;
        } else if(group1.getDataNotVar().get(i1) < group2.getDataNotVar().get(i2)){ //note, you should change this to a string comparison I believe
            //group 1 contains a not-element that group2 does not.
            markg2 = false;
            i1 ++;
        } else {
            //group 1 contains a not-element that group2 does not.
            markg1 = false;
            i2 ++;
        }
    }

    if(markg1){
        markedGroups.add(group1);
    }
    if(markg2){
        markedGroups.add(group2);
    }
}

Notice here that as soon as we marked both groups as still needed (so both markg1 and markg2 are false) then we quit the while loop early.

If you can get this to work it should speed things up a bit (or a lot, if the early exit while checking happens fast consistently). You'll need to at least replace the < with the correct comparison check. (StringComparitor?). Maybe group2.getDataAndVar().length should be group2.getDataAndVar().size() instead. And check the logic because I might have switched the cases around by accident.

If you're familiar with merge sort this algorithm should be relatively easy to understand.

EDIT: as per suggestion by @cHao, we're now comparing VG's even if they're already marked for removal. Since the checks themselves are rather expensive it's better to avoid that.

My first solution for this would be something like this:

List<TreeDataGroup> markedForRemoval = new ArrayList<>();
for (int x = treeDataGroups.size()-1; x >= 0; x--) {
    TreeDataGroup treeDg1 = treeDataGroups.get(x);
    for (int y = treeDataGroups.size()-1; y > x; y--) {
        TreeDataGroup treeDg2 = treeDataGroups.get(y);
        if(marmarkedForRemoval.contains(treeDG2) {
            continue;
        }
        markGroupForRemoval(treeDG1, treeDG2, markedForRemoval);
        if(markedForRemoval.contains(treeDG1){
            break;
        }
    }
}

Where the check for treeDG2 results in skipping that one in the inner loop only (if we would break out of the loop we get the same missing checks like before). And the check for treeDG1 right after the marking means that since the VG of the outer loop is marked, there's no reason to continue checking that one against the rest of the inner loop.

But we can actually do a little better than this. Remember that I said that removing in a single for loop is safe? Let's use that fact and place the removal inside the outer for loop:

List<TreeDataGroup> markedForRemoval = new ArrayList<>();
for (int x = treeDataGroups.size()-1; x >= 0; x--) {
    TreeDataGroup treeDg1 = treeDataGroups.get(x);
    for (int y = treeDataGroups.size()-1; y > x; y--) {
        TreeDataGroup treeDg2 = treeDataGroups.get(y);
        markGroupForRemoval(treeDG1, treeDG2, markedForRemoval);
        if(markedForRemoval.contains(treeDG1){
            break;
        }
    }
    for(TreeDataGroup tdg : markedForRemoval){
        treeDataGroups.remove(tdg);
    }
    markedForRemoval.clear();
}

Now we're sure that we check all combinations but without doing any unnecessary checks.

I did however spot a mistake thanks to @cHao's comment. If the 2 VG's are exactly the same, both will be marked for removal. This is not what we want. So let's fix this at the end of the markGroupForRemoval method

    if(markg1){
        markedGroups.add(group1);
        return; //important. If both are equal, we shouldn't remove them both.
    }
    if(markg2){
        markedGroups.add(group2);
    }
}