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?
int variabletaco[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;
}
0, then nothing winds up being moved.You could also take a look at the source code of arraycopy if you're curious, via the OpenJDK project.
arraycopy versus a simple loop is irrelevant.
System.arraycopy does NOT allocate any memory. Perhaps you are confusing it with something else.int[] taco = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int index = 5;
int temp = taco[index];
for(int i = index; i > 0; i--) {
taco[i] = taco[i-1];
}
taco[0] = temp;
int[] taco = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int indexTarget = 7;
int valueAtIndex = taco[indexTarget];
for(int i = indexTarget; i > 0; i--){
taco[i] = taco[i-1];
}
taco[0] = valueAtIndex;
Because Java arrays have a fixed size, you should create a new array, and loop through the elements:
/**
* Moves the element wanted to the front of the array, and returns a new array.
* @param array The array to adjust
* @param position The position of the element
* @return The adjusted array
*/
private int[] moveElement (int[] array, int position)
{
// Create temporary array to hold values
int[] tempArray = new int[array.length];
// Set first value to your wanted element
tempArray[0] = array[position];
// Set values of array before array[position]
for (int tempPosition = 0; tempPosition < position; tempPosition++)
{
tempArray[tempPosition + 1] = array[tempPosition];
}
// Set values of array after array[position]
for (int tempPosition = position + 1; tempPosition < array.length; tempPosition++)
{
tempArray[tempPosition] = array[tempPosition];
}
// Return newly created array
return tempArray;
}
for the new added question:no it doesnot make any difference ,you just need to use a temp variable of object type variable instead of int variable.
private int[] moveToZero (int[] workOnArray, int position) {
workOnArray[0]=workOnArray[position]+workOnArray[0];
workOnArray[position]=workOnArray[0]-workOnArray[position];
workOnArray[0]=workOnArray[0]-workOnArray[position];
return workOnArray;
}
I wrote a sample, you can check it:
public static void main(String[] args) {
int[] taco = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int index = 2;
int tmp = taco[0];
int preValue;
taco[0]=taco[index];
for(int i=1,n=taco.length;i<n;i++){
if(i==index+1)
break;
preValue = taco[i];
taco[i]=tmp;
tmp=preValue;
}
for(int i=0,n=taco.length;i<n;i++){
System.out.println(taco[i]);
}
}
