文章目录
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.多维数组
多维数组和二维数组套路用法一样。
使用代码演示多维数组的使用:
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类型数组,即使集合携带泛型。所以用如果使用无参方法会面临数据类型转换,相对更加麻烦。