Posted incompare

How To Compare Arrays In Java: A Comprehensive Guide

No Comments

Are you struggling with how to compare arrays in Java efficiently and accurately? At COMPARE.EDU.VN, we provide a detailed exploration of various methods for array comparison in Java, ensuring you can choose the best approach for your specific needs. This guide covers conventional methods, lambda expressions, and advanced techniques, offering a comprehensive understanding of array comparison.

1. Understanding Array Comparison in Java

Arrays in Java, being objects, require a nuanced understanding for effective comparison. Key concepts include object references, values, and the distinctions between primitive and object types.

1.1 Object References vs. Values

In Java, objects are handled by reference. Understanding this distinction is crucial when comparing arrays.

  • Objects Have References and Values: When comparing objects (including arrays), it’s essential to differentiate between comparing the object references themselves and comparing the actual values stored within the objects.

  • Equal References Point to the Same Value: If two references are equal, they point to the same object in memory. This means any changes made through one reference will be reflected in the other.

  • Different Values Have Different References: Generally, if two objects have different values, they reside in different memory locations and have different references.

  • Equal Values, Different References: Two objects can have the same values but still have different references, meaning they are distinct objects in memory.

  • Primitive Values Compared Directly: Primitive types (e.g., int, boolean) are compared by their actual values, not by reference.

  • String Literals Compared by Value: String literals are a special case where the == operator compares the content, not the reference (due to string interning).

1.2 Why This Matters for Arrays

Arrays, being objects, follow these rules. Comparing arrays directly with == checks if the references are the same, not if the contents are identical.

2. Methods for Comparing Arrays in Java

Java provides several ways to compare arrays, each with its specific use case. Let’s explore these methods in detail.

2.1 Comparing Object References with ==

The == operator checks if two array references point to the same object in memory.

  • When to Use: This method is useful when you want to determine if two variables are pointing to the exact same array instance.

  • Example:

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = planes1; // planes2 now references the same array as planes1

System.out.println(planes1 == planes2); // Output: true

  • Explanation: In this example, planes2 is assigned the same reference as planes1. Thus, planes1 == planes2 evaluates to true because they both point to the same array in memory.

  • Caveat: This does not compare the contents of the arrays. If two arrays have the same elements but are different instances, == will return false.

2.1.1 Verifying Reference Identity

To further verify that two references point to the same array, you can use assertion methods like isSameAs (from AssertJ library) in unit tests.

import static org.assertj.core.api.Assertions.assertThat;

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = planes1;

assertThat(planes1).isSameAs(planes2); // Assertion passes: planes1 and planes2 are the same object

2.1.2 Impact of Modifying References

When two references point to the same array, modifying the array through one reference affects the other.

planes2[0] = "747"; // Modify the array through planes2

System.out.println(planes1[0]); // Output: 747 (planes1 is also modified)

2.1.3 Comparing Different Array Instances

If two arrays are created as separate instances, even with the same content, == will return false.

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = new String[] { "A320", "B738", "A321" };

System.out.println(planes1 == planes2); // Output: false (different instances)

2.2 Comparing Array Lengths

Comparing the lengths of arrays is a basic but essential step in many comparison scenarios.

  • When to Use: This is useful when you need to ensure that two arrays have the same number of elements before proceeding with more detailed comparisons.
  • Example:
final String[] planes1 = new String[] { "A320", "B738", "A321" };
final Integer[] quantities = new Integer[] { 10, 12, 34 };

System.out.println(planes1.length == quantities.length); // Output: true
  • Explanation: This code compares the length property of two arrays. The result is true because both arrays have three elements.

2.2.1 Using Assertion for Array Size

You can use assertion libraries like AssertJ to check the size of arrays in unit tests.

import static org.assertj.core.api.Assertions.assertThat;

final String[] planes1 = new String[] { "A320", "B738", "A321" };
final Integer[] quantities = new Integer[] { 10, 12, 34 };

