Array reference expected java

Array initializer expected java ошибка

вы можете использовать объявление массива или литерал массива (но только когда вы объявляете и влияете на переменную сразу, литералы массива не могут использоваться для повторного назначения массива).

int[] myIntArray = new int[3]; int[] myIntArray = ; int[] myIntArray = new int[]; 

для классов, например String , Это-же:

String[] myStringArray = new String[3]; String[] myStringArray = ; String[] myStringArray = new String[]; 

третий способ инициализации полезен, когда вы сначала объявляете массив, а затем инициализируете его. Актерский состав здесь.

String[] myStringArray; myStringArray = new String[]; 

существует два типа массива.

Одномерный Массив

синтаксис значений по умолчанию:

или (менее предпочтительно)

синтаксис с заданными значениями (инициализация переменной / поля):

или (менее предпочтительно)

Примечание: Для удобства int[] num предпочтительнее, потому что он ясно говорит, что вы говорите здесь о массиве. Иначе никакой разницы. Не все.

многомерный массив

декларация

инициализации

 num[0][0]=1; num[0][1]=2; num[1][0]=1; num[1][1]=2; num[2][0]=1; num[2][1]=2; num[3][0]=1; num[3][1]=2; num[4][0]=1; num[4][1]=2; 

рваный массив (или непрямой массив)

 int[][] num = new int[5][]; num[0] = new int[1]; num[1] = new int[5]; num[2] = new int[2]; num[3] = new int[3]; 

Итак, здесь мы явно определяем столбцы.
Иначе:

для Доступ:

рваные массивы многомерные массивы.
Для объяснения см. подробности многомерного массива в официальные учебники java

Type[] variableName = new Type[capacity]; Type[] variableName = ; Type variableName[] = new Type[capacity]; Type variableName[] = ; 

также допустимо, но я предпочитаю скобки после типа, потому что легче увидеть, что тип переменной на самом деле является массивом.

существуют различные способы объявления массива в Java:

float floatArray[]; // Initialize later int[] integerArray = new int[10]; String[] array = new String[] ; 

вы можете найти более подробную информацию в Sun учебник сайт и JavaDoc.

Я считаю, это полезно, если вы понимаете каждую часть:

Type[] — это тип на переменная called name («имя» называется идентификатор). Литерал «Type» является базовым типом, а скобки означают, что это тип массива этой базы. Типы массивов, в свою очередь, являются собственными типами, что позволяет создавать многомерные массивы типа Type[][] (массив типа[]). Ключевое слово new говорит выделить память для нового массива. Число между скобками говорит о том, насколько большим будет новый массив и сколько памяти нужно выделить. Например, если Java знает, что базовый тип Type занимает 32 байта, и вы хотите массив размером 5, он должен внутренне выделить 32 * 5 = 160 байт.

вы также можете создавать массивы с уже имеющимися значениями, такими как

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

ниже представлены объявления массива, но массив не инициализируется:

ниже показано объявление, а также инициализация массива:

теперь следующее также показывает объявление, а также инициализацию массива:

но этот третий показывает свойство анонимного создания массива-объекта, на которое указывает ссылочная переменная «myIntArray», поэтому, если мы напишем просто » new int [] ; » тогда вот как можно создать анонимный объект-массив.

это не объявление массива, но следующий оператор делает вышеуказанное объявление полным:

// Either method works String arrayName[] = new String[10]; String[] arrayName = new String[10]; 

объявляет массив с именем arrayName размера 10 (у вас есть элементы от 0 до 9 для использования).

кроме того, если вы хотите что-то более динамичное, есть интерфейс списка. Это не будет выполнять, как хорошо, но является более гибким:

List listOfString = new ArrayList(); listOfString.add("foo"); listOfString.add("bar"); String value = listOfString.get(0); assertEquals( value, "foo" ); 

существует два основных способа создания массива:

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array 

и этот, для инициализированного массива:

вы также можете сделать многомерные массивы, как это:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions int[][] array2d = < , . >; 

возьмем примитивный тип int например. Существует несколько способов объявить и int время:

int[] i = new int[capacity]; int[] i = new int[] ; int[] i = ; 

где во всех этих, Вы можете использовать int i[] вместо int[] i .

С отражением, вы можете использовать (Type[]) Array.newInstance(Type.class, capacity);

обратите внимание, что в параметрах метода, . указано variable arguments . По сути, любое количество параметров прекрасно. Это проще объяснить с помощью кода:

