Как объявить и инициализировать массив в Java?

avatar
bestattendance
29 июля 2009 в 14:22
4951032
29
2256

Как объявить и инициализировать массив в Java?

Источник
janniks
3 февраля 2020 в 11:50
20

Прежде чем опубликовать новый ответ, подумайте, что на этот вопрос уже есть более 25 ответов. Пожалуйста, убедитесь, что ваш ответ содержит информацию, которой нет среди существующих ответов.

Babak
22 декабря 2020 в 09:03
0

docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

Rahul Gupta
14 мая 2021 в 13:56
0

проверьте это tutorialcup.com/java/how-to-return-an-array-in-java.htm

Rahul Gupta
16 мая 2021 в 13:35
0

tutorialcup.com/java/arrays-in-java.htm

Ответы (29)

avatar
glmxndr
3 марта 2021 в 13:33
2927

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

Для примитивных типов:

int[] myIntArray = new int[3];
int[] myIntArray = {1, 2, 3};
int[] myIntArray = new int[]{1, 2, 3};

// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html

int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

Для классов, например, 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"};
Quazi Irfan
10 апреля 2015 в 03:23
37

Для чего нужен и второй, и третий способ сделать это?

Skylar Ittner
16 апреля 2015 в 17:44
140

@iamcreasy Похоже, второй способ не работает с операторами возврата. return {1,2,3} выдает ошибку, а return new int[]{1,2,3} работает нормально (конечно, при условии, что ваша функция возвращает целочисленный массив).

Quazi Irfan
18 апреля 2015 в 04:41
1

@SkylarMT Но мы все еще можем использовать первый способ использования с оператором return.

Skylar Ittner
20 апреля 2015 в 06:09
7

@iamcreasy Недавно я написал функцию, возвращающую массив целых чисел. Если внутри функции произошла ошибка, я хотел, чтобы она вернула определенное значение, но функция должна была вернуть массив. Какой способ работает для однострочного оператора возврата? Только третий.

peterflynn
3 июня 2015 в 19:18
0

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

Jezzamon
26 июля 2015 в 11:43
0

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

Khaled.K
21 октября 2015 в 12:22
1

Этот ответ кажется мне неполным, в нем отсутствует часть в массиве классов \ объектов, использующая String или примитивный тип данных-автобоксинг , чтобы продемонстрировать, что классы вводят в заблуждение.

M. Usman Khan
11 января 2016 в 13:53
0

что, если у меня есть параметр в конструкторе? например У меня есть конструктор public MyClass (int something) {}; и я хочу инициализировать массив MyClass [] objs = new MyClass [3] (88);

apadana
20 мая 2016 в 20:49
1

Вторая форма также не может использоваться для перехода в функцию. Выдает ошибку. 3-й класс в порядке. Но я не уверен, почему вторую форму нельзя использовать для возврата или перехода к функции? Я хотел бы понять, что происходит за кулисами.

teukkam
18 октября 2016 в 09:55
7

@apadana Во втором случае вы создаете анонимный объект, который определен только во включающей области (функция или что-то еще). После возврата вызывающему абоненту он больше не действует. Используя ключевое слово new, вы выделяете новый объект из кучи, и он действителен за пределами определяемой области.

MrAP
6 апреля 2017 в 21:47
1

Что вы имеете в виду под: «но только когда вы объявляете переменную и сразу же воздействуете на нее, литералы массива не могут использоваться для переназначения массива»?

djangofan
29 мая 2017 в 17:54
0

Почему это работает? открытый класс Test {public static void main (String args []) {final double [] doubles = {2.3, 2.4}; финальный длинный [] длинный = {2,4L, 6,8}; }}

www-0av-Com
4 апреля 2018 в 12:06
1

Новичкам объясните, почему вы даете тройные ответы. Как новичок, подумал, что мне нужны все 3 строчки! Не впечатлен тем, что первый ответ получает все голоса, даже если он вводит в заблуждение. @codecubed имеет гораздо лучший простой ответ.

Androidcoder
3 декабря 2020 в 18:18
0

Инициализируются ли объявления массивов автоматически при вызове методов? Переменные, не являющиеся массивами, по-видимому, не инициализируются при объявлении в методах, поскольку вы получаете сообщение об ошибке «не инициализировано».

Clement Cherlin
3 марта 2021 в 13:20
0

