二维数组(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;i<arr.length;i++){//
for(int j:arr[i]){
System.out.println(j);
}
}
// 两个加强for嵌套
//foreach-->foreach
for(int[] a:arr){
for(int i:a){
System.out.println(i);
}
}
}
}
public 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
寄 语:
我们与成功之间并不遥远，
许多非凡的成就只不过是简单坚持的结果， 关键是要守住你的初心~``文章来源：https://www.toymoban.com/news/detail-842913.html
文章来源地址https://www.toymoban.com/news/detail-842913.html
到了这里，关于二维数组(Dyadic Array)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
