文章目录
Java中的多维数组
1.二维数组
在Java中二维数组被看作数组的数组，数组中的每个元素也是数组。Java不支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。
（1）二维数组初始化
二维和一维数组一样，初始化的方式也一样。
// 在定义时初始化
type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n};
// 给定空间，在赋值
type[][] arrayName = new type[size1][size2];
// 数组第二维长度为空，可变化
type[][] arrayName = new type[size][];
演示：
用以上三种方式创建一个二行二列的二维数组，并且对数组的元素初始化。
int[][] temp = new int[][]{
{1,2},{3,4}};
int[][] temp = new int[2][2];
int[][] temp = new int[2][];
（2）获取单个元素
arrayName[i-1][j-1];
数组名【行数-1】【列数-1】
数组的下标起始值为 0，因此行和列的下标需要减 1
代码演示：
public class Main01 {
public static void main(String[] args) {
int[][] nums = {
{
1,2,3,4},{
10,20,30,40},{
100,200,300,400}};
System.out.println(nums[1][2]); //第二行第三列 30
}
}
（3）获取全部元素
如果使用循环遍历，则需要循环嵌套。最简单的则是俩层for循环嵌套。
public class Main01 {
public static void main(String[] args) {
int[][] nums = {
{
1,2,3,4},{
10,20,30,40},{
100,200,300,400}};
System.out.println(nums[1][2]); //第二行第三列 30
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
System.out.println(nums[i][j]);
}
}
System.out.println("------------------------------------");
for (int[] row : nums) {
for (int value : row) {
System.out.println(value);
}
}
}
}
2.多维数组
多维数组和二维数组套路用法一样。
使用代码演示多维数组的使用：
扫描二维码关注公众号，回复：
13304671 查看本文章
public class Main02 {
public static void main(String[] args) {
String[][][] names = {
{
{
"铠","木兰"}
},
{
{
"守约","玄策"}
},
{
{
"苏烈","伽罗"}
}
};
// 普通for循环进行遍历
for (int i = 0; i < names.length; i++) {
for (int j = 0; j < names[i].length; j++) {
for (int k = 0; k < names[i][j].length; k++) {
System.out.print(names[i][j][k] + ' ');
}
}
}
// 高级for循环遍历
System.out.println();
for (String[][] names_i: names) {
for (String[] names_j : names_i) {
for (String names_k : names_j) {
System.out.print(names_k + ' ');
}
}
}
}
}
运行结果：
铠 木兰 守约 玄策 苏烈 伽罗
铠 木兰 守约 玄策 苏烈 伽罗
Java中的多维集合
1.Java集合框架
集合中的常用类型方法等等可参考下面文章：
集合框架和泛型
2.多维集合的创建和遍历
多维集合的创建需要和泛型结合使用，必须要规定内外部集合要存储的数据类型。
注意事项：
- 当我们创建集合时规定了泛型，当使用高级for循环进行遍历时，必须明确规定临时变量的数据类型，例如下面代码中的二维集合，遍历外层则规定是ArrayList，内层遍历规定临时变量类型则是Integer。
- 在创建集合时最规范的写发如下
- ArrayList<ArrayList> nums = new ArrayList<ArrayList>();
- 也可以简写成如下格式：
- ArrayList<ArrayList> nums = new ArrayList<>();
案例1演示：
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int zushu = sc.nextInt();
ArrayList<ArrayList<Integer>> nums = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < zushu; i++) {
ArrayList<Integer> words = new ArrayList<Integer>();
for (int j = 0; j < 2; j++) {
words.add(sc.nextInt());
}
nums.add((ArrayList<Integer>) words);
}
//打印输出集合
System.out.println(nums);
//遍历集合
for (ArrayList<Integer> every_array : nums) {
//System.out.println(every_array);
int sum = 0;
for (Integer word : every_array) {
//System.out.println(word);
sum += word;
}
System.out.println(sum);
}
}
}
输入：2 1 2 10 20
执行结果入下：
2
1
2
10
20
[[1, 2], [10, 20]]
3
30
集合与数组之间的相互转化
1.数组转为集合
（1）遍历
代码演示：
public class Main03 {
public static void main(String[] args) {
int[] nums = {
1,2,3,4};
List<Integer> list = new ArrayList<Integer>();
for (Integer temp : nums) {
list.add(temp);
}
System.out.println(list);
}
}
运行结果如下：
[1, 2, 3, 4]
（2）使用数组工具类asList()方法
注意：使用该方法，如果传入的参数是一个数组，那找个数组必须是一个引用类型才能转换成List集合，如果传入基本类型数组，则会将这个数组当成一个引用类型对象存进List集合。
代码演示：
public class Main04 {
public static void main(String[] args) {
Integer[] array = {
1,2,3,4}; //引用类型数组
List list = Arrays.asList(array);
System.out.println(list);
}
}
运行结果：
[1, 2, 3, 4]
对比如下代码：
public class Main04 {
public static void main(String[] args) {
int[] array = {
1,2,3,4}; //基本类型数组
List list = Arrays.asList(array);
System.out.println(list);
}
}
运行结果：
[[I@723279cf]
我们发现当传入基本类型数组的时候，最后结果显示的是一个地址，不得行。所以我们要解决的问题时基本类型如何转换成引用类型。
但是也有特殊情况，如果我们要传入的数据不多时，可以直接将基本类型数据写入到asList()方法的括号当中，如下代码演示：
public class Main05 {
public static void main(String[] args) {
int num = 100;
String str = "Java";
double shuzi = 200.0;
//List<Object> list = Arrays.asList(num,str,shuzi);
List list = Arrays.asList(num,str,shuzi);
System.out.println(list);
}
}
运行结果如下：
[100, Java, 200.0]
基本类型数组转、包装类型数组、集合之间的相互转化
通过以上代码对比演示，发现asList()方法的局限性比较大，所以又出现一个问题，就是基本类型数组如何转化为引用类型数组。
了解什么是包装类、装箱、拆箱：Java内置包装类
代码演示：
public class ZhuanHuan{
public static void main(String[] args) {
//数组: int[]
int[] arrayInt = new int[]{
1,2,3,4,5,6};
printElement(arrayInt);
//原生数组转包装类数组: int[] 2 Integer[]
Integer[] arrayInter = Arrays.stream(arrayInt).boxed().toArray(Integer[]::new);
printElement(arrayInter);
//*包装类数组转List/ArrayList: Integer[] 2 List<Integer>
List<Integer> listInter = Arrays.asList(arrayInter);
printElement(listInter);
//*List/ArrayList转包装类数组: List<Integer> 2 Integer[]
Integer[] arrayInter2 = listInter.toArray(new Integer[listInter.size()]);
printElement(arrayInter2);
//包装类数组转原生数组: Integer[] 2 int[]
int[] arrayInt2 = Arrays.stream(arrayInter2).mapToInt(Integer::valueOf).toArray();
printElement(arrayInt2);
//原生数组转List/ArrayList: int[] 2 List<Integer>
List<Integer> listInter2 = Arrays.stream(arrayInt2).boxed().collect(Collectors.toList());
printElement(listInter2);
//List/ArrayList转原生数组： List<Integer> 2 int[]
int[] arrayInt3 = listInter2.stream().mapToInt(Integer::valueOf).toArray();
printElement(arrayInt3);
}
}
2.集合转为数组
（1）遍历
代码演示：
public class Main06 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println("list：" + list);
Integer[] arrays = new Integer[list.size()];
for (int i = 0; i < list.size(); i++) {
arrays[i] = list.get(i);
}
System.out.println("arrays：" + Arrays.toString(arrays));
for (int i = 0; i < arrays.length; i++) {
System.out.println("arrays第" + i + "个元素是：" + arrays[i]);
}
}
}
运行结果如下：
list：[1, 2, 3, 4]
arrays：[1, 2, 3, 4]
arrays第0个元素是：1
arrays第1个元素是：2
arrays第2个元素是：3
arrays第3个元素是：4
（2）使用集合的toArray()方法
代码演示：
public class main07 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
// 方式一
Integer[] arrays = new Integer[list.size()];
list.toArray(arrays);
System.out.println("arrays：" + Arrays.toString(arrays));
// 方式二
Integer[] arrays_00 = list.toArray(new Integer[0]);
System.out.println("arrays_00：" + Arrays.toString(arrays_00));
}
}
运行结果如下：
arrays：[1, 2, 3, 4]
arrays_00：[1, 2, 3, 4]
注意：
使用toArray()是要注意，有参方法和无参方法，一般都选择使用有参方法，无参方法返回的是一个Object类型数组，即使集合携带泛型。所以用如果使用无参方法会面临数据类型转换，相对更加麻烦。