@teukkam В Java не существует такой вещи, как «анонимный объект, который определяется только во включающей области». Все объекты размещены в куче. Причина, по которой вы не можете вернуть {1, 2, 3}, носит чисто синтаксический характер и не имеет ничего общего с распределением объектов. В качестве доказательства полностью справедливо следующее: public static int[] returnsALiteralIntArray() { int[] ints = {1, 2, 3}; return ints; }

avatar
splash
14 февраля 2022 в 14:30
0

Иногда я использую это для инициализации строковых массивов:

private static final String[] PROPS = "lastStart,storetime,tstore".split(",");

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

avatar
shellhub
5 октября 2020 в 01:55
1
package com.examplehub.basics;

import java.util.Arrays;

public class Array {

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        System.out.println("numbers[0] = " + numbers[0]);
        System.out.println("numbers[1] = " + numbers[1]);
        System.out.println("numbers[2] = " + numbers[2]);
        System.out.println("numbers[3] = " + numbers[3]);
        System.out.println("numbers[4] = " + numbers[4]);

        /*
         * Array index is out of bounds
         */
        //System.out.println(numbers[-1]);
        //System.out.println(numbers[5]);


        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        for (int i = 0; i < 5; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        /*
         * Length of numbers = 5
         */
        System.out.println("length of numbers = " + numbers.length);

        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        /*
         * numbers[4] = 5
         * numbers[3] = 4
         * numbers[2] = 3
         * numbers[1] = 2
         * numbers[0] = 1
         */
        for (int i = numbers.length - 1; i >= 0; i--) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        /*
         * 12345
         */
        for (int number : numbers) {
            System.out.print(number);
        }
        System.out.println();

        /*
         * [1, 2, 3, 4, 5]
         */
        System.out.println(Arrays.toString(numbers));



        String[] company = {"Google", "Facebook", "Amazon", "Microsoft"};

        /*
         * company[0] = Google
         * company[1] = Facebook
         * company[2] = Amazon
         * company[3] = Microsoft
         */
        for (int i = 0; i < company.length; i++) {
            System.out.println("company[" + i + "] = " + company[i]);
        }

        /*
         * Google
         * Facebook
         * Amazon
         * Microsoft
         */
        for (String c : company) {
            System.out.println(c);
        }

        /*
         * [Google, Facebook, Amazon, Microsoft]
         */
        System.out.println(Arrays.toString(company));

        int[][] twoDimensionalNumbers = {
                {1, 2, 3},
                {4, 5, 6, 7},
                {8, 9},
                {10, 11, 12, 13, 14, 15}
        };

        /*
         * total rows  = 4
         */
        System.out.println("total rows  = " + twoDimensionalNumbers.length);

        /*
         * row 0 length = 3
         * row 1 length = 4
         * row 2 length = 2
         * row 3 length = 6
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.println("row " + i + " length = " + twoDimensionalNumbers[i].length);
        }

        /*
         * row 0 = 1 2 3
         * row 1 = 4 5 6 7
         * row 2 = 8 9
         * row 3 = 10 11 12 13 14 15
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.print("row " + i + " = ");
            for (int j = 0; j < twoDimensionalNumbers[i].length; j++) {
                System.out.print(twoDimensionalNumbers[i][j] + " ");
            }
            System.out.println();
        }

        /*
         * row 0 = [1, 2, 3]
         * row 1 = [4, 5, 6, 7]
         * row 2 = [8, 9]
         * row 3 = [10, 11, 12, 13, 14, 15]
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.println("row " + i + " = " + Arrays.toString(twoDimensionalNumbers[i]));
        }

        /*
         * 1 2 3
         * 4 5 6 7
         * 8 9
         * 10 11 12 13 14 15
         */
        for (int[] ints : twoDimensionalNumbers) {
            for (int num : ints) {
                System.out.print(num + " ");
            }
            System.out.println();
        }

        /*
         * [1, 2, 3]
         * [4, 5, 6, 7]
         * [8, 9]
         * [10, 11, 12, 13, 14, 15]
         */
        for (int[] ints : twoDimensionalNumbers) {
            System.out.println(Arrays.toString(ints));
        }


        int length = 5;
        int[] array = new int[length];
        for (int i = 0; i < 5; i++) {
            array[i] = i + 1;
        }

        /*
         * [1, 2, 3, 4, 5]
         */
        System.out.println(Arrays.toString(array));

    }
}

Источник из examplehub / java

Peter Mortensen
2 января 2021 в 01:45
0