public static void varargs(int fixed1, String fixed2, int. varargs) . varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = ; 

внутри метода, varargs рассматривается как нормальный int[] . Type. может использоваться только в параметрах метода, поэтому int. i = new int[] <> не будет компилироваться.

обратите внимание, что при прохождении int[] к методу (или любому другому Type[] ), вы не можете использовать третий способ. В заявлении int[] i = ** , компилятор предполагает, что <. >означает int[] . Но это потому, что вы объявляете переменную. При передаче массива методу объявление должно быть либо new Type[capacity] или new Type[] <. >.

Многомерная Массивы

многомерные массивы гораздо сложнее иметь дело. По сути, 2D-массив — это массив массивов. int[][] означает массив int[] s. Ключ в том, что если int[][] объявлен int[x][y] , максимальный индекс i[x-1][y-1] . По сути, прямоугольный int[3][5] — это:

[0, 0] [1, 0] [2, 0] [0, 1] [1, 1] [2, 1] [0, 2] [1, 2] [2, 2] [0, 3] [1, 3] [2, 3] [0, 4] [1, 4] [2, 4] 

Если вы хотите создавать массивы с помощью отражений, вы можете сделать следующее:

 int size = 3; int[] intArray = (int[]) Array.newInstance(int.class, size ); 

объявление массива ссылок на объекты:

class Animal <> class Horse extends Animal < public static void main(String[] args) < /* * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed) */ Animal[] a1 = new Animal[10]; a1[0] = new Animal(); a1[1] = new Horse(); /* * Array of Animal can hold Animal and Horse and all subtype of Horse */ Animal[] a2 = new Horse[10]; a2[0] = new Animal(); a2[1] = new Horse(); /* * Array of Horse can hold only Horse and its subtype (if any) and not allowed supertype of Horse nor other subtype of Animal. */ Horse[] h1 = new Horse[10]; h1[0] = new Animal(); // Not allowed h1[1] = new Horse(); /* * This can not be declared. */ Horse[] h2 = new Animal[10]; // Not allowed >> 

массив представляет собой последовательный список элементов

int item = value; int [] one_dimensional_array = < value, value, value, . value >; int [][] two_dimensional_array = < < value, value, value, .. value >, < value, value, value, .. value >, .. .. .. .. < value, value, value, .. value >>; 

если это объект, то это то же самое понятие

Object item = new Object(); Object [] one_dimensional_array = < new Object(), new Object(), .. new Object() >; Object [][] two_dimensional_array = < < new Object(), new Object(), .. new Object() >, < new Object(), new Object(), .. new Object() >, .. .. .. < new Object(), new Object(), .. new Object() >>; 

в случае объектов вам нужно либо назначить его null инициализировать их с помощью new Type(..) классы типа String и Integer особые случаи, которые будут обрабатываться следующим образом

String [] a = < "hello", "world" >; // is equivalent to String [] a = < new String(), new String() >; Integer [] b = < 1234, 5678 >; // is equivalent to Integer [] b = < new Integer(1234), new Integer(5678) >; 

в общем, вы можете создавать массивы, которые M мерные

int [][]..[] array = // ^ M times [] brackets >..> // ^ M times > bracket ; 

стоит отметить, что создание M размерный массив дорог с точки зрения пространства. С момента создания M мерный массив с N на всех измерениях общий размер массива больше, чем N^M , так как каждый массив имеет ссылку, а в M-измерении имеется (M-1)-мерный массив ссылок. Общий размер следующий

Space = N^M + N^(M-1) + N^(M-2) + .. + N^0 // ^ ^ array reference // ^ actual data 

для создания массивов объектов, вы можете использовать java.util.ArrayList . чтобы определить массив:

public ArrayList arrayName; arrayName = new ArrayList(); 

присвоить массиву значения:

