Move the first element of a list to the end

Question

is there any clever way to do that ? my best way was:

object next = list.get(0) ;
list.remove(0) ;
list.add(next) ;

if not is there any type of collection that will make that easier ? I don't like the need of a temporary object to store the element i want to move ..

EDIT: I have tested the propositions listed below, with my code:

    long starttime = System.nanoTime() ;
    for (int i = 0; i < ntours; i++){
        profit += retrieveGroupsWillPlay(groups, ngroups, limit) ;
    }
    long endtime = System.nanoTime() ;
    System.out.println("Timing: " + (endtime - starttime)) ;
    System.out.println("Profit: " + profit) ;

here is the results: (profit: 15, ensure that the result is right for my code) code:

private static int retrieveGroupsWillPlay(ArrayList<Integer> queue,int ngroups, int limit) { 
    int peopleWillPlay = 0 ;
    for (int i = 0; i < ngroups; i++){
        int nextGroup = queue.get(0) ;
        if(limit >= peopleWillPlay + nextGroup) {
            peopleWillPlay += nextGroup ;
            queue.add(nextGroup) ;
            queue.remove(0) ;
        }
        else break ;
    }
    return peopleWillPlay ;
}

results:

Timing: 23326
Profit: 15
Timing: 22171
Profit: 15
Timing: 22156
Profit: 15
Timing: 22944
Profit: 15
Timing: 22240
Profit: 15
Timing: 21769
Profit: 15
Timing: 21866
Profit: 15
Timing: 22341
Profit: 15
Timing: 24049
Profit: 15
Timing: 22420
Profit: 15

code:

private static int retrieveGroupsWillPlay(ArrayList<Integer> queue,int ngroups, int limit) { 
    int peopleWillPlay = 0 ;
    for (int i = 0; i < ngroups; i++){
        int nextGroup = queue.get(0) ;
        if(limit >= peopleWillPlay + nextGroup) {
            peopleWillPlay += nextGroup ;
            Collections.rotate(queue, -1) ;
        }
        else break ;
    }
    return peopleWillPlay ;
}

results:

Timing: 92101
Profit: 15
Timing: 87137
Profit: 15
Timing: 84531
Profit: 15
Timing: 105919
Profit: 15
Timing: 77019
Profit: 15
Timing: 84805
Profit: 15
Timing: 93393
Profit: 15
Timing: 77079
Profit: 15
Timing: 84315
Profit: 15
Timing: 107002
Profit: 15

code:

private static int retrieveGroupsWillPlay(ArrayList<Integer> queue,int ngroups, int limit) { 
    int peopleWillPlay = 0 ;
    for (int i = 0; i < ngroups; i++){
        int nextGroup = queue.get(0) ;
        if(limit >= peopleWillPlay + nextGroup) {
            peopleWillPlay += nextGroup ;
            queue.add(queue.remove(0)) ;
        }
        else break ;
    }
    return peopleWillPlay ;
}

results:

Timing: 28079
Profit: 15
Timing: 28994
Profit: 15
Timing: 29525
Profit: 15
Timing: 22240
Profit: 15
Timing: 38326
Profit: 15
Timing: 33742
Profit: 15
Timing: 21500
Profit: 15
Timing: 22714
Profit: 15
Timing: 20939
Profit: 15
Timing: 30157
Profit: 15

code:

private static int retrieveGroupsWillPlay(LinkedList<Integer> queue,int ngroups, int limit) { 
    int peopleWillPlay = 0 ;
    for (int i = 0; i < ngroups; i++){
        int nextGroup = queue.get(0) ;
        if(limit >= peopleWillPlay + nextGroup) {
            peopleWillPlay += nextGroup ;
            queue.addLast(queue.removeFirst()) ;
        }
        else break ;
    }
    return peopleWillPlay ;
}

result:

Timing: 31104
Profit: 15
Timing: 42332
Profit: 15
Timing: 36443
Profit: 15
Timing: 31840
Profit: 15
Timing: 31387
Profit: 15
Timing: 32102
Profit: 15
Timing: 31347
Profit: 15
Timing: 30666
Profit: 15
Timing: 32781
Profit: 15
Timing: 32464
Profit: 15

code:

private static int retrieveGroupsWillPlay(LinkedList<Integer> queue,int ngroups, int limit) { 
    int peopleWillPlay = 0 ;
    for (int i = 0; i < ngroups; i++){
        int nextGroup = queue.get(0) ;
        if(limit >= peopleWillPlay + nextGroup) {
            peopleWillPlay += nextGroup ;
            queue.offer(queue.poll()) ;
        }
        else break ;
    }
    return peopleWillPlay ;
}

results:

Timing: 35389
Profit: 15
Timing: 34849
Profit: 15
Timing: 43606
Profit: 15
Timing: 41796
Profit: 15
Timing: 51122
Profit: 15
Timing: 59302
Profit: 15
Timing: 32340
Profit: 15
Timing: 35654
Profit: 15
Timing: 34586
Profit: 15
Timing: 35479
Profit: 15 

Solution 1

I'm not exactly sure what you want to do, but here goes:

If you're using something like an ArrayList, you can do:

list.add(list.remove(0));

Please keep in mind that remove from an ArrayList runs in linear time, that is, O(N), so that is extremely inefficient.

In case you can choose the type of List, you probably want a LinkedList, that implementes the Dequeue interface, so it would allow you to do something like:

list.offer(list.poll());

Both offer and poll are operations done in constant time.

If you want to use a builtin from the Collections class, you can do as @dasblinkenlight suggested and use Collections.rotate(list, -1); (adding it here for completeness).

Solution 2

You can use Collections.rotate for that:

Collections.rotate(list, -1);

Solution 3

You don't need a temp variable just write:

list.add(list.remove(0));

Solution 4

You want a dequeu (short for double ended queue).

Solution 5

The obvious answer is:

list.add(list.remove(0))

which is the most elegant way, I believe. You could alternatively use

Collections.swap(list.get(0), list.get(list.size()-1))

however that will change position of another element (the last one). You could also use Collections.rotate(list, -1), however rotating the list could mean moving all of its elements (it depends on List implementation I guess) and that might not be efficient.

View more solutions