Bagaimana cara mendeklarasikan dan menginisialisasi array di Java?

Anda bisa menggunakan deklarasi array atau array literal (tetapi hanya ketika Anda mendeklarasikan dan memengaruhi variabel segera, literal array tidak dapat digunakan untuk menetapkan ulang array).

Untuk tipe primitif:

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 

Untuk kelas, misalnya String, sama saja:

String[] myStringArray = new String[3];
String[] myStringArray = {"a", "b", "c"};
String[] myStringArray = new String[]{"a", "b", "c"};

Cara ketiga menginisialisasi berguna ketika Anda mendeklarasikan array terlebih dahulu dan kemudian menginisialisasi itu. Para pemain diperlukan di sini.

String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};

Ada dua jenis array.

Array Satu Dimensi

Sintaks untuk nilai default:

int[] num = new int[5];

Atau (kurang disukai)

int num[] = new int[5];

Sintaks dengan nilai yang diberikan (inisialisasi variabel / bidang):

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

Atau (kurang disukai)

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

Catatan: Untuk kenyamanan int [] num lebih disukai karena jelas mengatakan bahwa Anda berbicara di sini tentang array. Kalau tidak ada perbedaan. Tidak semuanya.

Array multidimensi

Pernyataan

int[][] num = new int[5][2];

Atau

int num[][] = new int[5][2];

Atau

int[] num[] = new int[5][2];

Inisialisasi

 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;

Atau

 int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

Array Ragged (atau Non-rectangular Array)

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

Jadi di sini kita mendefinisikan kolom secara eksplisit.
Cara lain:

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

Untuk Mengakses:

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

Kalau tidak:

for (int[] a : num) {
  for (int i : a) {
    System.out.println(i);
  }
}

Array berjubah adalah array multidimensi.
Untuk penjelasannya lihat detail array multidimensi di tutorial resmi java

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

juga valid, tapi saya lebih suka tanda kurung setelah tipe, karena lebih mudah untuk melihat bahwa tipe variabel sebenarnya adalah sebuah array.

Ada berbagai cara untuk mendeklarasikan array di Java:

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

Anda dapat menemukan informasi lebih lanjut di situs tutorial Sun dan JavaDoc .

Saya merasa sangat membantu jika Anda memahami setiap bagian:

Type[] name = new Type[5];

Type[]adalah jenis dari variabel disebut nama ( "nama" disebut identifier ). "Tipe" literal adalah tipe dasar, dan tanda kurung berarti ini adalah tipe array dari basis itu. Tipe array pada gilirannya adalah tipe mereka sendiri, yang memungkinkan Anda untuk membuat array multidimensi seperti Type[][](tipe array dari Tipe []). Kata kunci newmengatakan untuk mengalokasikan memori untuk array baru. Angka di antara braket menyatakan seberapa besar array baru dan berapa banyak memori yang dialokasikan. Misalnya, jika Java tahu bahwa tipe dasar Typemembutuhkan 32 byte, dan Anda menginginkan array berukuran 5, ia perlu mengalokasikan secara internal 32 * 5 = 160 byte.

Anda juga dapat membuat array dengan nilai-nilai yang sudah ada, seperti

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

yang tidak hanya menciptakan ruang kosong tetapi mengisinya dengan nilai-nilai itu. Java dapat mengatakan bahwa primitif adalah bilangan bulat dan ada 5 dari mereka, sehingga ukuran array dapat ditentukan secara implisit.

Berikut ini menunjukkan deklarasi array, tetapi array tidak diinisialisasi:

 int[] myIntArray = new int[3];

Berikut ini menunjukkan deklarasi serta inisialisasi array:

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

Sekarang, yang berikut ini juga memperlihatkan deklarasi dan inisialisasi array:

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

Tapi yang ketiga ini menunjukkan properti dari penciptaan objek-array anonim yang ditunjukkan oleh variabel referensi "myIntArray", jadi jika kita menulis hanya "new int [] {1,2,3};" maka ini adalah bagaimana array-objek anonim dapat dibuat.

Jika kita hanya menulis:

int[] myIntArray;

ini bukan deklarasi array, tetapi pernyataan berikut membuat deklarasi di atas lengkap:

myIntArray=new int[3];

Kalau tidak,

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

Itu menyatakan sebuah array yang disebut arrayNameukuran 10 (Anda memiliki elemen 0 hingga 9 untuk digunakan).

