lớp mảng

Xin chào lần nữa! :) Trong bài học hôm nay, chúng ta sẽ nói về lớp Arrays trong Java. Trong bài học trước, chúng ta đã biết một cấu trúc dữ liệu gọi là mảng. Chúng tôi đã học cách tạo chúng và điền dữ liệu vào chúng. Và chúng tôi đã xem xét cách chúng được lưu trữ trong bộ nhớ. Hôm nay chúng ta sẽ xem xét một số tác vụ và ví dụ về cách làm việc với mảng mà bạn thường thấy trong công việc thực tế. Ví dụ, hãy tưởng tượng tình huống này: Chúng tôi có một mảng gồm 10 số ngẫu nhiên.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Nhiệm vụ của chúng ta là sắp xếp mảng này theo thứ tự tăng dần: từ nhỏ nhất đến lớn nhất. Cuối cùng, nó sẽ như thế này: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Chúng ta làm điều đó như thế nào? Nhiệm vụ này không tầm thường. Chúng tôi chưa bao giờ làm điều này trước đây :/ Có ý tưởng nào không? Thử đoán. Đây là một giải pháp:

• Đi qua tất cả các phần tử của mảng. So sánh từng phần tử với phần tử tiếp theo ([0] với [1], [1] với [2], [2] với [3], v.v.). Nếu phần tử hiện tại lớn hơn phần tử tiếp theo, chúng ta hoán đổi chúng, rồi chuyển sang phần tử tiếp theo. Nếu không, hãy để chúng như vậy và tiếp tục
• Do đó, sau lần đầu tiên đi qua các phần tử, giá trị lớn nhất (167) được đảm bảo nằm trong ô cuối cùng.
• Bây giờ chúng ta sẽ xem xét lại tất cả các phần tử, nhưng lần này chúng ta sẽ bắt đầu với chỉ số [0] đến phần tử áp chót (số lớn nhất đã ở vị trí của nó) và thực hiện các phép so sánh và hoán đổi tương tự. Sau khi vượt qua, trong ô áp chót, chúng tôi sẽ có giá trị lớn thứ hai (99).
• Lặp lại quá trình này nhiều lần khi chúng ta có các phần tử mảng.

Chúng tôi đã có ý tưởng. Bây giờ chúng ta chỉ cần viết mã. Nó trông như thế này:

public class Main {

   public static void main(String[] args) {
      
       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Uh... Có vẻ hơi phức tạp -_- Ngay cả khi nguyên tắc chung có thể hiểu được, chúng ta vẫn phải viết khá nhiều mã để giải quyết một nhiệm vụ đơn giản như vậy. Được rồi, có lẽ chúng ta đã đánh giá quá cao bản thân? Nhiệm vụ chúng tôi đã giải quyết có lẽ vẫn còn quá phức tạp đối với chúng tôi. Hãy thử một cái gì đó đơn giản hơn. Ví dụ, lấy cùng một mảng số.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Nhiệm vụ của chúng ta là sao chép nội dung của nó sang một mảng khác.

int [] numbersCopy = new int[10];

Hãy suy nghĩ về cách bạn sẽ làm điều đó bằng cách sử dụng những gì bạn đã biết về mảng? Ví dụ: bạn có thể duyệt qua mảng số trong một vòng lặp và viết tuần tự các phần tử của nó vào numbersCopy :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];
      
       for (int i = 0; i < numbers.length; i++) {
          
           numbersCopy[i] = numbers[i];
       }

   }
}

Chà, uh, về cơ bản chúng ta đã hoàn thành nó ở đây! Có vẻ như chúng ta đã giải quyết được vấn đề. Tuy nhiên, nếu bạn cần làm điều này thường xuyên, mã của bạn sẽ có một loạt các vòng lặp giống hệt nhau. Trên thực tế, những nhiệm vụ này (và những nhiệm vụ khác) đã được những người tạo ra Java giải quyết từ lâu. Chúng ta không cần phải "phát minh lại bánh xe" và mã hóa giải pháp của riêng mình. Có một lớp tĩnh đặc biệt ( Arrays ) để giúp bạn thực hiện các tác vụ thông thường khi làm việc với mảng. Các phương pháp để thực hiện các nhiệm vụ phổ biến nhất mà các lập trình viên Java phải đối mặt đã được thêm vào lớp này. Ví dụ: nhiệm vụ sắp xếp một mảng mà chúng tôi đã cố xử lý được giải quyết trong một dòng:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
      
       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