assertThat(planes1).hasSize(3); // Assertion passes: planes1 has size 3
assertThat(quantities).hasSize(3); // Assertion passes: quantities has size 3

2.2.2 Relevance of Array Length

The length of an array can be compared regardless of the element types or whether the values are filled. This makes it a versatile check for array compatibility.

final String[] planes1 = new String[] { "A320", "B738", "A321" };
final Integer[] quantities = new Integer[] { 10, 12, 34 };

System.out.println(planes1.length == quantities.length); // Output: true

2.3 Comparing Array Content with Arrays.equals()

The Arrays.equals() method compares the contents of two arrays element by element.

  • When to Use: This is the primary method for determining if two arrays have the same elements in the same order.
  • Example:
import java.util.Arrays;

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = new String[] { "A320", "B738", "A321" };

System.out.println(Arrays.equals(planes1, planes2)); // Output: true
  • Explanation: The Arrays.equals() method iterates through both arrays, comparing elements at each index using the == operator for primitive types or the equals() method for objects.

2.3.1 Element-wise Comparison

Arrays.equals() performs a pair-wise comparison. The arrays must have the same length, and each corresponding element must be equal.

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = new String[] { "B738", "A320", "A321" }; // Different order

System.out.println(Arrays.equals(planes1, planes2)); // Output: false

2.3.2 Using Assertions with Arrays.equals()

Assertions can be used to confirm that arrays are equal based on their contents.

import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = new String[] { "A320", "B738", "A321" };

assertThat(Arrays.equals(planes1, planes2)).isTrue(); // Assertion passes: arrays are equal

2.3.3 Handling Different Orders

Arrays.equals() considers the order of elements. If the elements are the same but in a different order, the method will return false.

String[] planes1 = new String[] { "A320", "B738", "A321" };
String[] planes2 = new String[] { "B738", "A320", "A321" }; // Different order

assertThat(Arrays.equals(planes1, planes2)).isFalse(); // Assertion passes: arrays are not equal

2.4 Comparing Multi-Dimensional Arrays with Arrays.deepEquals()

For multi-dimensional arrays (arrays of arrays), Arrays.equals() only compares the references of the inner arrays, not their contents. To compare the contents of multi-dimensional arrays, you need to use Arrays.deepEquals().

  • When to Use: This method is essential when you need to compare the contents of nested arrays.
  • Example:

First, let’s start with a Plane class:

public class Plane {
    private final String name;
    private final String model;

    public Plane(String name, String model) {
        this.name = name;
        this.model = model;
    }

    public String getName() {
        return name;
    }

    public String getModel() {
        return model;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Plane plane = (Plane) o;
        return Objects.equals(name, plane.name) && Objects.equals(model, plane.model);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, model);
    }
}

Then, let’s create the following two-element arrays:

import java.util.Arrays;
import java.util.Objects;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        Plane[][] planes1 = new Plane[][] {
                new Plane[]{new Plane("Plane 1", "A320")},
                new Plane[]{new Plane("Plane 2", "B738")}
        };

        Plane[][] planes2 = new Plane[][] {
                new Plane[]{new Plane("Plane 1", "A320")},
                new Plane[]{new Plane("Plane 2", "B738")}
        };

        System.out.println(Arrays.deepEquals(planes1, planes2)); // Output: true
    }
}
  • Explanation: Arrays.deepEquals() recursively compares the contents of nested arrays. In this example, it compares the Plane objects inside the two-dimensional arrays.

2.4.1 Deep Comparison of Objects

Arrays.deepEquals() relies on the equals() method of the objects within the arrays. It’s crucial that these objects have a properly implemented equals() method.

import java.util.Arrays;
import java.util.Objects;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        Plane[][] planes1 = new Plane[][] {
                new Plane[]{new Plane("Plane 1", "A320")},
                new Plane[]{new Plane("Plane 2", "B738")}
        };

        Plane[][] planes2 = new Plane[][] {
                new Plane[]{new Plane("Plane 2", "B738")},
                new Plane[]{new Plane("Plane 1", "A320")}
        };

        System.out.println(Arrays.deepEquals(planes1, planes2)); // Output: false
    }
}

