在2D ArrayList中移动元素

Question

I have 2D ArrayList which was filled with elements (objects which contain images etc.) so the 2D array was full. After calling removing functions my array looks like the picture on the left side; on the right side you can see the desired result. Could someone please give me the idea how to reorganize my array as you can see on the picture?

The idea was to go from to bottom to top. If I find the gap (the gap means that I set the background of element to null , respectively, imageIcon is set to null ) I will switch it for the previous element. And because I have switched it I have to do it for the whole column. Problem is, when they are 2 or more gaps and also, this algorithm does nothing.

    for (int i = 0; i < 10; i++) {

        for (int j = 7; j > 0; j--) {
            Item currentItem = this.elements.get(j).get(i).getItem();

            if (currentItem.getBack().getIcon() == null) {
                int count = j;

                while (count > 1) {
                    Position temp = this.elements.get(count).get(i);
                    Position zero = this.elements.get(count).get(i);
                    Position previous = this.elements.get(count - 1).get(i);
                    zero = previous;
                    previous = temp;

                    count--;

                }

            }
        }
    }

The arrayed data size is limited to 10x8 because of my gameboard panel. The items in array are not distinguishable, they only have different backgrounds (type of JLabel component). The items have to "fall from top to down".

PS: I am creating a clone of Bejeweled

Answer 1

From what you have shown in the pictures, you want the column's elements to be "dropped to bottom"? If that is the case, you should probably use a regular 2D array instead of ArrayList , with an array for each of your columns , and assume the bottom is indexed 0 - why? because ArrayList doesn't have fixed size, and your problem statement shows you want the container to be of fixed size. The solution would then be (roughly, because you shown only a part of your code, not a SSCCE):

//Item[][] items;
for( Item[] arr : items )
  for( int i = arr.length - 2; i >= 0; i-- )
    if ( arr[i] == null ) // or arr[i].getBack().getIcon() == null or whatever
      for( int j = i; j < arr.length - 1; j++ )
        arr[j] = arr[j+1];

This is a crude bubble sort, suitable for small arrays. There are other solutions possible (as this is a sorting problem by itself - you may look up qsort for this), but this one is arguably the simplest.

Note: You may implement the very same solution for ArrayList s, yet I strongly advocate against it. Using nested ArrayList s to mimic multi-dim arrays is seldom a good idea - it'll create the arrays anyway, but you'll get a large overhead, making the code both slower and less readable - anyway you can do so by replacing [] s with get() / set() etc.

For the sake of reference:

//ArrayList<ArrayList<Item>> items;
//int columnHeight;
for( ArrayList<Item> arr : items )
  for( int i = columnHeight - 2; i >= 0; i-- )
    if ( arr.get(i) == null ) //or arr.get(i).getIcon()==null or whatever
      for( int j = i; j < columnHeight - 1; j++ )
        arr.set(j, arr.get(j+1));

or simply, by providing a comparator:

//ArrayList<ArrayList<Item>> items;
//int columnHeight;
for( ArrayList<Item> arr : items )
  Collections.sort(arr, new Comparator<Item>() {
    @Override
    public int compare(Item i1, Item i2) {
        return ...; // place the sorting rule here
    }
  });

For more info, see docs for Collections.sort() & Comparator .

Also, if this is indeed for Bejewelled clone - you may consider doing the "dropping" by doing an iteration dropping all jewels with an empty field beneath by one step, counting the amount of dropped jewels, and repeating this iteration till the amount of drops == 0. That's the algo I used in my clone in the days of the past.

Answer 2

As @vaxquis has already mentioned, it's better to rewrite your code in some more elegant way.

for (int i = 0; i < 10; i++) {

    // Perfoming bubble sort for each column
    boolean swapped = true;
    for(int j = 6; j > 0 && swapped; j--) {
        swapped = false;

        for (int k = 0; k < j; k++) {
            Item currentItem =  this.elements.get(k).get(i).getItem();
            Item nextItem    =  this.elements.get(k+1).get(i).getItem();

            if (currentItem.getBack().getIcon() != nextItem.getBack().getIcon()) {
                swap(currentItem, nextItem);   // implement this yourself
                swapped = true;
            }

        }
    }
}

Answer 3

Besides the algorithm issues addressed by the other answers, your main problem is that you never change anything in the arrays. The following code just moves some values between local variables:

Position temp = this.elements.get(count).get(i);
Position zero = this.elements.get(count).get(i);
Position previous = this.elements.get(count - 1).get(i);
zero = previous;
previous = temp;

You probably have a setItem() method to set things back into a Position object? Then a swap would be:

Position current = this.elements.get(count).get(i);
Position previous = this.elements.get(count - 1).get(i);
Item temp = current.getItem();
current.setItem(previous.getItem();
previous.setItem(temp);