Phương thức Arrays.sort () sắp xếp mảng. Và thuật toán của nó hiệu quả hơn nhiều so với mã chúng tôi đã viết. Đầu ra của bàn điều khiển: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Lưu ý: Để chuyển đổi mảng thành chuỗi, chúng tôi đã sử dụng một phương thức khác của lớp Arrays : Arrays.toString() . Mảng trong Java không tự ghi đè phương thức toString() . Vì vậy, nếu bạn chỉ đơn giản viết

System.out.println(numbers.toString());

toString() của lớp Object sẽ được gọi. Đối với một mảng, đầu ra sẽ giống như sau: [I@4554617c Bây giờ chúng ta sẽ không đi vào chi tiết về lý do chính xác đây là đầu ra. Điều chính là nó rõ ràng không phải là thứ chúng ta cần. Nhưng Arrays.toString() thực hiện chính xác những gì chúng ta muốn. Nhân tiện, việc sao chép cũng được thực hiện dễ dàng với lớp Arrays :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Chúng tôi chuyển đến phương thức Arrays.copyOf() mảng ban đầu của chúng tôi (từ đó chúng tôi muốn sao chép các giá trị) và độ dài của mảng mới mà chúng tôi đang sao chép dữ liệu. Trong trường hợp này, chúng tôi đã chỉ định numbers.length làm độ dài, vì muốn sao chép toàn bộ mảng. Nếu chúng ta chỉ muốn sao chép một vài phần tử đầu tiên, chúng ta có thể chỉ định độ dài của một mảng mới nhỏ hơn:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Ở đây chúng tôi đã chỉ định 4 là độ dài của mảng mới. Theo đó, chỉ 4 phần tử đầu tiên của số sẽ được sao chép sang mảng mới. Đầu ra của bàn điều khiển: [167, -2, 16, 99] Nhân tiện, Mảng cũng cho phép bạn sao chép một phần của mảng từ giữa thay vì phần đầu của mảng:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Đầu ra: [16, 99, 26, 92] Các số đã được sao chép vào mảng mới từ mảng thứ hai từ phần tử thứ hai (đã bao gồm) đến phần tử thứ sáu (không bao gồm). Chúng ta cũng có thể cần so sánh hai mảng. Như với phương thức toString() , bản thân các mảng không ghi đè lên phương thức equals() . Vì vậy, nếu chúng ta cố gắng so sánh chúng như thế này

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

sau đó chúng tôi nhận được sai. Điều này là do Object.equals() , so sánh các tham chiếu, sẽ được gọi. Và, rõ ràng, chúng khác nhau! Nhưng điều chúng ta cần là so sánh nội dung mảng, không phải tham chiếu. Lớp Arrays ghi đè phương thức equals() để làm cho nó thực hiện chính xác những gì chúng ta muốn:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Kết quả: true Nhân tiện, lớp Arrays không chỉ hoạt động với các mảng thông thường mà còn với các mảng hai chiều:

public class Main {

   public static void main(String[] args) {

       int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));
      
       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Kết quả: Các mảng hai chiều này có bằng nhau không? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Như bạn có thể thấy, phương thức Arrays.copyOf() có thể sao chép một mảng hai chiều. Và lớp này có các phương thức đặc biệt để so sánh và hiển thị các mảng hai chiều: deepEquals và deepToString() . Trong tương lai, bạn sẽ nhiều lần thấy (và vui mừng vì điều đó) rằng những người tạo ra Java đã lường trước được rất nhiều tình huống mà các lập trình viên thường gặp phải và triển khai các giải pháp làm sẵn cho họ bằng ngôn ngữ này. Sử dụng các giải pháp này dễ dàng và thuận tiện hơn nhiều so với việc phát minh lại bánh xe, phải không? :) Hãy nhớ đọc tài liệu về lớp Arrays trên trang web của Oracle . Chúc may mắn trong các nghiên cứu của bạn!