2.4.2 Importance of equals() and hashCode()

When using Arrays.deepEquals() with custom objects, ensure that the equals() and hashCode() methods are correctly implemented to reflect the equality logic.

2.4.3 Using Assertions with Arrays.deepEquals()

Assertions can be used to verify the deep equality of multi-dimensional arrays.

import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Objects;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        Plane[][] planes1 = new Plane[][] {
                new Plane[]{new Plane("Plane 1", "A320")},
                new Plane[]{new Plane("Plane 2", "B738")}
        };

        Plane[][] planes2 = new Plane[][] {
                new Plane[]{new Plane("Plane 1", "A320")},
                new Plane[]{new Plane("Plane 2", "B738")}
        };

        assertThat(Arrays.deepEquals(planes1, planes2)).isTrue(); // Assertion passes: arrays are deeply equal
    }
}

2.5 Comparing Arrays with Different Orders of Elements

To compare arrays irrespective of the order of elements, you need to sort the arrays first.

  • When to Use: This is useful when the order of elements is not important, and you only care about whether the arrays contain the same elements.
  • Example:
import java.util.Arrays;
import java.util.Comparator;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        String[] planes1 = new String[] { "A320", "B738", "A321" };
        String[] planes2 = new String[] { "B738", "A321", "A320" };

        Arrays.sort(planes1);
        Arrays.sort(planes2);

        System.out.println(Arrays.equals(planes1, planes2)); // Output: true
    }
}
  • Explanation: This code sorts both arrays using Arrays.sort() before comparing them using Arrays.equals(). This ensures that the order of elements does not affect the comparison result.

2.5.1 Custom Sorting with Comparator

For custom objects, you can use a Comparator to define the sorting logic.

import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        Plane[] planes1 = new Plane[] {
                new Plane("Plane 1", "A320"),
                new Plane("Plane 2", "B738")
        };

        Plane[] planes2 = new Plane[] {
                new Plane("Plane 2", "B738"),
                new Plane("Plane 1", "A320")
        };

        Comparator<Plane> planeComparator = Comparator.comparing(Plane::getName).thenComparing(Plane::getModel);

        Arrays.sort(planes1, planeComparator);
        Arrays.sort(planes2, planeComparator);

        System.out.println(Arrays.deepEquals(new Plane[][]{planes1}, new Plane[][]{planes2})); // Output: true
    }

    static class Plane {
        private final String name;
        private final String model;

        public Plane(String name, String model) {
            this.name = name;
            this.model = model;
        }

        public String getName() {
            return name;
        }

        public String getModel() {
            return model;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Plane plane = (Plane) o;
            return Objects.equals(name, plane.name) && Objects.equals(model, plane.model);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, model);
        }
    }
}

2.5.2 Sorting and Deep Comparison

After sorting, you can use Arrays.deepEquals() to perform a deep comparison of the arrays.

2.5.3 Using Assertions with Sorting

Assertions can be used to verify that arrays are equal after sorting.

import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Comparator;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        String[] planes1 = new String[] { "A320", "B738", "A321" };
        String[] planes2 = new String[] { "B738", "A321", "A320" };

        Arrays.sort(planes1);
        Arrays.sort(planes2);

        assertThat(Arrays.equals(planes1, planes2)).isTrue(); // Assertion passes: arrays are equal after sorting
    }
}

2.6 Comparing Arrays Lexicographically with Arrays.compare()

Java 9 introduced the Arrays.compare() method, which allows you to compare two arrays lexicographically.

  • When to Use: This method is useful when you need to compare arrays based on the natural order of their elements, such as numerical or alphabetical order.
  • Example:
import java.util.Arrays;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        String[] array1 = new String[] { "A", "B", "C" };
        String[] array2 = new String[] { "A", "B", "C" };

        System.out.println(Arrays.compare(array1, array2)); // Output: 0 (arrays are equal)
    }
}
  • Explanation: Arrays.compare() compares the elements of the arrays element by element. If the arrays are equal, it returns 0.

