Использование имен массивов в качестве переменных в циклах (Java)

Question

Я столкнулся с проблемой сегодня, когда пытался упростить свой код, используя имена массивов в качестве переменных в циклах, но компилятор постоянно говорит мне, что переменная (имя массива) - это символ, а не массив, так какЯ исправлю это, чтобы реализовать название моего вопроса?PS Я знаю, что есть еще много вещей, которые нужно исправить с помощью приведенного ниже кода, но я просто хочу привести пример следующего использования имен массивов в качестве переменных в циклах:

(сравните [i +1]) [i]> (сравните [i]) [i]

class ArraySort{

    public static void main(String[] args){

    int[] a = {4, 5, 3};
    int[] b = {7, 5};
    int[] c = {7, 8, 9};
    int[] d = {4, 9, 9};
    int[] e = {5, 1};
    int[] f = {3, 8, 2, 5};     

    System.out.println("Before sort: 453 75 789 499 51 3825");
    System.out.println("After sort:");

    char[] compare = {'a', 'b', 'c', 'd', 'e', 'f'};
    char temp;

    for(int i = 0; i < 3; i++ ){ // 3 --> max number amount to compare;  
        for(int j = 0; j < compare.length-1; j++){
            if((compare[i+1])[i] > (compare[i])[i]){ // problem is here
                temp = compare[i];
                compare[i] = compare[i+1];
                compare[i+1] = temp;    
            }
        }
    }

}

Answer 1

Вы не можете легко получить доступ к локальным переменным, используя строку их имени в Java. Вместо этого вы можете просто ссылаться на переменную напрямую.

int[][] compare = {a, b, c, d, e, f};

Answer 2

Ваш код не компилировался в моей среде Java8, мне пришлось кое-что изменить.

Во-первых, инициализация массива должна была быть:

int[] a = {4, 5, 3};
int[] b = {7, 5};
int[] c = {7, 8, 9};
int[] d = {4, 9, 9};
int[] e = {5, 1};
int[] f = {3, 8, 2, 5};

Затем инициализация сравненияи временный объект был изменен на массивы:

int[][] compare = {a, b, c, d, e, f};
int[] temp;

Полный метод теперь выглядит следующим образом:

class ArraySort
{

    public static void main(String[] args)
    {

        int[] a = {4, 5, 3};
        int[] b = {7, 5};
        int[] c = {7, 8, 9};
        int[] d = {4, 9, 9};
        int[] e = {5, 1};
        int[] f = {3, 8, 2, 5};

        System.out.println("Before sort: 453 75 789 499 51 3825");
        System.out.println("After sort:");

        int[][] compare = {a, b, c, d, e, f};
        int[] temp;

        for (int i = 0; i < 3; i++)
        { // 3 --> max number amount to compare;
            for (int j = 0; j < compare.length - 1; j++)
            {
                if ((compare[i + 1])[i] > (compare[i])[i])
                { // problem is here
                    temp = compare[i];
                    compare[i] = compare[i + 1];
                    compare[i + 1] = temp;
                }
            }
        }

    }
}

Компилируется без каких-либо ошибок или предупреждений.Не могу сказать, если результат будет таким, как ожидалось, так как ваш ожидаемый результат мне не ясен на 100%.Но упомянутые проблемы с компилятором исчезли.

Использование символов или строк, содержащих имена переменных, на самом деле не работает в Java.Есть способы, конечно, вы можете использовать отражения для достижения этой цели.Но я настоятельно рекомендую не использовать отражения в этом случае.

=== EDIT1 ===

Я использую int[][] compare = {a, b, c, d, e, f}; вместо char[] compare = {'a', 'b', 'c', 'd', 'e', 'f'};.Почему?

Вы определили несколько массивов в начале вашего кода a = {4, 5, 3} и т. Д. Итак, у вас есть массив с именем переменной a.Если вы используете 'a' (помните ') в массиве символов, это не что иное, как символ 'a', он не имеет никакой ссылки на фактический массив, который хранится в переменной a.Вы также можете перейти к 'x' или любому другому символу.

Использование имени переменной в символе, а не самой переменной требует создания «связи» между символом 'a' и переменной * 1032.* вручную.Вы можете использовать отражения для этого.Подробнее об отражениях позже.

Не используя массив символов, а массив int[][] для compare, вы создаете массив, который будет содержать int[] «вещей».И ваши начальные массивы a = {4, 5, 3} и т. Д. Точно соответствуют этому формату int[].Это позволяет вам просто использовать саму переменную в вашем массиве сравнения.Таким образом, в строке int[][] compare = {a, b, c, d, e, f}; символ a - это не символ, а действительная переменная, ссылающаяся на первоначально определенный массив.

Имея его немного сокращенный:

int[] a = {4, 5, 3};
int[] b = {7, 5};
int[][] compare = {a, b};

так же, как

int[][] compare = {{4, 5, 3}, {7, 5}};

Если вы хотите пойти с отражениями ... вы должны пойти и прочитать об этом.Это сложная тема.Очень очень очень просто, просто для того, чтобы у вас хватило ума: с помощью отражений вы можете получить доступ (и манипулировать) к исходному коду во время выполнения.

Представьте себе это так

int[] a = {1, 2, 3};
char access = 'a';

int[] reflectionOfA = (int[])myClass.getMember(access);

! Нереальный код Java! Метод myClass.getMember(String) получает строковое значение в виде простого текста.Затем он будет сканировать myClass и искать члена с именем со значением access, которое равно 'a'.Он найдет массив int [] a и вернет его.Так как метод getMember не может знать, какой тип искомого члена (это int [], String, что-нибудь еще?), Вам необходимо предоставить эту информацию.В данном случае это кастинг.Но я думаю, что реальные отражения Java принимают другой параметр, который определяет тип возвращаемого значения.

Если вы ничего не знаете об отражениях, не используйте их пока!Читайте о них.У них большой недостаток, так как они не очень производительны (они сканируют объекты при каждом вызове, без кэширования, без оптимизации).