Déplacer des éléments dans une ArrayList

Question

J'ai joué avec ArrayList s. Ce que j'essaie d'obtenir, c'est une méthode pour faire quelque chose comme ça :

Item 1
Item 2
Item 3
Item 4

J'essaie de pouvoir déplacer des éléments vers le haut de la liste, à moins qu'ils ne soient déjà en haut, auquel cas ils restent inchangés. Par exemple, si l'élément 3 était déplacé, la liste serait la suivante :

Item 1
Item 3
Item 2
Item 4

D'après ce que j'ai compris pour l'instant, je voudrais quelque chose de l'ordre de ce qui suit :

IF arrayname index is not equal to 0
THEN move up
ELSE do nothing

La partie qui me pose problème est celle qui concerne le "déplacement vers le haut". Tout conseil ou exemple de code sur la façon dont cela pourrait être réalisé serait très apprécié.

Answer 1

A Move l'élément de la liste est simplement ajouté :

// move item to index 0
Object object = ObjectList.get(index);
ObjectList.remove(index);
ObjectList.add(0,object);

A Swap deux éléments dans la liste, il suffit d'ajouter :

// swap item 10 with 20
Collections.swap(ObjectList,10,20);

Answer 2

Application de la récursion pour réorganiser les éléments d'une liste de tableaux

public class ArrayListUtils {
            public static <T> void reArrange(List<T> list,int from, int to){
                if(from != to){
                     if(from > to)
                        reArrange(list,from -1, to);
                      else
                        reArrange(list,from +1, to);

                     Collections.swap(list, from, to);
                }
            }
    }

Answer 3

Déplacer des éléments les uns par rapport aux autres est quelque chose dont j'avais besoin dans un de mes projets. J'ai donc écrit une petite classe util qui déplace un élément dans une liste à une position relative à un autre élément. N'hésitez pas à l'utiliser (et à l'améliorer ;))

import java.util.List;

public class ListMoveUtil
{
    enum Position
    {
        BEFORE, AFTER
    };

    /**
     * Moves element `elementToMove` to be just before or just after `targetElement`.
     *
     * @param list
     * @param elementToMove
     * @param targetElement
     * @param pos
     */
    public static <T> void moveElementTo( List<T> list, T elementToMove, T targetElement, Position pos )
    {
        if ( elementToMove.equals( targetElement ) )
        {
            return;
        }
        int srcIndex = list.indexOf( elementToMove );
        int targetIndex = list.indexOf( targetElement );
        if ( srcIndex < 0 )
        {
            throw new IllegalArgumentException( "Element: " + elementToMove + " not in the list!" );
        }
        if ( targetIndex < 0 )
        {
            throw new IllegalArgumentException( "Element: " + targetElement + " not in the list!" );
        }
        list.remove( elementToMove );

        // if the element to move is after the targetelement in the list, just remove it
        // else the element to move is before the targetelement. When we removed it, the targetindex should be decreased by one
        if ( srcIndex < targetIndex )
        {
            targetIndex -= 1;
        }
        switch ( pos )
        {
            case AFTER:
                list.add( targetIndex + 1, elementToMove );
                break;
            case BEFORE:
                list.add( targetIndex, elementToMove );
                break;
        }
    }

Answer 4

Stockez d'abord l'élément à fromIndex dans une variable distincte item et déplace les éléments voisins jusqu'à ce qu'il atteigne le toIndex . Enfin, définissez le toIndex à la item .

public class ArrayListMove {
    public static <E> void move(ArrayList<E> list, int fromIndex, int toIndex) {
        if (fromIndex >= list.size() || fromIndex < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(fromIndex, list.size()));
        if (toIndex >= list.size() || toIndex < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(toIndex, list.size()));
        if (fromIndex == toIndex) return;
        int from = fromIndex;
        E item;
        if (fromIndex < toIndex) {
            item = list.set(from, list.get(from + 1));
            from++;
            while (from < toIndex) {
                list.set(from, list.get(from + 1));
                from++;
            }
        } else {
            item = list.set(from, list.get(from - 1));
            from--;
            while (from > toIndex) {
                list.set(from, list.get(from - 1));
                from--;
            }
        }
        list.set(toIndex, item);
    }

    private static String outOfBoundsMsg(int index, int size) {
        return String.format(Locale.getDefault(), "Index: %d, Size: %d", index, size);
    }
}

Si vous utilisez kotlin, utilisez les fonctions d'extension.

fun <E> ArrayList<E>.move(fromIndex: Int, toIndex: Int) {
    if (fromIndex >= size || fromIndex < 0)
        throw IndexOutOfBoundsException(outOfBoundsMsg(fromIndex, size))
    if (toIndex >= size || toIndex < 0)
        throw IndexOutOfBoundsException(outOfBoundsMsg(toIndex, size))
    if (fromIndex == toIndex) return
    if (fromIndex < toIndex) {
        var from = fromIndex
        val item = set(from, get(from + 1))
        from++
        while (from < toIndex) {
            set(from, get(from + 1))
            from++
        }
        set(toIndex, item)
    } else {
        var from = fromIndex
        val item = set(from, get(from - 1))
        from--
        while (from > toIndex) {
            set(from, get(from - 1))
            from--
        }
        set(toIndex, item)
    }
}

private fun outOfBoundsMsg(index: Int, size: Int): String {
    return "Index: $index, Size: $size"
}