Объяснение было бы в порядке.

avatar
Dupinder Singh
31 мая 2020 в 17:05
1

Еще один полный пример с классом фильмов:

public class A {

    public static void main(String[] args) {

        class Movie {

            String movieName;
            String genre;
            String movieType;
            String year;
            String ageRating;
            String rating;

            public Movie(String [] str)
            {
                this.movieName = str[0];
                this.genre = str[1];
                this.movieType = str[2];
                this.year = str[3];
                this.ageRating = str[4];
                this.rating = str[5];
            }
        }

        String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};

        Movie mv = new Movie(movieDetailArr);

        System.out.println("Movie Name: "+ mv.movieName);
        System.out.println("Movie genre: "+ mv.genre);
        System.out.println("Movie type: "+ mv.movieType);
        System.out.println("Movie year: "+ mv.year);
        System.out.println("Movie age : "+ mv.ageRating);
        System.out.println("Movie  rating: "+ mv.rating);
    }
}
avatar
Virangaa
21 февраля 2020 в 18:13
2
int[] x = new int[enter the size of array here];

Пример:

int[] x = new int[10];
              

Или

int[] x = {enter the elements of array here];

Пример:

int[] x = {10, 65, 40, 5, 48, 31};
avatar
Zia
21 февраля 2020 в 05:15
4

Массив имеет два основных типа.

Статический массив: Массив фиксированного размера (его размер должен быть объявлен в начале и не может быть изменен позже)

Динамический массив: Никаких ограничений размера для этого не рассматривается. (Чистых динамических массивов в Java не существует. Вместо этого рекомендуется использовать List.)

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

int[] intArray = new int[10];
String[] intArray = new int[10];
float[] intArray = new int[10];

// Here you have 10 index starting from 0 to 9

Чтобы использовать динамические функции, вы должны использовать List ... Список представляет собой чистый динамический массив , и нет необходимости объявлять размер в начале. Ниже приведен правильный способ объявления списка в Java -

ArrayList<String> myArray = new ArrayList<String>();
myArray.add("Value 1: something");
myArray.add("Value 2: something more");
Zia
19 марта 2020 в 06:49
1

Спасибо @Matheus за улучшение моих ответов. Я прошу вас проголосовать за это, чтобы охватить больше пользователей.

avatar
Zgpeace
21 января 2020 в 01:12
1

Массив может содержать типы данных примитивов, а также объекты класса в зависимости от определения массива. В случае типов данных примитивов фактические значения хранятся в смежных ячейках памяти. В случае объектов класса фактические объекты хранятся в сегменте кучи.


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

Общая форма объявления одномерного массива:

type var-name[];
OR
type[] var-name;

Создание экземпляра массива в Java

var-name = new type [size];

Например,

int intArray[];  // Declaring an array
intArray = new int[20];  // Allocating memory to the array

// The below line is equal to line1 + line2
int[] intArray = new int[20]; // Combining both statements in one
int[] intArray = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Accessing the elements of the specified array
for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + ": "+ intArray[i]);

Ссылка: Массивы в Java

avatar
Syed Salman Hassan
4 августа 2019 в 12:06
0

Объявить и инициализировать массив очень просто. Например, вы хотите сохранить в массиве пять целочисленных элементов: 1, 2, 3, 4 и 5. Сделать это можно следующим образом:

а)

int[] a = new int[5];

или

б)

int[] a = {1, 2, 3, 4, 5};

, поэтому основной шаблон для инициализации и объявления методом a):

datatype[] arrayname = new datatype[requiredarraysize];

datatype должен быть в нижнем регистре.

Итак, основной шаблон для инициализации и объявления методом a:

Если это строковый массив:

String[] a = {"as", "asd", "ssd"};

Если это массив символов:

char[] a = {'a', 's', 'w'};

Для типа float double формат массива будет таким же, как и integer.

Например:

double[] a = {1.2, 1.3, 12.3};

но когда вы объявляете и инициализируете массив «методом a», вам придется вводить значения вручную или с помощью цикла или чего-то еще.

Но если вы сделаете это «методом b», вам не придется вводить значения вручную.

avatar
kundus
10 июня 2019 в 00:57
1

Объявить массив: int[] arr;

Инициализировать массив: int[] arr = new int[10]; 10 представляет количество элементов, разрешенных в массиве

Объявить многомерный массив: int[][] arr;

