tra-loi-cau-hoi-phat-trien-web.com

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

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

1841
bestattendance

Bạn có thể sử dụng khai báo mảng hoặc mảng bằng chữ (nhưng chỉ khi bạn khai báo và ảnh hưởng đến biến ngay lập tức, không thể sử dụng 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};

Đố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"};
2450
glmxndr

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, hãy xem chi tiết mảng nhiều chiều tại các hướng dẫn chính thức về Java

253
Isabella Engineer
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.

120
Nate

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 hướng dẫn Sun site và JavaDoc .

35
Anirudh

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];
28
Amit Bhandari

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

Type[] name = new Type[5];

Type[] loại của biến biến tên được gọi ("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úng, cho phép bạn tạo các mảng nhiều chiều như Type[][] (kiểu mảng của Loại []). Từ khóa new nó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ở Type mất 32 byte và bạn muốn một mảng có kích thước 5, thì nó cần phải phân bổ nội bộ 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.

27
Chet

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ó tên arrayName có kích thước 10 (bạn có các phần tử từ 0 đến 9 để sử dụng).

25
Thomas Owens

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" );
24
Dave

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 ...} ...};
14
codecubed

Lấy loại nguyên thủy int làm ví dụ. Có một số cách để khai báo và mảng int:

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

trong đó, 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, ... biểu thị 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 thức, varargs được coi là một int[] bình thường. Type... chỉ có thể được sử dụng trong các tham số của 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[] cho một phương thức (hoặc bất kỳ Type[] nào khác), 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à 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 int[]s. Điều quan trọng là nếu một int[][] được khai báo là int[x][y], thì chỉ mục 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]
10
HyperNeutrino

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 ); 
9
Muhammad Suleman

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

Trong Java 9

Sử dụng các phương thức IntStream.iterateIntStream.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]

Trong Java 10

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

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

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 đối tượng, bạn cần gán nó cho null để khởi tạo chúng bằng cách sử dụng new Type(..), các lớp như StringInteger là 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 đó là M chiề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 một mảng M là tốn kém về mặt Không gian. Vì khi bạn tạo một mảng M với N trên tấ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à ở chiều M có một mảng chiều (M-1) tài liệu tham khảo. Tổng kích thước như sau

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

Để tạo 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);

Chú thích:

variableName là một tham chiếu đến mảng có nghĩa là thao tác variableName sẽ thao tác arrayName

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
}
6
Samuel Newport

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);
6
Chamly Idunil

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à cho 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]]
4
Kirill Podlivaev

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. Tôi đã không nhìn thấy nó trong các câu trả lời khác vì vậy tôi nghĩ rằng tôi có thể thêm nó.

3
Sylhare

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");
}};
2
Clement.Xu

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 }
1
Konstantin Spirin

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 nhiều 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ó.

0
kundus

Rất nhiều câu trả lời ở đây. Thêm một vài cách khó khăn để tạo mảng (Từ một kỳ thi quan điểm 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ữ 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
  1. Sử dụng ngoặc vuông [] trước tên biến

    int[] intArray = new int[3];
    intArray[0] = 1;  // array content now {1,0,0}
    
  2. 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 đề cập đến kích thước trong khung hộp. Ngay cả biến thể đơn giản của điều này là

    int[] intArray = {1,2,3,4};
    
  3. 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];
    

    nó 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 yếu 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 rằng nếu bạn đang sử dụng cú pháp trên, hãy chuyển hướng bạn phải chỉ định các giá trị trong ngoặc vuông. Hãy để nó 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

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

0
Arundev

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 5 phần tử nguyên là 1,2,3,4,5 trong một mảng để bạn có thể thực hiện theo cách sau:

a)

int[] a =new int[5];

hoặc 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 pháp a là:

datatype[] arrayname = new datatype[requiredarraysize];

kiểu dữ liệu 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 thức a là: nếu đó là mảng chuỗi:

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

nếu đó là một mảng char:

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

cho float gấp đôi đị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 thức b", bạn sẽ không phải nhập các giá trị theo cách thủ công.

0
Syed Salman Hassan