二维数组(Dyadic Array)
一维数组 : 数组中直接存放数据
二维数组 : 数组中存放数组
二维数组可以看成以数组为元素的数组。就是一个特殊的一维数组,其每一个元素都是一个一维数组
String[][] str = new String[3][4];//String类型二维数组举例
其实多维数组不仅仅只有二维数组,还有三维数组,四维数组…, 但是三维以上很少见到,所以大家重点了解二维数组即可.
1.举例
int [][] a = {{1,2},{3,4,0,9},{5,6,7}};
2.二维数组的声明
数据类型 变量名; -->变量声明
数据类型[] 数组名; -->一维数组声明
数据类型[][] 数组名; -->二维数组声明
3.二维数组的初始化
3.1.动态初始化
数组定义与为数组元素分配空间和赋值的操作分开进行
数据类型[][] 数组名 = new 数据类型[一维][二维];
注意:这种初始化方式,每一个内层的二位数组长度相同
int[][] a=new int[3][2]; a[0][0] = 1; a[0][1] = 2;
动态初始化 : 创建二维数组的同时赋值(内部一维数组创建+每一个一维数组中的数据)
创建外层二维数组同时创建内层每一个一维刷组+没有赋值数据,存在默认值
数据类型[][] 数组名 = new 数据类型[外层二维数组长度][内层一维数组长度];
创建外层二维数组,内层每一个一维数组在后续确定时单独创建+赋值数据
数据类型[][] 数组名 = new 数据类型[外层二维数组长度][];
int[][] a=new int[3][];
arr[0]=new int[2];
arr[1]=new int[]{3,4,5,6};
arr[2]=new int[]{7,8,9};
arr[0][0] = 1;
arr[0][1] = 2;
3.2.静态初始化
在定义数组的同时就为数组元素分配空间并赋值
数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
数据类型[][] 数组名 = {{...},{...},{...}}; --简化写法
int[][] arr1=new int[][]{{5,4,8},{3,8},{1}};
char[][] arr2={{'a'},{'b','c'}};
4.二维数组的使用
- 根据索引进行使用
- 数组数组名 [外层二维索引] [内层一维索引]
4.1.数组的遍历
双重循环实现多维数组的遍历
/* 二维数组的遍历方式 : 1.for 2.foreach 以上两种循环任意嵌套 */ public class ArrayTest { public static void main(String[] args) { int[][] arr = {{1,2,3},{4,5},{6}}; // for循环嵌套加强for //for-->foreach for(int i=0;ipublic class AraayEachTest { public static void main(String[] args) { int[][] arr = {{1,2,3},{4,5},{6,7}}; //for嵌套for for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.println(arr[i][j]); } } //System.out.println(Arrays.deepToString(arr));//返回指定数组内容的字符串表示形式。 //for 嵌套each for (int i = 0; i < arr.length; i++) { for (int a:arr[i] ) { System.out.println(a); } } // //each 嵌套each // for (int[] a:arr // ) {// for (int b:a // ) {// System.out.println(b); // } // } // //each 嵌套for // for (int[] i:arr // ) {// for (int j = 0; j < i.length; j++) {// System.out.println(i[j]); // } // } } }Arrays中提供操作多维数组的方法:
package com.arraytest; import java.util.Arrays;//它提供的所有方法都是静态的。 public class AraayEachTest { public static void main(String[] args) { int[][] arr = {{1,2,3},{4,5},{6,7}}; int[][] arr2 = {{1,2,3},{4,5},{6,7}}; int[][] arr1 = {{1,2,3},{4,5},{6,7}}; int[] arr3 = {3,1,5,8,9}; System.out.println(arr1);//打印对象地址 System.out.println(Arrays.deepToString(arr1));//返回指定数组的“深层内容”的字符串表示形式 System.out.println(arr== arr2);//false 地址不一样 System.out.println(Arrays.equals(arr,arr2));//false System.out.println(Arrays.deepEquals(arr,arr2));//如果两个数组彼此深度相等，则返回 true //将数组升序排序 System.out.println(Arrays.toString(arr3)); Arrays.sort(arr3); System.out.println(Arrays.toString(arr3)); //二进制搜索指定值 System.out.println(Arrays.binarySearch(arr3,8));//数值8在下标3的位置 System.out.println(Arrays.binarySearch(arr3,10));//-6如果不存在,返回 -插入点-1 System.out.println(Arrays.binarySearch(arr3,100));//-6 } }import java.lang.reflect.Array; import java.util.Arrays; /* Arrays : 该类包含用于操作数组的各种方法（例如排序和搜索）。 java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有但不限于以下功能: 给数组赋值：通过fill方法。 对数组排序：通过sort方法,按升序。 比较数组：通过equals方法比较数组中元素值是否相等。 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。 */ public class Class001_Arrays { public static void main(String[] args) { int[] arr1 ={3,1,5,2,4}; int[] arr2 ={3,1,5,2,4}; int[] arr5 ={13,1,5,2,14}; int[][] arr3 = {{1,2,3},{4,5},{6}}; int[][] arr4 = {{1,2,3},{4,5},{6}}; //static String toString(int[] a) 返回指定数组内容的字符串表示形式。 System.out.println(Arrays.toString(arr1)); System.out.println(Arrays.toString(arr3)); //static String deepToString(Object[] a) 返回指定数组的“深层内容”的字符串表示形式。 System.out.println(Arrays.deepToString(arr3)); //static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。 System.out.println(arr1==arr2); System.out.println(Arrays.equals(arr1,arr2)); //static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true 。 System.out.println(Arrays.deepEquals(arr3,arr4)); //static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) 如果指定范围内的两个指定的int数组彼此 相等 ，则返回true。 System.out.println(Arrays.equals(arr2,1,4,arr5,1,4)); //static void fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。 //static void fill(int[] a, int fromIndex, int toIndex, int val) 将指定的int值分配给指定的int数组的指定范围的每个元素。 //注意 : 一般指定结束索引位置都不包含 int[] arr6 = new int[10]; System.out.println(Arrays.toString(arr6)); Arrays.fill(arr6,100); System.out.println(Arrays.toString(arr6)); Arrays.fill(arr6,3,6,1); System.out.println(Arrays.toString(arr6)); //static void sort(int[] a) 将指定的数组按升序排序。 System.out.println(Arrays.toString(arr1)); Arrays.sort(arr1); System.out.println(Arrays.toString(arr1)); //static void sort(int[] a, int fromIndex, int toIndex) 按升序对数组的指定范围进行排序。 System.out.println(Arrays.toString(arr2)); Arrays.sort(arr2,1,4); System.out.println(Arrays.toString(arr2)); //定义字符数组|字符串数组|double数组,使用Arrays.sort对其数据做升序排序 //static int binarySearch(int[] a, int key) 使用二进制搜索算法在指定的int数组中搜索指定的值。 System.out.println(Arrays.binarySearch(arr1,6)); //如果不存在,返回-插入点-1 } }5.附部分练习题
5.1 二维数组遍历求和操作：
用二重循环求出二维数组b所有元素的和
package com.task.d11_array; /*6.二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和： int[][] b={{11},{21,22},{31,32,33}}*/ public class Sum06 {//双层普通for循环 public static void main(String[] args) { int sum = 0;//计数器 int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化 for (int i = 0; i < b.length; i++) {//遍历外层二维数组 for (int j = 0; j < b[i].length; j++) {//遍历内层一维数组 sum += b[i][j];//两个下标位置识别一个数 } } System.out.println(sum);//输出150 } } /*接下来其余三种组合的循环遍历*/ class S2{//第二种,普通for,内层嵌套foreach public static void main(String[] args) { int sum = 0; int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化 for (int i = 0; i < b.length; i++) {//外层普通for for (int j:b[i]) {//内层增强for sum += j;//每次循环出一个数j } } System.out.println(sum);//输出150 } } class S3{//第三种两层foreach循环嵌套 public static void main(String[] args) { int sum = 0; int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化 for(int[] a:b){//外层循环,得到一个数组,因此用int[]类型接收,数组名是a for(int i:a){//内层循环,a数组,得到每一个值 sum += i; } } System.out.println(sum); } } class S4{//第四种 外层foreach 嵌套内层for循环 public static void main(String[] args) { int sum = 0; int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化 for(int[] a:b){ for (int i = 0; i < a.length; i++) {//循环遍历a数组 sum += a[i];//得到每一个索引i位置的元素 } } System.out.println(sum); } }5.2 数组查找操作：
定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。
package com.task.d11_array; import java.util.Scanner; /*1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。*/ public class Check01 { public static void main(String[] args) { String[] arr = new String[10];//定义长度为10的一维字符串数组 arr[0] = "lbj";//给数组赋值 arr[1] = "kb"; arr[2] = "kd"; arr[3] = "cp3"; arr[4] = "kaka"; arr[5] = "messi"; arr[6] = "ad"; arr[7] = "kg"; arr[8] = "dw"; arr[9] = "msn"; Scanner sc = new Scanner(System.in);//创建对象 System.out.println("请输入需要查找的内容:"); String in = sc.next();//使用功能,接收键盘输入信息 boolean flag = false;//布尔类型声明并赋值 for(String s:arr){//foreach遍历 if(s.equals(in)){//用equals方法比较是否对象深度内容相同 flag = true; } } if(flag){ System.out.println("YES"); }else{ System.out.println("NO"); } } }/*数组排序及元素查找*/ public class ArrOrder { public static void main(String[] args) throws Exception{//main方法,抛出异常 int[] arr = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 }; Arrays.sort(arr);//sort方法给数组排序 printArr("数组排序结果是:",arr); System.out.println("-----------换行----------"); int index = Arrays.binarySearch(arr,4);//查找数组中元素 System.out.println("元素4的下标位置是"+index); } private static void printArr(String str,int[] arr){ System.out.println(str+"[数组长度:"+ arr.length +"]"); for (int i:arr ) { System.out.print(" "+i); } } } /*数组排序结果是:[数组长度:10] -9 -7 -3 -2 0 2 4 5 6 8-----------换行---------- 元素4的下标位置是6*/5.3 获取数组最大值和最小值操作
package com.task.d11_array; /*获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写 函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小 的数，并统计其中>=60的有多少个。*/ public class GetMaxMin02 { public static void main(String[] args) { int[] arr = getArray(100); printArr(arr); int min = getMin(arr); int max = getMax(arr); System.out.println("数组中最大值和最小值分别是"+max+"和"+min); int count = count(arr,60); System.out.println("数组中大于或者等于60的数的个数是"+count); } //创建一个数组对象,并且初始化50个随机数 public static int[] getArray(int n){ int[] arr = new int[50];//静态声明,长度50个 for (int i = 0; i < 50; i++) {//遍历 arr[i] = (int)(n*Math.random());//给每个索引赋值随机数 } return arr; } //数组遍历 private static void printArr(int[] arr){ System.out.println("输出数组元素"); for (int i = 0; i < arr.length; i++) { if(i%10 == 0){ System.out.println(); } System.out.print(arr[i]+"\t"); } } //最大值 private static int getMax(int[] arr){ int max = arr[0]; for(int m:arr){ if(max < m){ max = m; } } return max; } //最小值 private static int getMin(int[] arr){ int min = arr[0]; for (int i = 0; i < arr.length; i++) { if(min > arr[i]){ min = arr[i]; } } return min; } //统计数组中大于等于60 public static int count(int[] arr,int num){ int count = 0; for(int v:arr){ if(v >= num){ count++; } } return count; } }/*数组倒序实例*/ public class ReverseTest { private static int[] reverse; public static void main(String[] args) { int[] arr1 = {1,3,4,7,9}; for(int i:arr1){ System.out.print(i+" ");//不换行遍历输出原来数组内容 } System.out.println("\n"); arr1 = ReverseTest.reverse(arr1); for(int i: arr1){ System.out.print(i+" "); } } public static int[] reverse(int[] arr){//返回值是新数组配合return 形参是数组 int[] res = new int[arr.length];//动态声明初始化新数组,数组长度不变 for (int i = 0, j = res.length-1; i < arr.length ;i++,j--) { res[j] = arr[i];//新数组最后一位就等于原数组第一位 } return res;//返回新数组 } }5.4 获取数组长度
/*获取数组长度*/ public class Arr_Length { public static void main(String[] args) { String[][] str = new String[3][8]; System.out.println("第一维数组长度是:"+str.length); System.out.println("第二维数组长度是:"+str[0].length); /*第一维数组长度是:3 第二维数组长度是:8*/ int[][] arr = {{1,2},{3,4,5},{6,7,8,9}}; int rows = arr.length;//行的长度 int cols = arr[0].length;//列的长度 int c = arr[1].length; int co = arr[2].length; System.out.println(rows);//3 System.out.println(cols);//2 System.out.println(c);//3 System.out.println(co);//4 } }5.5 数组反转
import java.util.Arrays; import java.util.Collection; import java.util.Collections; /*数组倒序实例*///数组反转 public class ReverseTest { private static int[] reverse; //方法一测试 public static void main(String[] args) { int[] arr1 = {1,3,4,7,9}; for(int i:arr1){ System.out.print(i+" ");//不换行遍历输出原来数组内容 } System.out.println("\n"); arr1 = ReverseTest.reverse(arr1);//调用方法一 for(int i: arr1){ System.out.print(i+" "); } System.out.println("----------"); //调用方法二测试 int[] arr3 = {1,2,3,4}; rever(arr3,arr3.length); /*9 7 4 3 1 反转后的数组是: 1 3 4 7 9 */ System.out.println("==========="); //调用方法三测试 int[] arr4 = {10,11,12,14,17}; runoobtest(arr4,arr4.length); System.out.println("---------"); //方法四测试 Integer[] arr2 = {1,2,3,4,5}; re(arr2);//[5, 4, 3, 2, 1] } //方法一 public static int[] reverse(int[] arr){//返回值是新数组配合return 形参是数组 int[] res = new int[arr.length];//动态声明初始化新数组,数组长度不变 for (int i = 0, j = res.length-1; i < arr.length ;i++,j--) { res[j] = arr[i];//新数组最后一位就等于原数组第一位 } return res;//返回新数组 } //方法二: public static void rever(int[] arr,int n){ int[] arr1 = new int[n]; int j = n; for (int i = 0; i < n; i++) { arr1[j-1] = arr[i]; j--; } System.out.println("反转后的数组是:"); for (int i = 0; i < n; i++) { System.out.print(arr1[i]+" "); } } //方法三: public static void runoobtest(int[] arr,int n){ //0和n-1换,1和n-1-1换,2和-n-1-2换 int c; for (int i = 0; i < n/2 ; i++) { c = arr[i]; arr[i] = arr[n-i-1]; arr[n-i-1] = c; } System.out.println("新数组是:\n"); for (int j = 0; j < n; j++) { System.out.print(arr[j]+" "); } } //方法四: static void re(Integer arr[]){ Collections.reverse(Arrays.asList(arr)); System.out.println(Arrays.asList(arr)); } }5.6 杨辉三角
public class YangHuiTest { public static void main(String[] args) { int[][] arr = new int[10][]; arr[0] = new int[]{1}; arr[1] = new int[]{1,1}; for (int i = 2; i < arr.length; i++) { arr[i] = new int[i+1]; arr[i][0] = arr[i][i] = 1; for (int j = 1; j < i; j++) { arr[i][j] = arr[i-1][j-1] + arr[i-1][j]; } } for (int[] arr1:arr ) { for (int i:arr1 ) { System.out.print(i+" "); } System.out.println(); } } } //打印结果如下 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1寄 语:
我们与成功之间并不遥远，
许多非凡的成就只不过是简单坚持的结果， 关键是要守住你的初心~``