1. Overview
1.概述
In this tutorial, we’ll get familiar with some ways to print 2D arrays, along with their time and space complexity.
在本教程中，我们将熟悉一些打印 二维数组的方法，以及它们在时间和空间上的复杂性。
2. Common Ways to Print a 2D Array
2.打印二维数组的常见方法
Java, a versatile programming language, offers multiple methods for handling and manipulating arrays. Specifically, 2D arrays provide a convenient way to organize and store data in a grid-like structure. Printing a 2D array constitutes a common operation, and Java presents several approaches to accomplish this task.
Java 作为一种通用编程语言，提供了多种处理和操作数组的方法。具体来说，二维数组提供了一种以网格状结构组织和存储数据的便捷方法。打印二维数组是一种常见的操作，Java 提供了多种方法来完成这项任务。
2.1. Using Nested Loops
2.1.使用嵌套循环
The most straightforward method involves using nested loops to iterate through the rows and columns of the 2D array. This method is simple and intuitive, making it an excellent choice for basic array printing. Let’s look into the implementation:
最直接的方法是使用嵌套循环遍历二维数组的行和列。这种方法简单直观，是基本数组打印的绝佳选择。让我们来看看具体的实现方法：
int[][] myArray = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
for (int i = 0; i < myArray.length; i++) {
for (int j = 0; j < myArray[i].length; j++) {
System.out.print(myArray[i][j] + " ");
}
}Advantages:
优势
- Simple and easy to understand
- Doesn’t necessitate extra libraries or functionalities
Disadvantages:
缺点
- If prioritizing code brevity, this may not be the optimal selection
Time Complexity: O(m * n), where ‘m’ is the number of rows and ‘n’ is the number of columns in the 2D array
时间复杂性：O(m*n)，其中 “m “是二维数组的行数，”n “是列数
Space Complexity: O(1), constant space as no additional data structures are used
空间复杂性：O(1)，空间不变，因为不使用额外的数据结构
2.2. Using Arrays.deepToString()
2.2.使用 Arrays.deepToString() <br
For simplicity and conciseness, Java provides the Arrays.deepToString() method, which enables printing 2D arrays directly. This method manages nested arrays and furnishes a compact representation of the array contents. Let’s delve into the implementation:
为了简单明了，Java 提供了 Arrays.deepToString() 方法，可以直接打印二维数组。该方法可管理嵌套数组，并提供数组内容的简洁表示：
int[][] myArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
System.out.println(Arrays.deepToString(myArray));Advantages:
优势
- Offers conciseness and demands minimal code
- Appropriate for swift debugging or when accepting a compact output format
Disadvantages:
缺点
- Generates a new string representation of the entire array, potentially less efficient in terms of space complexity for very large arrays
- Lacks control over the array’s formatting and depends on the implementation of the toString
Time Complexity: O(m * n)
时间复杂性：O(m * n)
Space Complexity: O(m * n), due to the creation of a new string representation of the entire 2D array
空间复杂度：O(m*n)，因为要为整个二维数组创建新的字符串表示法
2.3. Using Java 8 Streams
2.3.使用 Java 8 流
For a more modern approach, Java 8 introduced streams, allowing concise and expressive code. The Arrays.stream() method can be employed to flatten the 2D array, and then forEach() is used to print the elements. Let’s look into the implementation:
对于更现代的方法，Java 8 引入了流，允许编写简洁而富有表现力的代码。可以使用 Arrays.stream() 方法来扁平化二维数组，然后使用 forEach() 来打印元素：
int[][] myArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
Arrays.stream(myArray)
.flatMapToInt(Arrays::stream)
.forEach(num -> System.out.print(num + " "));Advantages:
优势
- Embraces modernity and expressiveness
- Employs concise code that utilizes Java 8 features
Disadvantages:
缺点
- May be deemed more advanced and could be less readable for individuals unfamiliar with Java 8 streams
Time Complexity: O(m * n)
时间复杂性：O(m * n)
Space Complexity: O(1), constant space as no additional data structures are used
空间复杂性：O(1)，空间不变，因为不使用额外的数据结构
2.4. Using Arrays.toString()
2.4.使用 Arrays.toString()
This method is used to convert each row of the 2D array into a string representation and then print each row. This approach provides a clean and concise output. Let’s look into the implementation:
该方法用于将二维数组的每一行转换为字符串表示，然后打印每一行。这种方法提供了简洁明了的输出。让我们来了解一下实现方法：
int[][] myArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
for (int[] row : myArray) {
System.out.print(Arrays.toString(row));
}Advantages:
优势
- Does not create additional data structures like lists or streams, resulting in a more memory-efficient solution
- Straightforward implementation, requiring minimal code to achieve the desired output
Disadvantages:
缺点
- It generates a new string representation of each row, which might be less efficient in terms of space complexity for arrays with a large number of columns.
- We lack control over how the array is formatted, and it depends on the implementation of the toString method of the elements.
Time Complexity: O(m * n)
时间复杂性：O(m * n)
Space Complexity: O(n), due to the creation of a new string representation of each row
空间复杂度：O(n)，因为要为每一行创建一个新的字符串表示法
It’s important to note that all these approaches have a time complexity of O(m * n) because to print the entire 2D array, we must visit each element at least once. The space complexity varies slightly based on whether we create additional data structures, such as strings for representation. In general, these complexities are quite reasonable for typical use cases, and the choice of method can depend on factors like code readability, simplicity, and specific project requirements.
值得注意的是，所有这些方法的时间复杂度都是 O(m * n)，因为要打印整个二维数组，我们必须对每个元素至少访问一次。空间复杂度则根据我们是否创建额外的数据结构（如用于表示的字符串）而略有不同。一般来说，这些复杂度对于典型用例来说是相当合理的，而方法的选择可能取决于代码的可读性、简洁性和特定项目要求等因素。
3. Conclusion
3.结论
In conclusion, the choice of the “best” approach depends on your specific requirements and coding preferences. For most general use cases, the nested loops approach strikes a good balance between simplicity and efficiency. However, for scenarios where conciseness or customization is a priority, other methods might be more suitable. Java offers flexibility to meet the diverse needs of developers. Choose the method that best fits your coding style and the requirements of your project.
总之，”最佳 “方法的选择取决于您的具体要求和编码偏好。对于大多数一般用例，嵌套循环方法在简单性和效率之间取得了良好的平衡。但是，对于优先考虑简洁性或定制的场景，其他方法可能更适合。Java 提供了灵活性，可满足开发人员的不同需求。选择最适合您的编码风格和项目要求的方法。
As usual, the source code for all of these examples is available over on GitHub.
与往常一样，所有这些示例的源代码均可在 GitHub 上获取。