Làm cách nào để khai báo và khởi tạo một mảng trong Java?

Bạn có thể sử dụng khai báo mảng hoặc bằng chữ (nhưng chỉ khi bạn khai báo và ảnh hưởng đến biến ngay lập tức, thì không thể sử dụng các ký tự mảng để gán lại một mảng).

Đối với các loại nguyên thủy:

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 

Đối với các lớp, ví dụ String, nó giống nhau:

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

Cách khởi tạo thứ ba rất hữu ích khi bạn khai báo mảng trước rồi khởi tạo nó. Các diễn viên là cần thiết ở đây.

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

Có hai loại mảng.

Mảng một chiều

Cú pháp cho các giá trị mặc định:

int[] num = new int[5];

Hoặc (ít ưu tiên hơn)

int num[] = new int[5];

Cú pháp với các giá trị đã cho (khởi tạo biến / trường):

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

Hoặc (ít ưu tiên hơn)

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

Lưu ý: Để thuận tiện, int [] num thích hợp hơn vì nó nói rõ rằng bạn đang nói ở đây về mảng. Nếu không thì không có gì khác biệt. Không có gì.

Mảng đa chiều

Tờ khai

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

Hoặc là

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

Hoặc là

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

Khởi tạo

 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;

Hoặc là

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

Mảng rách (hoặc Mảng không phải hình chữ nhật)

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

Vì vậy, ở đây chúng tôi đang xác định cột rõ ràng.
Cách khác:

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

Để truy cập:

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

Cách khác:

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

Mảng rách là mảng đa chiều.
Để được giải thích, xem chi tiết mảng đa chiều tại các hướng dẫn java chính thức

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

cũng hợp lệ, nhưng tôi thích dấu ngoặc sau kiểu hơn, vì dễ thấy rằng kiểu của biến thực sự là một mảng.

Có nhiều cách khác nhau để bạn có thể khai báo một mảng trong Java:

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

Bạn có thể tìm thêm thông tin trong trang hướng dẫn của Sun và JavaDoc .

Tôi thấy nó hữu ích nếu bạn hiểu từng phần:

Type[] name = new Type[5];

Type[]là loại của biến được gọi tên ( "tên" được gọi là định danh ). "Loại" theo nghĩa đen là loại cơ sở và dấu ngoặc có nghĩa đây là loại mảng của cơ sở đó. Các kiểu mảng lần lượt là các kiểu của chính chúng, cho phép bạn tạo các mảng đa chiều như Type[][](kiểu mảng của Loại []). Từ khóa newnói để phân bổ bộ nhớ cho mảng mới. Con số giữa khung cho biết mảng mới sẽ lớn đến mức nào và phân bổ bộ nhớ bao nhiêu. Chẳng hạn, nếu Java biết rằng loại cơ sở Typecần 32 byte và bạn muốn một mảng có kích thước 5, thì nó cần phân bổ bên trong 32 * 5 = 160 byte.

Bạn cũng có thể tạo các mảng với các giá trị đã có, chẳng hạn như

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

không chỉ tạo ra không gian trống mà còn lấp đầy nó với các giá trị đó. Java có thể nói rằng các nguyên hàm là các số nguyên và có 5 trong số chúng, do đó kích thước của mảng có thể được xác định ngầm.

Sau đây cho thấy khai báo của một mảng, nhưng mảng không được khởi tạo:

 int[] myIntArray = new int[3];

Sau đây cho thấy khai báo cũng như khởi tạo mảng:

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

Bây giờ, sau đây cũng cho thấy khai báo cũng như khởi tạo mảng:

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

Nhưng cái thứ ba này cho thấy thuộc tính của việc tạo đối tượng mảng ẩn danh được chỉ ra bởi một biến tham chiếu "myIntArray", vì vậy nếu chúng ta chỉ viết "new int [] {1,2,3};" thì đây là cách đối tượng mảng ẩn danh có thể được tạo.

Nếu chúng ta chỉ viết:

int[] myIntArray;

Đây không phải là khai báo mảng, nhưng câu lệnh sau làm cho khai báo trên hoàn thành:

myIntArray=new int[3];

Ngoài ra,

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

Điều đó khai báo một mảng được gọi là arrayNamekích thước 10 (bạn có các phần tử từ 0 đến 9 để sử dụng).

Ngoài ra, trong trường hợp bạn muốn một cái gì đó năng động hơn, có giao diện Danh sách. Điều này sẽ không thực hiện tốt, nhưng linh hoạt hơn:

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

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

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

Có hai cách chính để tạo một mảng:

Cái này, cho một mảng trống:

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