Juga, jika Anda menginginkan sesuatu yang lebih dinamis ada antarmuka Daftar. Ini tidak akan berkinerja baik, tetapi lebih fleksibel:

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

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

String value = listOfString.get(0);
assertEquals( value, "foo" );

Ada dua cara utama untuk membuat array:

Yang ini, untuk array kosong:

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

Dan yang ini, untuk array yang diinisialisasi:

int[] array = {1,2,3,4 ...};

Anda juga dapat membuat array multidimensi, seperti ini:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

Ambil intcontoh tipe primitif . Ada beberapa cara untuk mendeklarasikan dan mengatur int:

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

dimana dalam semua ini, Anda dapat menggunakan int i[]bukan int[] i.

Dengan refleksi, Anda bisa menggunakannya (Type[]) Array.newInstance(Type.class, capacity);

Perhatikan bahwa dalam parameter metode, ... menunjukkan variable arguments. Pada dasarnya, sejumlah parameter baik-baik saja. Lebih mudah dijelaskan dengan kode:

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

Di dalam metode, varargs diperlakukan seperti biasa int[]. Type...hanya dapat digunakan dalam parameter metode, jadi int... i = new int[] {}tidak akan dikompilasi.

Perhatikan bahwa ketika meneruskan suatu int[]metode (atau yang lain Type[]), Anda tidak bisa menggunakan cara ketiga. Dalam pernyataannyaint[] i = *{a, b, c, d, etc}* , kompilator mengasumsikan bahwa {...}berarti a int[]. Tapi itu karena Anda mendeklarasikan variabel. Saat mengirimkan array ke metode, deklarasi harus berupa new Type[capacity]atau new Type[] {...}.

Array Multidimensi

Array multidimensi jauh lebih sulit untuk dihadapi. Pada dasarnya, array 2D adalah array array. int[][]berarti array int[]s. Kuncinya adalah bahwa jika int[][]dinyatakan sebagai int[x][y], indeks maksimum adalah i[x-1][y-1]. Pada dasarnya, sebuah persegi panjang int[3][5]adalah:

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

Di Jawa 9

Menggunakan berbagai metode IntStream.iteratedan 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]

Di Jawa 10

Menggunakan Inferensi Tipe Variabel Lokal :

var letters = new String[]{"A", "B", "C"};

Jika Anda ingin membuat array menggunakan refleksi maka Anda dapat melakukannya seperti ini:

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

Mendeklarasikan array referensi objek:

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

Array adalah daftar item berurutan

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

Jika itu objek, maka konsepnya sama

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

Dalam hal objek, Anda perlu menetapkannya nulluntuk menginisialisasi mereka menggunakan new Type(..), kelas suka Stringdan Integerkasus khusus yang akan ditangani sebagai berikut

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

Secara umum Anda dapat membuat array yang Mberdimensi

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

Patut dicatat bahwa membuat Marray dimensi mahal dalam hal Space. Karena ketika Anda membuat Marray dimensi dengan Npada semua dimensi, Ukuran total array lebih besar daripada N^M, karena setiap array memiliki referensi, dan pada dimensi M ada array (M-1) -dimensi dimensi referensi. Ukuran total adalah sebagai berikut

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

Di Java 8 Anda bisa menggunakan seperti ini.

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

Untuk membuat array Objek kelas Anda dapat menggunakan java.util.ArrayList. untuk mendefinisikan array:

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Tetapkan nilai ke array:

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

Baca dari array:

ClassName variableName = arrayName.get(index);

catatan:

variableNameadalah referensi ke makna array yang memanipulasi variableNameakan memanipulasiarrayName

untuk loop:

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

untuk loop yang memungkinkan Anda untuk mengedit arrayName(konvensional untuk loop):

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

Deklarasikan dan inisialisasi untuk Java 8 dan yang lebih baru. Buat array integer sederhana:

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]

Buat array acak untuk bilangan bulat antara [-50, 50] dan untuk ganda [0, 1E17]:

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

Urutan dua kekuatan:

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]

Untuk String [] Anda harus menentukan konstruktor:

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

Array multidimensi:

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]]

Cara lain untuk mendeklarasikan dan menginisialisasi ArrayList:

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

Ada banyak jawaban di sini. Saya menambahkan beberapa cara rumit untuk membuat array (dari sudut pandang ujian , ada baiknya mengetahui hal ini)

1. Deklarasikan dan tentukan array

   int intArray[] = new int[3];

   Ini akan membuat array dengan panjang 3. Karena ini memegang tipe primitif, int, semua nilai diatur ke 0 secara default. Sebagai contoh,

   intArray[2]; // Will return 0

