Мне интересно, есть ли более эффективный способ замены двух элементов в массиве, чем что-то вроде этого:
String temp = arr[1];
arr[1] = arr[2];
arr[2] = temp;
Ну, это явно не плохо или даже неправильно, но мне нужно часто меняться, поэтому мне интересно, есть ли какие-либо Libs или что-то, что обеспечивает более эффективный способ сделать это?
Неа. У вас может быть функция, позволяющая сделать ее более кратким в каждом месте, где вы ее используете, но в итоге работа была бы одинаковой (плюс накладные расходы на вызов функции до тех пор, пока HotSpot не переместил ее inline — с этим сделаем functon static final).
Это должно сделать его бесшовным:
public static final <T> void swap (T[] a, int i, int j) {
T t = a[i];
a[i] = a[j];
a[j] = t;
}
public static final <T> void swap (List<T> l, int i, int j) {
Collections.<T>swap(l, i, j);
}
private void test() {
String [] a = {"Hello", "Goodbye"};
swap(a, 0, 1);
System.out.println("a:"+Arrays.toString(a));
List<String> l = new ArrayList<String>(Arrays.asList(a));
swap(l, 0, 1);
System.out.println("l:"+l);
}
Если вы хотите поменять строку. это уже эффективный способ сделать это.
Однако, если вы хотите поменять целое число, вы можете использовать XOR для более эффективного обмена двумя целыми числами:
int a = 1; int b = 2; a ^= b; b ^= a; a ^= b;
Если вы меняете номера и хотите получить сжатый способ написать код, не создавая отдельную функцию или используя запутанный хакер XOR, я считаю, что это намного проще понять, и это также один лайнер.
public static void swap(int[] arr, int i, int j) {
arr[i] = (arr[i] + arr[j]) - (arr[j] = arr[i]);
}
То, что я видел в некоторых примитивных тестах, заключается в том, что разница в производительности в целом также незначительна.
Невероятно поздно для вечеринки (мои извинения), но может быть реализовано более общее решение, чем предоставленные здесь (будет работать как с примитивами, так и с не примитивами):
public static void swap(final Object array, final int i, final int j) {
final Object atI = Array.get(array, i);
Array.set(array, i, Array.get(array, j));
Array.set(array, j, atI);
}
Вы теряете безопасность во время компиляции, но это должно сделать трюк.
Примечание I: вы получите NullPointerException, если данный array равен null, a IllegalArgumentException, если данный array не является массивом, а ArrayIndexOutOfBoundsException, если любой из индексов недействительны для данного array.
Примечание II. Для этого для каждого типа массива (Object[] и всех примитивных типов) существуют отдельные методы, которые будут более эффективными (используя другие подходы, приведенные здесь), поскольку для этого требуется некоторый бокс/распаковка. Но также было бы намного больше кода для написания/поддержки.
Попробуйте следующее:
int lowIndex = 0;
int highIndex = elements.length-1;
while(lowIndex < highIndex) {
T lowVal = elements[lowIndex];
T highVal = elements[highIndex];
elements[lowIndex] = highVal;
elements[highIndex] = lowVal;
lowIndex += 1;
highIndex -=1;
}
Используйте Collections.swap и Arrays.asList:
Collections.swap(Arrays.asList(arr), i, j);
во-первых, вы не должны писать for (int k = 0; k **<** data.length **- 1**; k++) потому что <до тех пор, пока k не станет меньше длины -1 и тогда цикл будет выполняться до последней позиции в массиве и не будет занимать последнее место в массиве; поэтому вы можете исправить это двумя способами: 1: for (int k = 0; k <= data.length - 1; k++) 2: for (int k = 0; k < data.length; k++) и тогда все будет работать нормально !!! и для обмена вы можете использовать: сохранить один из int в другом месте, а затем заменить
int x = data[k]
data[k] = data[data.length - 1]
data[data.length - 1] = x;
потому что вы не хотите потерять один из Int!
Решение для объектных и примитивных типов:
public static final <T> void swap(final T[] arr, final int i, final int j) {
T tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final boolean[] arr, final int i, final int j) {
boolean tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final byte[] arr, final int i, final int j) {
byte tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final short[] arr, final int i, final int j) {
short tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final int[] arr, final int i, final int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final long[] arr, final int i, final int j) {
long tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final char[] arr, final int i, final int j) {
char tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final float[] arr, final int i, final int j) {
float tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static final void swap(final double[] arr, final int i, final int j) {
double tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}