2.6.1 Lexicographic Comparison

Lexicographic comparison refers to the natural order of elements. For strings, it’s alphabetical order; for numbers, it’s numerical order.

import java.util.Arrays;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        String[] array1 = new String[] { "A", "B", "C", "D" };
        String[] array2 = new String[] { "A", "C", "B" };

        System.out.println(Arrays.compare(array1, array2)); // Output: -1 (array1 is lexicographically smaller than array2)
        System.out.println(Arrays.compare(array2, array1)); // Output: 1 (array2 is lexicographically greater than array1)
    }
}

2.6.2 Handling Different Lengths

If the arrays have different lengths, the shorter array is considered a proper prefix of the longer array.

import java.util.Arrays;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        String[] array1 = new String[] { "A", "B", "C" };
        String[] array2 = new String[] { "A", "B" };

        System.out.println(Arrays.compare(array1, array2)); // Output: 1 (array1 is lexicographically greater than array2)
    }
}

2.6.3 Null Handling

A null array is always lexicographically less than a non-null array.

import java.util.Arrays;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        String[] array1 = new String[] { "A", "B", "C" };
        String[] array2 = null;

        System.out.println(Arrays.compare(array1, array2)); // Output: 1 (array1 is lexicographically greater than array2)
    }
}

2.6.4 Overloaded Versions

The Arrays class offers several overloaded compare() versions for comparing arrays holding primitive data types such as boolean, byte, char, and int.

import java.util.Arrays;

public class ArrayComparisonExample {

    public static void main(String[] args) {
        int[] array1 = new int[] { 1, 2, 3 };
        int[] array2 = new int[] { 1, 2, 4 };

        System.out.println(Arrays.compare(array1, array2)); // Output: -1 (array1 is lexicographically smaller than array2)
    }
}

2.7 Summary Table: Comparing Java Array Comparison Methods

Method Description Compares Considers Order Handles Multi-Dimensional Arrays Requires Custom equals() Primitive Type Support
== Checks if two array references point to the same object. Object references Yes No No Yes
Arrays.equals() Compares the contents of two arrays element by element. Contents of arrays Yes No Yes Yes
Arrays.deepEquals() Compares the contents of multi-dimensional arrays recursively. Contents of nested arrays Yes Yes Yes Yes
Sorting + Arrays.equals() Compares arrays irrespective of the order of elements (after sorting). Contents of arrays after sorting No No Yes Yes
Arrays.compare() Compares two arrays lexicographically based on the natural order of elements. Elements based on their natural order (numerical/alphabetical) Yes No No Yes

3. Practical Examples and Use Cases

To solidify your understanding, let’s walk through some practical examples and use cases for array comparison in Java.

3.1 Verifying Data Integrity

One common use case is verifying the integrity of data stored in arrays. For example, you might receive data from an external source and need to ensure it matches your expected values.

import java.util.Arrays;

public class DataIntegrityExample {

    public static void main(String[] args) {
        String[] expectedData = new String[] { "A320", "B738", "A321" };
        String[] receivedData = new String[] { "A320", "B738", "A321" };

        if (Arrays.equals(expectedData, receivedData)) {
            System.out.println("Data integrity verified: Data matches expected values.");
        } else {
            System.out.println("Data integrity check failed: Data does not match expected values.");
        }
    }
}

3.2 Comparing Test Results

In testing, you often need to compare the actual output of a function or method with the expected output. Arrays are commonly used to store and compare these results.

import java.util.Arrays;

public class TestResultExample {

    public static void main(String[] args) {
        int[] expectedResults = new int[] { 1, 2, 3, 4, 5 };
        int[] actualResults = new int[] { 1, 2, 3, 4, 5 };

        if (Arrays.equals(expectedResults, actualResults)) {
            System.out.println("Test passed: Actual results match expected results.");
        } else {
            System.out.println("Test failed: Actual results do not match expected results.");
        }
    }
}