Và cái này, cho một mảng khởi tạo:

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

Bạn cũng có thể tạo các mảng nhiều chiều, như thế này:

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

Lấy kiểu nguyên thủy intchẳng hạn. Có một số cách để khai báo và intmảng:

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

nơi mà trong tất cả những thứ này, bạn có thể sử dụng int i[]thay vì int[] i.

Với sự phản chiếu, bạn có thể sử dụng (Type[]) Array.newInstance(Type.class, capacity);

Lưu ý rằng trong các tham số phương thức, ...chỉ ra variable arguments. Về cơ bản, bất kỳ số lượng các tham số là tốt. Giải thích bằng mã dễ dàng hơn:

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

Bên trong phương pháp, varargsđược coi là bình thường int[]. Type...chỉ có thể được sử dụng trong các tham số phương thức, vì vậy int... i = new int[] {}sẽ không biên dịch.

Lưu ý rằng khi truyền int[]một phương thức (hoặc bất kỳ phương thức nào khác Type[]), bạn không thể sử dụng cách thứ ba. Trong câu lệnh int[] i = *{a, b, c, d, etc}*, trình biên dịch giả định rằng {...}có nghĩa là một int[]. Nhưng đó là bởi vì bạn đang khai báo một biến. Khi truyền một mảng cho một phương thức, khai báo phải là new Type[capacity]hoặc new Type[] {...}.

Mảng đa chiều

Mảng nhiều chiều khó đối phó hơn nhiều. Về cơ bản, một mảng 2D là một mảng các mảng. int[][]có nghĩa là một mảng của int[]s. Điều quan trọng là nếu một int[][]được khai báo là int[x][y], chỉ số tối đa là i[x-1][y-1]. Về cơ bản, một hình chữ nhật int[3][5]là:

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

Trong Java 9

Sử dụng khác nhau IntStream.iteratevà IntStream.takeWhilephương pháp:

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]

Trong Java 10

Sử dụng suy luận kiểu biến cục bộ :

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

Nếu bạn muốn tạo mảng bằng phản xạ thì bạn có thể làm như thế này:

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

Khai báo một mảng các tham chiếu đối tượng:

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

Mảng là một danh sách tuần tự của các mục

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

Nếu đó là một đối tượng, thì đó là cùng một khái niệm

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

Trong trường hợp của các đối tượng, bạn cần gán nó nullđể khởi tạo chúng bằng cách sử dụng new Type(..), các lớp như Stringvà Integerlà các trường hợp đặc biệt sẽ được xử lý như sau

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

Nói chung, bạn có thể tạo các mảng theo Mchiều

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

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

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

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

Thật đáng để lưu ý rằng việc tạo ra một Mmảng chiều rất tốn kém về mặt Không gian. Vì khi bạn tạo một Mmảng thứ nguyên với Ntất cả các kích thước, Tổng kích thước của mảng lớn hơn N^M, vì mỗi mảng có một tham chiếu và tại kích thước M có một mảng tham chiếu hai chiều (M-1). Tổng kích thước như sau

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

Trong Java 8, bạn có thể sử dụng như thế này.

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

Để tạo các mảng của Đối tượng lớp, bạn có thể sử dụng java.util.ArrayList. để xác định một mảng:

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

Gán các giá trị cho mảng:

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

Đọc từ mảng:

ClassName variableName = arrayName.get(index);

Ghi chú:

variableNamelà một tham chiếu đến mảng có nghĩa là thao tác variableNamesẽ thao tácarrayName

cho các vòng lặp:

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

cho vòng lặp cho phép bạn chỉnh sửa arrayName(vòng lặp thông thường):

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

Khai báo và khởi tạo cho Java 8 trở lên. Tạo một mảng số nguyên đơn giản:

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]

Tạo một mảng ngẫu nhiên cho các số nguyên giữa [-50, 50] và nhân đôi [0, 1E17]:

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

Chuỗi sức mạnh của hai:

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]

Đối với Chuỗi [], bạn phải chỉ định hàm tạo:

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

Mảng nhiều chiều:

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

Một cách khác để khai báo và khởi tạo ArrayList:

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

Có rất nhiều câu trả lời ở đây. Tôi đang thêm một vài cách khó khăn để tạo mảng (từ quan điểm của kỳ thi , thật tốt khi biết điều này)

1. Khai báo và định nghĩa một mảng

   int intArray[] = new int[3];

   Điều này sẽ tạo ra một mảng có độ dài 3. Vì nó giữ một kiểu nguyên thủy, int, tất cả các giá trị được đặt thành 0 theo mặc định. Ví dụ,

   intArray[2]; // Will return 0

