Question

Lets say I have the array:

int[] taco = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

How can I move an element based its index to the front? Example:

Move element taco[5] to the front should produce this:

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// becomes
{5, 0, 1, 2, 3, 4, 6, 7, 8, 9}

EDIT:
Does it make a difference if the ints are instead objects?

Answer 1

1. Store the value you’re moving in a temporary int variable
2. Copy all elements down the array, one at a time, in a loop
3. Assign the value you stored in the temporary variable to the new position (the front of the array, taco[0], in this case)

It does not make any difference if it’s an array of int values, or objects. The algorithm is the same. Since an array of Object references would literally be an array of 32-bit or 64-bit memory references, you’re effectively still copying integers around.

Here is code that would do it – there are several ways to do this, but this is the basic idea:

public int[] moveValueAtIndexToFront(int[] arrayToBeShifted, int index) {
  int valueBeingMoved = originalArray[index];

  for (int i = index; i > 0; i--) {
    arrayToBeShifted[i] = arrayToBeShifted[i-1];
  }

  arrayToBeShifted[0] = valueBeingMoved;

  return arrayToBeShifted;
}

• This will moves all values at the specified index backward in the array by one position, and places the value being moved at the front.
• If the index passed in is 0, then nothing winds up being moved.
• If the index passed in happens to be the the index of the very last item in the array, every single item in the array needs to be shifted. If you’re dealing with large arrays, and you’re doing a lot of shifts of values late in the array, this becomes really inefficient, really fast.

You could also take a look at the source code of arraycopy if you’re curious, via the OpenJDK project.