Як оголосити і ініціалізувати масив у Java?

Ви можете використовувати декларацію масиву або літерал масиву (але лише тоді, коли ви декларуєте та впливає на змінну відразу, літерали масиву не можна використовувати для повторного призначення масиву).

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

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"};

Існує два типи масивів.

Один розмірний масив

Синтаксис значень за замовчуванням:

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

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[]це тип з змінної називається ім'ям ( «ім'я» називається ідентифікатором ). Буквальний "Тип" - це базовий тип, а дужки означають, що це тип масиву цієї бази. Типи масивів, у свою чергу, є власними типами, що дозволяє робити багатовимірні масиви на зразок 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. Це не буде ефективно, але є більш гнучким:

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]

На 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"};

Якщо ви хочете створити масиви за допомогою відображень, то ви можете зробити так:

 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({'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 8 можна використовувати так.

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

Для створення масивів об’єктів класу ви можете використовувати 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 та новіших версій. Створіть простий цілий масив:

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[]{"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]]

Ще один спосіб оголошення та ініціалізації ArrayList:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

Тут є багато відповідей. Я додаю кілька складних способів створення масивів (з точки зору іспиту добре це знати)

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

ВАЖЛИВО: Для посилаються типів значення за замовчуванням, збережене в масиві, є нульовим.

Ви також можете це зробити за допомогою java.util.Arrays:

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

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

Цей досить простий і простий.

З локальним висновком типу змінної вам потрібно вказати тип лише один раз:

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

Або

int[] values = { 1, 2, 3 }

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

Статичний масив: масив з фіксованим розміром (його розмір слід оголосити на початку та не можна змінити пізніше)

Динамічний масив: для цього не вважається обмеження розміру. (Чистих динамічних масивів у Java не існує. Натомість, список найбільш рекомендується)

Щоб оголосити статичний масив Integer, string, float тощо ..., використовуйте наступні заяви та ініціалізацію.

    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

Щоб використовувати динамічні функції, ви повинні використовувати Список ... Список - це чистий динамічний масив, і немає необхідності оголошувати розмір на початку. Нижче наведено правильний спосіб оголосити список у JAVA>

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("Value 1: something");
        myArray.add("Value 2: something more");

Оголосити масив: int[] arr;

Ініціалізувати масив: int[] arr = new int[10];10 представляє кількість елементів, дозволених у масиві

Оголосити багатовимірний масив: int[][] arr;

Ініціалізуйте багатовимірний масив: int[][] arr = new int[10][17];10 рядків та 17 стовпців та 170 елементів, оскільки 10 разів 17 - 170.

Ініціалізувати масив означає вказати його розмір.

Декларувати та ініціалізувати масив дуже просто. Наприклад, ви хочете зберегти п'ять цілих елементів, які є 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 формат масиву буде таким же, як цілий.

Наприклад:

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

але коли ви оголошуєте і ініціалізуєте масив "методом а", вам доведеться вводити значення вручну або через цикл чи щось.

Але коли ви це зробите за "методом b", вам не доведеться вводити значення вручну.

Масив може містити типи даних примітивів, а також об'єкти класу залежно від визначення масиву. У разі типів даних про примітиви фактичні значення зберігаються у суміжних місцях пам'яті. У випадку об’єктів класу фактичні об’єкти зберігаються в купі сегмента.

Одновимірні масиви:
загальною формою оголошення одновимірного масиву є

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

Ігнорування масиву на Java

var-name = new type [size];

Наприклад

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals 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]);

Довідка: https://www.geeksforgeeks.org/arrays-in-java/

ще один повний приклад з класом фільмів 😋

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);


            }

        } 

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};

int[] SingleDimensionalArray = new int[2]

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