arrayName.add(new ClassName(class parameters go here); 

ClassName variableName = arrayName.get(index); 

variableName является ссылкой на массив, означающий, что манипулирование variableName будет манипулировать arrayName

//repeats for every value in the array for (ClassName variableName : arrayName) < >//Note that using this for loop prevents you from editing arrayName 

для цикла, который позволяет редактировать arrayName (условный цикл):

в Java 8 вы можете использовать, как это.

String[] strs = IntStream.range(0, 15) // 15 is the size .mapToObj(i -> Integer.toString(i)) .toArray(String[]::new); 

используя разные IntStream.iterate и IntStream.takeWhile методы:

int[] a = IntStream.iterate(10, x -> x x + 10).toArray(); Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray(); Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

В Java 10

С помощью Вывод Типа Локальной Переменной:

объявить и инициализировать для Java 8 и выше. Создайте простой целочисленный массив:

int [] a1 = IntStream.range(1, 20).toArray(); System.out.println(Arrays.toString(a1)); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 

создайте случайный массив для целых чисел между [-50, 50] и для двойников [0, 1E17]:

int [] a2 = new Random().ints(15, -50, 50).toArray(); double [] a3 = new Random().doubles(5, 0, 1e17).toArray(); 

double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray(); System.out.println(Arrays.toString(a4)); // Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0] 

для String[] необходимо указать конструктор:

String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new); System.out.println(Arrays.toString(a5)); 

String [][] a6 = List.of(new String[] , new String[]) .toArray(new String[0][]); System.out.println(Arrays.deepToString(a6)); // Output: [[a, b, c], [d, e, f, g]] 

другой способ объявить и инициализировать ArrayList:

private List list = new ArrayList()>; 

int[] SingleDimensionalArray = new int[2] int[][] MultiDimensionalArray = new int[3][4] 

I am working on Android project and I am getting an error which I cannot understand:

Array initializer is not allowed here

I tried to simplify my code and it comes down to this

public class MainActivity extends Activity< int pos = ; @Override protected void onCreate(Bundle savedInstanceState)< super.onCreate(savedInstanceState); setContentView(R.layout.main); pos = ; > > 

6,025 12 gold badges 49 silver badges 61 bronze badges

Источник

Java – array reference expected exception in java

Want to improve this question? Update the question so it's on-topic for Stack Overflow.

Im just trying to create a new 2d array using existing 2d array call properties and new two values which is sourceURL and fetchURL .

public static String[][] setProperties(String[][] properties, String sourceURL, String fetchURL) < String[][] propertyArray = new String[properties.length][]; for (int i = 0; i else < propertyArray[properties.length][0] = sourceURL; propertyArray[properties.length][1] = fetchURL; return propertyArray; >> return new String[0][]; > 

while I'm doing this I'm getting an exception saying "array reference expected" in the propertyArray[i][0] = properties[i][0]; line. Can some one help me to create this function?

Best Solution

you haven't set the second dimension size of the array. probably it will throw NullPointerException

String[][] propertyArray = new String[properties.length][2]; 

Also you you missed a logic

String[][] propertyArray = new String[properties.length+1][2];

Related Solutions

Java – Is Java “pass-by-reference” or “pass-by-value”

Java is always pass-by-value. Unfortunately, when we deal with objects we are really dealing with object-handles called references which are passed-by-value as well. This terminology and semantics easily confuse many beginners.

public static void main(String[] args) < Dog aDog = new Dog("Max"); Dog oldDog = aDog; // we pass the object to foo foo(aDog); // aDog variable is still pointing to the "Max" dog when foo(. ) returns aDog.getName().equals("Max"); // true aDog.getName().equals("Fifi"); // false aDog == oldDog; // true >public static void foo(Dog d) < d.getName().equals("Max"); // true // change d inside of foo() to point to a new Dog instance "Fifi" d = new Dog("Fifi"); d.getName().equals("Fifi"); // true >

In the example above aDog.getName() will still return "Max" . The value aDog within main is not changed in the function foo with the Dog "Fifi" as the object reference is passed by value. If it were passed by reference, then the aDog.getName() in main would return "Fifi" after the call to foo .

public static void main(String[] args) < Dog aDog = new Dog("Max"); Dog oldDog = aDog; foo(aDog); // when foo(. ) returns, the name of the dog has been changed to "Fifi" aDog.getName().equals("Fifi"); // true // but it is still the same dog: aDog == oldDog; // true >public static void foo(Dog d) < d.getName().equals("Max"); // true // this changes the name of d to be "Fifi" d.setName("Fifi"); >

In the above example, Fifi is the dog's name after call to foo(aDog) because the object's name was set inside of foo(. ) . Any operations that foo performs on d are such that, for all practical purposes, they are performed on aDog , but it is not possible to change the value of the variable aDog itself.

For more information on pass by reference and pass by value, consult the following SO answer: https://stackoverflow.com/a/430958/6005228. This explains more thoroughly the semantics and history behind the two and also explains why Java and many other modern languages appear to do both in certain cases.

Java – Create ArrayList from array

new ArrayList<>(Arrays.asList(array)); 

Источник