3.3 Checking for Data Consistency in Databases

When working with databases, you may need to compare data retrieved from different tables or sources to ensure consistency. Arrays can be used to store and compare these datasets.

import java.util.Arrays;

public class DatabaseConsistencyExample {

    public static void main(String[] args) {
        String[] dataFromTable1 = new String[] { "A320", "B738", "A321" };
        String[] dataFromTable2 = new String[] { "A320", "B738", "A321" };

        if (Arrays.equals(dataFromTable1, dataFromTable2)) {
            System.out.println("Data consistency verified: Data in both tables match.");
        } else {
            System.out.println("Data consistency check failed: Data in tables do not match.");
        }
    }
}

3.4 Implementing Custom Data Structures

When implementing custom data structures, such as sets or bags, you may need to compare arrays to check for equality or containment.

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class CustomSetExample {

    public static void main(String[] args) {
        String[] array1 = new String[] { "A320", "B738", "A321" };
        String[] array2 = new String[] { "B738", "A321", "A320" };

        Set<String> set1 = new HashSet<>(Arrays.asList(array1));
        Set<String> set2 = new HashSet<>(Arrays.asList(array2));

        if (set1.equals(set2)) {
            System.out.println("The arrays contain the same elements, regardless of order.");
        } else {
            System.out.println("The arrays do not contain the same elements.");
        }
    }
}

3.5 Real-World Scenario: Inventory Management System

Consider an inventory management system where you need to compare the expected stock levels with the actual stock levels recorded in the system.

import java.util.Arrays;

public class InventoryManagementExample {

    public static void main(String[] args) {
        String[] expectedStock = new String[] { "Laptop", "Keyboard", "Mouse", "Monitor" };
        String[] actualStock = new String[] { "Laptop", "Keyboard", "Mouse", "Monitor" };

        if (Arrays.equals(expectedStock, actualStock)) {
            System.out.println("Inventory check passed: Stock levels match expected levels.");
        } else {
            System.out.println("Inventory check failed: Stock levels do not match expected levels.");
        }
    }
}

These examples illustrate how array comparison is used in various practical scenarios to ensure data integrity, validate test results, maintain database consistency, and implement custom data structures.

4. Best Practices for Array Comparison in Java

To ensure efficient and accurate array comparisons, consider the following best practices:

  1. Choose the Right Method: Select the appropriate method based on your comparison needs. Use == for reference comparison, Arrays.equals() for content comparison, Arrays.deepEquals() for multi-dimensional arrays, and sorting combined with Arrays.equals() for order-insensitive comparison.
  2. Implement equals() and hashCode(): When comparing arrays of custom objects, ensure that the equals() and hashCode() methods are correctly implemented to reflect the equality logic.
  3. Consider Performance: Be mindful of the performance implications of different comparison methods. Sorting arrays before comparison can be time-consuming for large datasets.
  4. Handle Null Values: Properly handle null values to avoid NullPointerExceptions. Use null checks before performing comparisons.
  5. Use Assertions: Use assertions in unit tests to verify the correctness of array comparisons.
  6. Document Your Code: Clearly document your code to explain the purpose and logic of array comparisons.

5. Common Pitfalls and How to Avoid Them

