gredwhite 44 / 44 / 11 Регистрация: 21.01.2013 Сообщений: 668 |
||||
1 |
||||
07.03.2014, 00:50. Показов 1575. Ответов 9 Метки нет (Все метки)
вроде по сути во 2 и 3 строчке одно и тоже делается, но 2 строчка не компилится. почему?
0 |
harlins 2 / 2 / 3 Регистрация: 22.10.2013 Сообщений: 41 |
||||||||
07.03.2014, 00:53 |
2 |
|||||||
Так попробуй
Добавлено через 59 секунд
0 |
Insane__ 43 / 43 / 15 Регистрация: 10.09.2013 Сообщений: 293 |
||||
07.03.2014, 02:13 |
3 |
|||
почему? Возможно потому что Вы пытаетесь добавить этот массив на стадии выполнения программы, а в 3 строке создается массив на этапе компиляции. Как вариант можно добавить так:
0 |
4088 / 3822 / 745 Регистрация: 18.05.2010 Сообщений: 9,331 Записей в блоге: 11 |
|
07.03.2014, 07:01 |
4 |
упс
0 |
Заблокирован |
|
07.03.2014, 11:06 |
5 |
Может конечно это и не так, но мне кажется диким вот так создавать массив d.add({«A»}); Мне кажется тут просто синтаксическая ошибка.
0 |
gredwhite 44 / 44 / 11 Регистрация: 21.01.2013 Сообщений: 668 |
||||
07.03.2014, 11:56 [ТС] |
6 |
|||
не, ребят, вы что-то нагородили, кажется.
меня лично такое объяснение устраивает
0 |
Заблокирован |
||||
07.03.2014, 12:10 |
7 |
|||
не, ребят, вы что-то нагородили, лолшто? Добавлено через 9 минут
намекаю
0 |
44 / 44 / 11 Регистрация: 21.01.2013 Сообщений: 668 |
|
07.03.2014, 12:33 [ТС] |
8 |
не знаю про что вы, но я про то, что присвоение и инициализация при создании это разные вещи. При передачи в метод работает присвоение.
0 |
Заблокирован |
|
07.03.2014, 12:38 |
9 |
вроде по сути во 2 и 3 строчке одно и тоже делается, но 2 строчка не компилится.
не, ребят, вы что-то нагородили, кажется.
меня лично такое объяснение устраивае я об этом
0 |
44 / 44 / 11 Регистрация: 21.01.2013 Сообщений: 668 |
|
07.03.2014, 12:41 [ТС] |
10 |
как бы изначально ясно было почему ошибка, мне то не ясно было, поэтому и спрашивал. Ответы не приблизили меня к пониманию, но сам разобдрался.
0 |
IT_Exp Эксперт 87844 / 49110 / 22898 Регистрация: 17.06.2006 Сообщений: 92,604 |
07.03.2014, 12:41 |
Помогаю со студенческими работами здесь Код не компилируется Не компилируется код struct Element{ // структура, задающая элемент списка Не компилируется код Не компилируется код Не компилируется код Код не компилируется // File Output.cpp: определяет точку входа для… Искать еще темы с ответами Или воспользуйтесь поиском по форуму: 10 |
как объявить и инициализировать массив в Java?
19 ответов
вы можете использовать объявление массива или литерал массива (но только когда вы объявляете и влияете на переменную сразу, литералы массива не могут использоваться для повторного назначения массива).
для примитивных типов:
int[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};
для классов, например String
, Это-же:
String[] myStringArray = new String[3];
String[] myStringArray = {"a","b","c"};
String[] myStringArray = new String[]{"a","b","c"};
третий способ инициализации полезен, когда вы сначала объявляете массив, а затем инициализируете его. Актерский состав здесь.
String[] myStringArray;
myStringArray = new String[]{"a","b","c"};
существует два типа массива.
Одномерный Массив
синтаксис значений по умолчанию:
int[] num = new int[5];
или (менее предпочтительно)
int num[] = new int[5];
синтаксис с заданными значениями (инициализация переменной / поля):
int[] num = {1,2,3,4,5};
или (менее предпочтительно)
int num[] = {1, 2, 3, 4, 5};
Примечание: Для удобства int[] num предпочтительнее, потому что он ясно говорит, что вы говорите здесь о массиве. Иначе никакой разницы. Не все.
многомерный массив
декларация
int[][] num = new int[5][2];
или
int num[][] = new int[5][2];
или
int[] num[] = new int[5][2];
инициализации
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={ {1,2}, {1,2}, {1,2}, {1,2}, {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];
Итак, здесь мы явно определяем столбцы.
Иначе:
int[][] num={ {1}, {1,2}, {1,2,3,4,5}, {1,2}, {1,2,3} };
для Доступ:
for (int i=0; i<(num.length); i++ ) {
for (int j=0;j<num[i].length;j++)
System.out.println(num[i][j]);
}
кроме того:
for (int[] a : num) {
for (int i : a) {
System.out.println(i);
}
}
рваные массивы многомерные массивы.
Для объяснения см. подробности многомерного массива в официальные учебники java
226
автор: Isabella Engineer
Type[] variableName = new Type[capacity];
Type[] variableName = {comma-delimited values};
Type variableName[] = new Type[capacity];
Type variableName[] = {comma-delimited values};
также допустимо, но я предпочитаю скобки после типа, потому что легче увидеть, что тип переменной на самом деле является массивом.
существуют различные способы объявления массива в Java:
float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};
вы можете найти более подробную информацию в Sun учебник сайт и JavaDoc.
Я считаю, это полезно, если вы понимаете каждую часть:
Type[] name = new Type[5];
Type[]
— это тип на переменная called name («имя» называется идентификатор). Литерал «Type» является базовым типом, а скобки означают, что это тип массива этой базы. Типы массивов, в свою очередь, являются собственными типами, что позволяет создавать многомерные массивы типа Type[][]
(массив типа[]). Ключевое слово new
говорит выделить память для нового массива. Число между скобками говорит о том, насколько большим будет новый массив и сколько памяти нужно выделить. Например, если Java знает, что базовый тип Type
занимает 32 байта, и вы хотите массив размером 5, он должен внутренне выделить 32 * 5 = 160 байт.
вы также можете создавать массивы с уже имеющимися значениями, такими как
int[] name = {1, 2, 3, 4, 5};
, который не только создает пустое пространство, но и наполняет эти ценности. Java может сказать, что примитивы целых чисел и что их 5, поэтому размер массива можно определить неявно.
ниже представлены объявления массива, но массив не инициализируется:
int[] myIntArray = new int[3];
ниже показано объявление, а также инициализация массива:
int[] myIntArray = {1,2,3};
теперь следующее также показывает объявление, а также инициализацию массива:
int[] myIntArray = new int[]{1,2,3};
но этот третий показывает свойство анонимного создания массива-объекта, на которое указывает ссылочная переменная «myIntArray», поэтому, если мы напишем просто » new int [] {1,2,3}; » тогда вот как можно создать анонимный объект-массив.
если мы просто пишем:
int[] myIntArray;
это не объявление массива, но следующий оператор делает вышеуказанное объявление полным:
myIntArray=new int[3];
кроме того,
// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];
объявляет массив с именем arrayName
размера 10 (у вас есть элементы от 0 до 9 для использования).
кроме того, если вы хотите что-то более динамичное, есть интерфейс списка. Это не будет выполнять, как хорошо, но является более гибким:
List<String> listOfString = new ArrayList<String>();
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[] array = {1,2,3,4 ...};
вы также можете сделать многомерные массивы, как это:
int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};
возьмем примитивный тип int
например. Существует несколько способов объявить и int
время:
int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};
где во всех этих, Вы можете использовать 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 = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};
внутри метода, varargs
рассматривается как нормальный int[]
. Type...
может использоваться только в параметрах метода, поэтому int... i = new int[] {}
не будет компилироваться.
обратите внимание, что при прохождении int[]
к методу (или любому другому Type[]
), вы не можете использовать третий способ. В заявлении int[] i = *{a, b, c, d, etc}*
, компилятор предполагает, что {...}
означает 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 );
7
автор: Muhammad Suleman
объявление массива ссылок на объекты:
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({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };
Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };
в общем, вы можете создавать массивы, которые M
мерные
int [][]..[] array =
// ^ M times [] brackets
{{..{
// ^ M times { bracket
// this is array[0][0]..[0]
// ^ M times [0]
}}..}
// ^ 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<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();
присвоить массиву значения:
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
(условный цикл):
for (int i = 0; i < arrayName.size(); i++){
//manipulate array here
}
в 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 <= 100, 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
С помощью Вывод Типа Локальной Переменной:
var letters = new String[]{"A", "B", "C"};
объявить и инициализировать для 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();
последовательность Power-of-two:
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[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"})
.toArray(new String[0][]);
System.out.println(Arrays.deepToString(a6));
// Output: [[a, b, c], [d, e, f, g]]
3
автор: Kirill Podlivaev
другой способ объявить и инициализировать ArrayList:
private List<String> list = new ArrayList<String>(){{
add("e1");
add("e2");
}};
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 = {0, 1, 2};
@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
pos = {2, 1, 0};
}
}
What is going on here?
Ivar
5,98712 gold badges49 silver badges61 bronze badges
asked Jan 15, 2017 at 6:33
1
You should use
pos = new int[]{1,2,3};
You can only use the abbreviated syntax int[] pos = {0,1,2};
at variable initialization time.
private int[] values1 = new int[]{1,2,3,4};
private int[] values2 = {1,2,3,4}; // short form is allowed only at variable initialization
answered Jan 15, 2017 at 6:51
JayanthJayanth
5,8443 gold badges20 silver badges37 bronze badges
Your initialization statement is wrong: you must add square brackets to declare an array (and here you can omit the new
keyword because you’re declaring and initializing the variable at the same time):
int[] pos = { 0, 1, 2 };
In the onCreate
method, you can’t omit the new
keyword because the variable was already declared, so you have to write:
pos = new int[] { 2, 1, 0 };
You can read the Oracle documentation and the Java Language Specs for more details.
answered Jan 15, 2017 at 7:27
Robert HumeRobert Hume
1,1292 gold badges14 silver badges25 bronze badges
use the following syntax to declare/initialize and empty array, and then populated it with data:
String[] menuArray = {};
menuArray = new String[]{"new item","item 2"};
answered Feb 7, 2018 at 10:22
saigopi.mesaigopi.me
13.7k2 gold badges81 silver badges54 bronze badges
This is a compile-time error Illegal Initializer for int.
You could solve this problem by adding square braces after your variable’s data type like this:
int[] pos = {0, 1, 2};
answered Mar 3, 2019 at 18:11
thejufothejufo
1231 silver badge7 bronze badges
Array initializer is not allowed here
The use of array is divided into declaration and initialization, which can be carried out simultaneously or separately
Int [] array; declaration
Array = New Int {element1, Element2, element3..}; initialization mode 1
Array = New Int [length]; initialization mode 2
There are two initialization methods for arrays
1、 Static initialization: the initial value of each array element is explicitly specified by the programmer during initialization;
arrayName = new type[]{element1,element2,element3…}
2、 Dynamic initialization: when initializing, the programmer specifies the length of the array, and the system initializes the default value of each array element.
arrayName = new type[length];
Note: do not use static initialization and dynamic initialization at the same time. In other words, do not specify the length of the array and divide each element of the array
The initial value is set.
Looking at the code today, we can see a simplified array initialization method, which belongs to the simplified version of static initialization, but there is something wrong with it
Int [] array = {1,2,3}; object [] obj = {}; this is OK
So I tried to write like this
Class member variables declare an array int [] elementdata, but it is not initialized;
Initialize it in the constructor, trying to write like this
Elementdata = {1,3,5}, so the above compilation error prompt appears
It seems that this simplified way of writing is not applicable here,
The use of arrays must be initialized
Suppose that elementdata = {1,3,5} does not generate new objects through new. Maybe the compiler thinks that it has been declared but not initialized
Therefore, it is recommended that the initialization is completed when the array is declared
Int [] elementdata = {1,3,5}; this is OK, declaration and assignment are done at the same time
Your initialization statement is wrong: you must add square brackets to declare an array (and here you can omit the new
keyword because you’re declaring and initializing the variable at the same time):
int[] pos = { 0, 1, 2 };
In the onCreate
method, you can’t omit the new
keyword because the variable was already declared, so you have to write:
pos = new int[] { 2, 1, 0 };
You can read the Oracle documentation and the Java Language Specs for more details.
You should use
pos = new int[]{1,2,3};
You can only use the abbreviated syntax int[] pos = {0,1,2};
at variable initialization time.
private int[] values1 = new int[]{1,2,3,4};
private int[] values2 = {1,2,3,4}; // short form is allowed only at variable initialization
use the following syntax to declare/initialize and empty array, and then populated it with data:
String[] menuArray = {};
menuArray = new String[]{"new item","item 2"};