Инициализировать многомерный массив: int[][] arr = new int[10][17]; 10 строк и 17 столбцов и 170 элементов, потому что 10 умножить на 17 равно 170.

Инициализация массива означает указание его размера.

avatar
Arundev
28 марта 2019 в 10:05
4

Здесь много ответов. Я добавляю несколько хитрых способов создания массивов (с точки зрения экзамена хорошо знать это)

  1. Объявить и определить массив

    int intArray[] = new int[3];
    

    Это создаст массив длиной 3. Поскольку он содержит примитивный тип int, все значения по умолчанию равны 0. Например,

    intArray[2]; // Will return 0
    
  2. Использование квадратных скобок [] перед именем переменной

    int[] intArray = new int[3];
    intArray[0] = 1;  // Array content is now {1, 0, 0}
    
  3. Инициализировать и передать данные в массив

    int[] intArray = new int[]{1, 2, 3};
    

    На этот раз размер в скобках коробки указывать не приходится. Даже простой вариант:

    int[] intArray = {1, 2, 3, 4};
    
  4. Массив длины 0

    int[] intArray = new int[0];
    int length = intArray.length; // Will return length 0
    

    Аналогично для многомерных массивов

    int intArray[][] = new int[2][3];
    // This will create an array of length 2 and
    //each element contains another array of length 3.
    // { {0,0,0},{0,0,0} }
    int lenght1 = intArray.length; // Will return 2
    int length2 = intArray[0].length; // Will return 3
    

Использование квадратных скобок перед переменной:

    int[][] intArray = new int[2][3];

Совершенно нормально, если вы поставите одну скобу коробки в конце:

    int[] intArray [] = new int[2][4];
    int[] intArray[][] = new int[2][3][4]

Некоторые примеры

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
    // All the 3 arrays assignments are valid
    // Array looks like {{1,2,3},{4,5,6}}

Необязательно, чтобы все внутренние элементы имели одинаковый размер.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.

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

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

Еще одна важная особенность - ковариант

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   // You can store a subclass object in an array that is declared
   // to be of the type of its superclass.
   // Here 'Number' is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // This is also valid

ВАЖНО: для ссылочных типов значение по умолчанию, хранящееся в массиве, равно null.

avatar
Sylhare
14 ноября 2018 в 19:59
5

Если под «массивом» вы имели в виду использование java.util.Arrays, вы можете сделать это так:

List<String> number = Arrays.asList("1", "2", "3");

Out: ["1", "2", "3"]

Этот довольно простой и понятный.

Sylhare
13 сентября 2019 в 12:57
0

Я не видел этого в других ответах, поэтому подумал, что могу добавить.

Tirno
8 января 2020 в 16:25
3

Список - это не массив

Sylhare
8 января 2020 в 20:22
0

Иногда люди имеют в виду массивы, когда им нужен список.

avatar
Konstantin Spirin
31 октября 2018 в 16:38
3

При выводе типа локальной переменной вам нужно указать тип только один раз:

var values = new int[] { 1, 2, 3 };

Или

int[] values = { 1, 2, 3 }
Cameron Hudson
18 октября 2019 в 22:39
0

В Java нет var.

Konstantin Spirin
23 октября 2019 в 15:17
6

@CameronHudson Java 10 имеет var openjdk.java.net/jeps/286

avatar
Chamly Idunil
8 марта 2018 в 18:21
10

В Java 8 вы можете использовать что-то вроде этого.

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);
avatar
Oleksandr Pyrohov
21 февраля 2018 в 12:45
11

В Java 9

Использование различных методов 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"};
avatar
Kirill Podlivaev
25 августа 2017 в 13:27
7

Объявить и инициализировать для 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] и для чисел типа double [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[]{"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]]
Peter Mortensen
21 февраля 2018 в 22:38
0

Действительно ли включены -50 и / или +50? То есть внутреннее отверстие открыто с одного или обоих концов?

Kirill Podlivaev
21 марта 2018 в 09:56
1

-50 включено и +50 исключено. Эта информация из java api «с указанием происхождения (включительно) и привязкой (исключая)». Я использую объявление интервала из вики. Так что думаю будет правильнее [-50, 50)

avatar
Clement.Xu
4 августа 2017 в 07:42
4

Другой способ объявления и инициализации ArrayList:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};
avatar
Samuel Newport
8 августа 2016 в 10:01
6

Для создания массивов объектов класса вы можете использовать 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
}
avatar
codecubed
28 января 2016 в 19:19
16