2. Menggunakan kurung kotak [] sebelum nama variabel

   int[] intArray = new int[3];
   intArray[0] = 1;  // Array content is now {1, 0, 0}

3. Inisialisasi dan berikan data ke array

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

   Kali ini tidak perlu menyebutkan ukuran di braket kotak. Bahkan varian sederhana dari ini adalah:

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

4. Array dengan panjang 0

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

   Mirip untuk array multi dimensi

   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

Menggunakan kurung kotak sebelum variabel:

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

Tidak apa-apa jika Anda menempatkan satu braket kotak di bagian akhir:

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

Beberapa contoh

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

Tidak wajib bahwa setiap elemen dalam memiliki ukuran yang sama.

    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.

Anda harus memastikan jika Anda menggunakan sintaks di atas, bahwa arah maju Anda harus menentukan nilai dalam kurung kotak. Kalau tidak, itu tidak akan dikompilasi. Beberapa contoh:

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

Fitur penting lainnya adalah kovarian

    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

PENTING: Untuk tipe yang direferensikan, nilai default yang disimpan dalam array adalah nol.

Anda juga dapat melakukannya dengan java.util.Arrays:

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

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

Yang ini cukup sederhana dan mudah.

Dengan inferensi tipe variabel lokal Anda hanya perlu menentukan jenisnya sekali:

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

Atau

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

Array memiliki dua tipe dasar.

Array Statis: Array ukuran tetap (Ukurannya harus dideklarasikan pada awal dan tidak dapat diubah kemudian)

Dynamic Array: Tidak ada batasan ukuran untuk ini. (Array dinamis murni tidak ada di Jawa. Sebaliknya, Daftar paling dianjurkan)

Untuk mendeklarasikan array statis Integer, string, float, dll ... gunakan pernyataan di bawah ini dan pernyataan inisialisasi.

    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

Untuk menggunakan fitur dinamis, Anda harus menggunakan Daftar ... Daftar adalah array dinamis murni dan tidak perlu menyatakan ukuran di awal. Di bawah adalah cara yang tepat untuk mendeklarasikan daftar di JAVA>

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

Deklarasikan Array: int[] arr;

Initialize Array: int[] arr = new int[10];10 menunjukkan jumlah elemen yang diizinkan dalam array

Deklarasikan Array Multidimensi: int[][] arr;

Inisialisasi Array Multidimensi: int[][] arr = new int[10][17];10 baris dan 17 kolom dan 170 elemen karena 10 kali 17 adalah 170.

Menginisialisasi array berarti menentukan ukurannya.

Sangat mudah untuk mendeklarasikan dan menginisialisasi array. Misalnya, Anda ingin menyimpan lima elemen integer yang 1, 2, 3, 4, dan 5 dalam sebuah array. Anda dapat melakukannya dengan cara berikut:

Sebuah)

int[] a = new int[5];

atau

b)

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

jadi pola dasarnya adalah untuk inisialisasi dan deklarasi dengan metode a) adalah:

datatype[] arrayname = new datatype[requiredarraysize];

datatype harus dalam huruf kecil.

Jadi pola dasar untuk inisialisasi dan deklarasi dengan metode a adalah:

Jika array string:

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

Jika array karakter:

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

Untuk float double, format array akan sama dengan integer.

Sebagai contoh:

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

tetapi ketika Anda mendeklarasikan dan menginisialisasi array dengan "metode a" Anda harus memasukkan nilai secara manual atau dengan loop atau sesuatu.

Tetapi ketika Anda melakukannya dengan "metode b" Anda tidak harus memasukkan nilai secara manual.

Array dapat berisi tipe data primitif serta objek kelas tergantung pada definisi array. Dalam kasus tipe data primitif, nilai aktual disimpan di lokasi memori yang berdekatan. Dalam kasus objek kelas, objek aktual disimpan di segmen heap.

Array Satu Dimensi:
Bentuk umum deklarasi array satu dimensi adalah

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

Membuat Instansi Array di Jawa

var-name = new type [size];

Sebagai contoh

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

Ref: https://www.geeksforgeeks.org/arrays-in-java/

satu contoh lengkap lainnya dengan kelas film 😋

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

contoh:

int[] x=new int[10];

atau

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

contoh:

int[] x={10,65,40,5,48,31};

int[] SingleDimensionalArray = new int[2]

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