2. Sử dụng ngoặc vuông [] trước tên biến

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

3. Khởi tạo và cung cấp dữ liệu cho mảng

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

   Lần này không cần phải đề cập đến kích thước trong khung hộp. Ngay cả một biến thể đơn giản của điều này là:

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

4. Mảng có độ dài 0

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

   Tương tự cho mảng đa chiều

   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

Sử dụng dấu ngoặc hộp trước biến:

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

Sẽ hoàn toàn tốt nếu bạn đặt một khung hộp ở cuối:

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

Vài ví dụ

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

Không bắt buộc rằng mỗi phần tử bên trong có cùng kích thước.

    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.

Bạn phải chắc chắn nếu bạn đang sử dụng cú pháp trên, rằng hướng chuyển tiếp bạn phải chỉ định các giá trị trong ngoặc vuông. Khác nó sẽ không biên dịch. Vài ví dụ:

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

Một tính năng quan trọng khác là covariant

    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

QUAN TRỌNG: Đối với các loại tham chiếu, giá trị mặc định được lưu trữ trong mảng là null.

Bạn cũng có thể làm điều đó với java.util.Arrays:

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

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

Điều này là khá đơn giản và đơn giản.

Với suy luận kiểu biến cục bộ, bạn chỉ phải xác định kiểu một lần:

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

Hoặc là

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

Mảng có hai loại cơ bản.

Mảng tĩnh: Mảng kích thước cố định (Kích thước của nó phải được khai báo khi bắt đầu và không thể thay đổi sau này)

Dynamic Array: Không giới hạn kích thước được xem xét cho việc này. (Mảng động thuần túy không tồn tại trong Java. Thay vào đó, Danh sách được khuyến khích nhất)

Để khai báo một mảng tĩnh gồm Integer, chuỗi, float, v.v ... hãy sử dụng các câu lệnh khởi tạo và khai báo dưới đây.

    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

Để sử dụng các tính năng động, bạn phải sử dụng Danh sách ... Danh sách là Mảng động thuần túy và không cần phải khai báo kích thước khi bắt đầu. Dưới đây là cách thích hợp để khai báo danh sách trong JAVA>

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

Khai báo mảng: int[] arr;

Khởi tạo mảng: int[] arr = new int[10];10 biểu thị số phần tử được phép trong mảng

Khai báo mảng đa chiều: int[][] arr;

Khởi tạo Mảng nhiều chiều: int[][] arr = new int[10][17];10 hàng và 17 cột và 170 phần tử vì 10 lần 17 là 170.

Khởi tạo một mảng có nghĩa là chỉ định kích thước của nó.

Rất dễ dàng để khai báo và khởi tạo một mảng. Ví dụ: bạn muốn lưu năm phần tử nguyên là 1, 2, 3, 4 và 5 trong một mảng. Bạn có thể làm theo cách sau:

a)

int[] a = new int[5];

hoặc là

b)

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

vì vậy mẫu cơ bản là để khởi tạo và khai báo theo phương thức a) là:

datatype[] arrayname = new datatype[requiredarraysize];

datatype nên ở dạng chữ thường

Vì vậy, mẫu cơ bản là để khởi tạo và khai báo theo phương pháp a là:

Nếu đó là một chuỗi chuỗi:

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

Nếu đó là một mảng ký tự:

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

Đối với float double, định dạng của mảng sẽ giống như số nguyên.

Ví dụ:

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

nhưng khi bạn khai báo và khởi tạo mảng bằng "phương thức a", bạn sẽ phải nhập các giá trị theo cách thủ công hoặc theo vòng lặp hoặc một cái gì đó.

Nhưng khi bạn thực hiện bằng "phương pháp b", bạn sẽ không phải nhập các giá trị theo cách thủ công.

Mảng có thể chứa các kiểu dữ liệu nguyên thủy cũng như các đối tượng của một lớp tùy thuộc vào định nghĩa của mảng. Trong trường hợp các kiểu dữ liệu nguyên thủy, các giá trị thực được lưu trữ ở các vị trí bộ nhớ liền kề. Trong trường hợp các đối tượng của một lớp, các đối tượng thực tế được lưu trữ trong phân đoạn heap.

Mảng một chiều:
Dạng chung của khai báo mảng một chiều là

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

Khởi tạo một mảng trong Java

var-name = new type [size];

Ví dụ

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

Tham chiếu: https://www.geekforgeek.org/arrays-in-java/

một ví dụ đầy đủ khác với lớp phim

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

thí dụ:

int[] x=new int[10];

hoặc là

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

thí dụ:

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

int[] SingleDimensionalArray = new int[2]

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