Есть два основных способа создать массив:

Этот для пустого массива:

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 ...} ...};
avatar
Khaled.K
21 октября 2015 в 13:39
8

Массив - это последовательный список элементов

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
avatar
2787184
16 октября 2015 в 10:18
9

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

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
    }
}
avatar
hyper-neutrino
23 мая 2015 в 19:56
11

Возьмем, к примеру, примитивный тип 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]
avatar
Muhammad Suleman
20 января 2015 в 11:54
10

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

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 
Dorian Gray
8 января 2020 в 19:38
0

Зачем вам создавать массив таким образом?

avatar
Isabella Engineer
9 июля 2013 в 21:59
298

Есть два типа массивов.

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

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

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

vipin8169
19 февраля 2017 в 00:25
0

Не приведет ли первый к нулевому / пустому массиву вместо массива со значениями по умолчанию?

AdamIJK
26 апреля 2017 в 11:26
0

Я согласен с этим, и мы можем добавить еще одну функцию, мы можем динамически изменять размер.

Tim M.
18 июля 2017 в 15:19
0

Я могу поспорить с вами по поводу того, что многомерный массив - это другой «тип» массива. Это просто термин, используемый для описания массива, который может содержать другие массивы. И внешние массивы, и внутренние массивы (и те, которые находятся между ними, если они существуют) являются обычными массивами.

avatar
Amit Bhandari
4 июня 2013 в 06:02
30

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

 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];
Jon Skeet
21 февраля 2015 в 23:08
3

Нет абсолютно никакой разницы между вторым и третьим подходами, кроме того, что второй подход работает только , когда вы также объявляете переменную. Непонятно, что вы имеете в виду под «показывает свойство создания анонимного объекта-массива», но на самом деле это эквивалентные фрагменты кода.

Jon Skeet
21 февраля 2015 в 23:12
6

Кроме того, первый фрагмент инициализирует массив - гарантировано, что значение 0 для каждого элемента массива.

eigenfield
15 января 2020 в 06:28
0

Неужели нет разницы между вторым и третьим подходами?

avatar
Dave
29 июля 2009 в 15:56
25

Также, если вам нужно что-то более динамичное, есть интерфейс List. Это не будет работать, но более гибкое:

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );
CyprUS
27 августа 2015 в 00:05
2

как называется «<>» в созданном вами списке?

Heimdall
29 ноября 2018 в 14:27
0

@CyprUS List - это общий класс, у него есть тип в качестве параметра, заключенный в <>. Это помогает, потому что вам нужно определить общий тип только один раз, а затем вы можете использовать его с несколькими разными типами. Для более подробного объяснения см. docs.oracle.com/javase/tutorial/java/generics/types.html

avatar
Chet
29 июля 2009 в 14:29
32

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

Type[] name = new Type[5];

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

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

int[] name = {1, 2, 3, 4, 5};

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

Cookie Monster
28 июня 2018 в 10:26
0

Значит, не обязательно включать int[] name = new int[5]?

avatar
Nate
29 июля 2009 в 14:29
130
Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

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

Chet
29 июля 2009 в 14:31
22

Я согласен с этим. Тип переменной не "TYPE", а на самом деле TYPE [], поэтому для меня имеет смысл написать его таким образом.

wener
5 марта 2014 в 12:43
3

Стиль Google тоже подсказывает это.

Jeroen Vannevel
19 марта 2015 в 01:46
11

Обратите внимание, что int[] a, b; не будет таким же, как int a[], b;, ошибку легко сделать, если вы воспользуетесь последней формой.

avatar
Anirudh
29 июля 2009 в 14:28
40

Существует несколько способов объявления массива в Java:

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

Дополнительную информацию можно найти на сайте Sun tutorial и на сайте JavaDoc.

avatar
Thomas Owens
29 июля 2009 в 14:25
27

Или

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

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

Anti Earth
3 октября 2012 в 04:20
7

Какой стандарт использовать? Я только что обнаружил первое и считаю его ужасно вводящим в заблуждение: |

Celeritas
9 августа 2013 в 04:50
2

Как бы то ни было, мой профессор сказал, что второй способ более типичен для Java и лучше передает то, что происходит; как массив, связанный с типом, к которому была приведена переменная.

Muhammad Suleman
5 мая 2015 в 11:17
2

Для примечания: язык, имеющий более одной семантики для объявления одной вещи, означающей плохой языковой дизайн.