When comparing arrays in Java, there are several common pitfalls that developers often encounter. Here’s how to avoid them:

  1. Using == for Content Comparison:

    • Pitfall: Using the == operator to compare the contents of arrays instead of their references.
    • Solution: Use Arrays.equals() for single-dimensional arrays and Arrays.deepEquals() for multi-dimensional arrays to compare their contents.

  2. Not Implementing equals() and hashCode() for Custom Objects:

    • Pitfall: When comparing arrays of custom objects, failing to implement the equals() and hashCode() methods in the custom class.
    • Solution: Implement these methods to define the equality logic for your objects, ensuring that Arrays.equals() and Arrays.deepEquals() can correctly compare the array contents.

  3. Ignoring the Order of Elements:

    • Pitfall: Assuming that Arrays.equals() will return true even if the elements are in a different order.
    • Solution: If the order of elements is not important, sort the arrays before comparing them using Arrays.sort() in conjunction with Arrays.equals().

  4. Not Handling Null Values:

    • Pitfall: Failing to handle null values when comparing arrays, which can lead to NullPointerExceptions.
    • Solution: Add null checks before performing comparisons to avoid exceptions.

  5. Performance Issues with Large Arrays:

    • Pitfall: Using inefficient comparison methods for large arrays, which can lead to performance bottlenecks.
    • Solution: Consider the performance implications of different comparison methods and choose the most efficient one for your use case. For example, sorting large arrays before comparison can be time-consuming.

  6. Incorrectly Comparing Multi-Dimensional Arrays:

    • Pitfall: Using Arrays.equals() to compare multi-dimensional arrays, which only compares the references of the inner arrays, not their contents.
    • Solution: Use Arrays.deepEquals() to recursively compare the contents of multi-dimensional arrays.

By being aware of these common pitfalls and following the recommended solutions, you can avoid errors and ensure accurate array comparisons in your Java code.

6. Frequently Asked Questions (FAQ)

Q1: What is the difference between == and Arrays.equals() in Java?

  • == compares object references to see if they point to the same object in memory. Arrays.equals() compares the contents of two arrays to see if they contain the same elements in the same order.

Q2: How do I compare multi-dimensional arrays in Java?

  • Use Arrays.deepEquals() to compare the contents of multi-dimensional arrays recursively.

Q3: How do I compare arrays without considering the order of elements?

  • Sort the arrays using Arrays.sort() and then compare them using Arrays.equals().

Q4: What is lexicographical comparison of arrays?

  • Lexicographical comparison refers to comparing arrays based on the natural order of their elements, such as numerical or alphabetical order.

Q5: How do I compare arrays lexicographically in Java?

  • Use Arrays.compare() to compare two arrays lexicographically based on the natural order of their elements.

Q6: How do I handle null values when comparing arrays in Java?

  • Add null checks before performing comparisons to avoid NullPointerExceptions.

Q7: Why do I need to implement equals() and hashCode() when comparing arrays of custom objects?

  • The equals() method defines the equality logic for your objects, and hashCode() is used to generate a hash code for the object. These methods are necessary for Arrays.equals() and Arrays.deepEquals() to correctly compare the array contents.

Q8: What is the best method for comparing large arrays in Java?

  • The best method depends on your specific needs. If the order of elements is important, Arrays.equals() is the most efficient method. If the order is not important, sorting the arrays before comparison can be time-consuming for large datasets.

Q9: Can I use lambda expressions to compare arrays in Java?

  • Yes, you can use lambda expressions to define custom comparison logic when sorting arrays using Arrays.sort() with a Comparator.

Q10: What is the significance of array length in array comparison?

  • The length of the arrays must be the same for methods like Arrays.equals() to return true. Comparing array lengths is a basic check to ensure that the arrays are compatible for further comparison.

7. Conclusion

Comparing arrays in Java involves understanding the nuances of object references, equality checks, and the various methods available in the Arrays class. By mastering these concepts, you can write robust and efficient code that accurately compares arrays based on your specific needs.

At COMPARE.EDU.VN, we strive to provide comprehensive guides and resources to help you navigate the complexities of software development. Whether you’re a student, a seasoned professional, or just someone looking to expand your knowledge, we’re here to support you on your journey.

Ready to make smarter decisions? Visit COMPARE.EDU.VN today and explore detailed comparisons to help you choose the best options for your needs. From software solutions to educational resources, we’ve got you covered.

COMPARE.EDU.VN – Your trusted source for unbiased comparisons.

Contact Us:

  • Address: 333 Comparison Plaza, Choice City, CA 90210, United States
  • WhatsApp: +1 (626) 555-9090
  • Website: compare.edu.vn

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *