Triển khai mảng javascript

Một mảng là một đối tượng chứa chứa một số giá trị cố định của một loại. Độ dài của một mảng được thiết lập khi mảng được tạo. Sau khi tạo, độ dài của nó là cố định. Bạn đã thấy một ví dụ về mảng rồi, trong phương thức

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
9 của "Xin chào thế giới. " đăng kí. Phần này thảo luận về mảng chi tiết hơn

Triển khai mảng javascript

Mảng 10 phần tử

Mỗi mục trong một mảng được gọi là một phần tử và mỗi phần tử được truy cập bằng chỉ số của nó. Như thể hiện trong hình minh họa trước, việc đánh số bắt đầu bằng 0. Ví dụ, phần tử thứ 9 sẽ được truy cập tại chỉ mục 8

Chương trình sau đây,

// declares an array of integers
int[] anArray;
0, tạo một mảng các số nguyên, đặt một số giá trị vào mảng và in từng giá trị ra đầu ra tiêu chuẩn

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];
           
        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        System.out.println("Element at index 0: "
                           + anArray[0]);
        System.out.println("Element at index 1: "
                           + anArray[1]);
        System.out.println("Element at index 2: "
                           + anArray[2]);
        System.out.println("Element at index 3: "
                           + anArray[3]);
        System.out.println("Element at index 4: "
                           + anArray[4]);
        System.out.println("Element at index 5: "
                           + anArray[5]);
        System.out.println("Element at index 6: "
                           + anArray[6]);
        System.out.println("Element at index 7: "
                           + anArray[7]);
        System.out.println("Element at index 8: "
                           + anArray[8]);
        System.out.println("Element at index 9: "
                           + anArray[9]);
    }
} 

Đầu ra từ chương trình này là

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000

Trong một tình huống lập trình trong thế giới thực, bạn có thể sẽ sử dụng một trong các cấu trúc vòng lặp được hỗ trợ để lặp qua từng phần tử của mảng, thay vì viết từng dòng riêng lẻ như trong ví dụ trước. Tuy nhiên, ví dụ minh họa rõ ràng cú pháp mảng. Bạn sẽ tìm hiểu về các cấu trúc vòng lặp khác nhau (

// declares an array of integers
int[] anArray;
1,
// declares an array of integers
int[] anArray;
2 và
// declares an array of integers
int[] anArray;
3) trong phần Luồng điều khiển

Khai báo một biến để tham chiếu đến một mảng

Chương trình trước khai báo một mảng (tên là

// declares an array of integers
int[] anArray;
4) với dòng mã sau

// declares an array of integers
int[] anArray;

Giống như khai báo cho các loại biến khác, khai báo mảng có hai thành phần. kiểu của mảng và tên của mảng. Kiểu của một mảng được viết là

// declares an array of integers
int[] anArray;
5, trong đó
// declares an array of integers
int[] anArray;
6 là kiểu dữ liệu của các phần tử chứa trong đó; . Kích thước của mảng không phải là một phần của kiểu của nó (đó là lý do tại sao các dấu ngoặc trống). Tên của mảng có thể là bất cứ thứ gì bạn muốn, miễn là nó tuân theo các quy tắc và quy ước như đã thảo luận trước đó trong phần đặt tên. Cũng như các biến thuộc các kiểu khác, việc khai báo không thực sự tạo ra một mảng;

Tương tự, bạn có thể khai báo các mảng kiểu khác

// declares an array of integers
int[] anArray;
1

Bạn cũng có thể đặt dấu ngoặc sau tên mảng

// declares an array of integers
int[] anArray;
2

Tuy nhiên, quy ước không khuyến khích hình thức này;

Tạo, khởi tạo và truy cập một mảng

Một cách để tạo mảng là sử dụng toán tử

// declares an array of integers
int[] anArray;
7. Câu lệnh tiếp theo trong chương trình
// declares an array of integers
int[] anArray;
0 cấp phát mảng có đủ bộ nhớ cho 10 phần tử số nguyên và gán mảng cho biến
// declares an array of integers
int[] anArray;
4

// declares an array of integers
int[] anArray;
6

Nếu câu lệnh này bị thiếu, thì trình biên dịch sẽ in ra lỗi như sau và quá trình biên dịch không thành công

// declares an array of integers
int[] anArray;
7

Các dòng tiếp theo gán giá trị cho từng phần tử của mảng

// declares an array of integers
int[] anArray;
8

Mỗi phần tử mảng được truy cập bởi chỉ số của nó

// declares an array of integers
int[] anArray;
9

Ngoài ra, bạn có thể sử dụng cú pháp tắt để tạo và khởi tạo mảng

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];
           
        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        System.out.println("Element at index 0: "
                           + anArray[0]);
        System.out.println("Element at index 1: "
                           + anArray[1]);
        System.out.println("Element at index 2: "
                           + anArray[2]);
        System.out.println("Element at index 3: "
                           + anArray[3]);
        System.out.println("Element at index 4: "
                           + anArray[4]);
        System.out.println("Element at index 5: "
                           + anArray[5]);
        System.out.println("Element at index 6: "
                           + anArray[6]);
        System.out.println("Element at index 7: "
                           + anArray[7]);
        System.out.println("Element at index 8: "
                           + anArray[8]);
        System.out.println("Element at index 9: "
                           + anArray[9]);
    }
} 
0

Ở đây, độ dài của mảng được xác định bởi số lượng giá trị được cung cấp giữa các dấu ngoặc nhọn và được phân tách bằng dấu phẩy

Bạn cũng có thể khai báo một mảng gồm các mảng (còn được gọi là mảng nhiều chiều) bằng cách sử dụng hai hoặc nhiều bộ dấu ngoặc, chẳng hạn như

// declares an array of integers
int[] anArray;
10. Do đó, mỗi phần tử phải được truy cập bởi một số giá trị chỉ mục tương ứng

Trong ngôn ngữ lập trình Java, mảng nhiều chiều là mảng mà các thành phần của nó chính là mảng. Điều này không giống như các mảng trong C hoặc Fortran. Hệ quả của điều này là các hàng được phép thay đổi độ dài, như thể hiện trong chương trình

// declares an array of integers
int[] anArray;
11 sau

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
0

Đầu ra từ chương trình này là

Cuối cùng, bạn có thể sử dụng thuộc tính

// declares an array of integers
int[] anArray;
12 tích hợp để xác định kích thước của bất kỳ mảng nào. Đoạn mã sau in kích thước của mảng thành đầu ra tiêu chuẩn

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
1

Sao chép mảng

Lớp

// declares an array of integers
int[] anArray;
13 có phương thức
// declares an array of integers
int[] anArray;
14 mà bạn có thể sử dụng để sao chép dữ liệu từ mảng này sang mảng khác một cách hiệu quả

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
2

Hai đối số

// declares an array of integers
int[] anArray;
15 chỉ định mảng cần sao chép và mảng cần sao chép vào. Ba đối số
// declares an array of integers
int[] anArray;
16 chỉ định vị trí bắt đầu trong mảng nguồn, vị trí bắt đầu trong mảng đích và số phần tử mảng cần sao chép

Chương trình sau,

// declares an array of integers
int[] anArray;
17, khai báo một mảng gồm các phần tử
// declares an array of integers
int[] anArray;
18. Nó sử dụng phương thức
// declares an array of integers
int[] anArray;
19 để sao chép một dãy con của các thành phần mảng vào một mảng thứ hai

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
3

Đầu ra từ chương trình này là

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
4

Thao tác mảng

Mảng là một khái niệm mạnh mẽ và hữu ích được sử dụng trong lập trình. Java SE cung cấp các phương thức để thực hiện một số thao tác phổ biến nhất liên quan đến mảng. Chẳng hạn, ví dụ về

// declares an array of integers
int[] anArray;
17 sử dụng phương thức
// declares an array of integers
int[] anArray;
14 của lớp
// declares an array of integers
int[] anArray;
13 thay vì lặp thủ công qua các phần tử của mảng nguồn và đặt từng phần tử vào mảng đích. Điều này được thực hiện ở hậu trường, cho phép nhà phát triển chỉ sử dụng một dòng mã để gọi phương thức

Để thuận tiện cho bạn, Java SE cung cấp một số phương thức để thực hiện các thao tác với mảng (các tác vụ phổ biến, chẳng hạn như sao chép, sắp xếp và tìm kiếm mảng) trong lớp

// declares an array of integers
int[] anArray;
23. Chẳng hạn, ví dụ trước có thể được sửa đổi để sử dụng phương thức
// declares an array of integers
int[] anArray;
24 của lớp
// declares an array of integers
int[] anArray;
23, như bạn có thể thấy trong ví dụ
// declares an array of integers
int[] anArray;
26. Sự khác biệt là việc sử dụng phương thức
// declares an array of integers
int[] anArray;
24 không yêu cầu bạn tạo mảng đích trước khi gọi phương thức, bởi vì mảng đích được trả về bởi phương thức

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
5

Như bạn có thể thấy, đầu ra từ chương trình này là như nhau, mặc dù nó yêu cầu ít dòng mã hơn. Lưu ý rằng tham số thứ hai của phương thức

// declares an array of integers
int[] anArray;
24 là chỉ mục ban đầu của phạm vi được sao chép, bao gồm, trong khi tham số thứ ba là chỉ mục cuối cùng của phạm vi được sao chép, riêng. Trong ví dụ này, phạm vi được sao chép không bao gồm phần tử mảng ở chỉ số 9 (chứa chuỗi
// declares an array of integers
int[] anArray;
29)

Một số hoạt động hữu ích khác được cung cấp bởi các phương thức trong lớp

// declares an array of integers
int[] anArray;
23 là

  • Tìm kiếm một mảng cho một giá trị cụ thể để lấy chỉ mục mà nó được đặt (phương thức

    // declares an array of integers
    int[] anArray;
    
    61)

  • So sánh hai mảng để xác định xem chúng có bằng nhau hay không (phương pháp

    // declares an array of integers
    int[] anArray;
    
    62)

  • Điền vào một mảng để đặt một giá trị cụ thể tại mỗi chỉ mục (phương thức

    // declares an array of integers
    int[] anArray;
    
    63)

  • Sắp xếp một mảng theo thứ tự tăng dần. Điều này có thể được thực hiện tuần tự, sử dụng phương thức

    // declares an array of integers
    int[] anArray;
    
    64 hoặc đồng thời, sử dụng phương thức
    // declares an array of integers
    int[] anArray;
    
    65 được giới thiệu trong Java SE 8. Sắp xếp song song các mảng lớn trên hệ thống đa bộ xử lý nhanh hơn so với sắp xếp mảng tuần tự

  • Tạo một luồng sử dụng một mảng làm nguồn của nó (phương thức

    // declares an array of integers
    int[] anArray;
    
    66). Ví dụ: câu lệnh sau in nội dung của mảng
    // declares an array of integers
    int[] anArray;
    
    67 giống như trong ví dụ trước

    Element at index 0: 100
    Element at index 1: 200
    Element at index 2: 300
    Element at index 3: 400
    Element at index 4: 500
    Element at index 5: 600
    Element at index 6: 700
    Element at index 7: 800
    Element at index 8: 900
    Element at index 9: 1000
    
    6

    Xem Hoạt động tổng hợp để biết thêm thông tin về luồng

  • Chuyển đổi một mảng thành một chuỗi. Phương thức

    // declares an array of integers
    int[] anArray;
    
    68 chuyển đổi từng phần tử của mảng thành một chuỗi, phân tách chúng bằng dấu phẩy, sau đó bao quanh chúng bằng dấu ngoặc. Ví dụ: câu lệnh sau chuyển đổi mảng
    // declares an array of integers
    int[] anArray;
    
    67 thành một chuỗi và in nó