一维数组&多维数组（20201213~20201218）

3.1数组的概述

数组（array）是多个相同类型数据按一定顺序排列的集合，并使用一个数字命名，并通过编号的方式对这些数据进行统一管理。

数组的常见概念

1. 数组名
2. 下标（或索引）
3. 元素
4. 数组的长度:元素的个数

3.数组的特点：

1. 数组是有序排列的
2. 数组属于引用数据类型的变量，数组的元素既可以是基本数据类型也可以是引用数据类型
3. 创建数组对象会在内存中开辟一整块连续的空间。
4. 数组的长度一旦确定，就不能修改

4.数组的分类：

1. 按照维数：一维数组、二维数组、、、
2. 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

3-2一维数组

一维数组的使用：
1. 一维数组的声明和初始化
2. 如何调用数组的指定位置的元素
3. 如何获取数组的长度
4. 如何遍历数组元素
5. 数组元素的默认初始化值
6. 数组的内存解析

3.21静态初始化和动态初始化

1.静态初始化：数组的初始化和数组元素赋值操作同时进行
2.动态初始化：数组的初始化和数组元素赋值操作分开进行
总结：数组一旦初始化完成，其长度就确定了。

//1.一维数组的声明和初始化
int[] ids;//声明
//1.1静态初始化
ids = new int[] {1001,1002,1003,1004};//数组的初始化和数组元素赋值操作同时进行
//1.2动态初始化
String[] names=new String[5];//数组的初始化和数组元素赋值操作分开进行

   //2.如何调用数组的指定位置的元素：通过角标的方式调用
   //数组的角标（或者索引）从0开始，到数组的长度-1结束
   names[0] = "王宇";
   names[1] = "王一";
   names[2] = "王二";
   names[3] = "王三";
   names[4] = "王四";

// names[5] = “王四”;异常 java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
//3.如何获取数组的长度。
//属性：length
System.out.println(names.length);//5
System.out.println(ids.length);//4

   //4.如何遍历数组元素
   for (int i = 0; i < names.length; i++) {
       System.out.println(names[i]);
   }

/*
    * 5.数组元素的默认初始化值
    *  >数组元素是整型：0
    *  >数组元素是浮点型：0.0
    *  >数组元素是char型：0或者'\u0000'而非'0'
    *  >数组元素是boolean：false
    * 
    *  >数组元素是引用数据类型： null
    *    6.数组的内存解析
    */
   int[] arr=new int[4];
   for (int i = 0; i < arr.length; i++) {
       System.out.println(arr[i]);
   }
   
   
   float [] arr1=new float[4];
   for (int i = 0; i < arr.length; i++) {
       System.out.println(arr1[i]);
   }
   
   char [] arr2=new char[4];
   for (int i = 0; i < arr.length; i++) {
       System.out.println("----"+arr2[i]+"***********");
   }
   
   if (arr2[0]==0) {
       System.out.println("你好");
   }
   
   boolean [] arr3=new boolean[4];
   System.out.println(arr3[0]);

   String [] arr4=new String[4]; 
   System.out.println(arr4[0]);//null

结果：18013820100

package com.atguigu.java;
import java.util.Scanner;
public class ArrayTest {
public static void main(String[] args) {

   Scanner scan=new Scanner(System.in);
   System.out.println("请输入学生人数");
   int numberStudent = scan.nextInt();
   
   int[]  scoreStudent= new int[numberStudent];
   
   System.out.println("请输入五个成绩：");
   for (int i = 0; i < scoreStudent.length; i++) {
       
       scoreStudent[i]=scan.nextInt();
       
   }
   
   int maxScore=0;
   for (int i = 0; i < scoreStudent.length; i++) {
       if(maxScore<=scoreStudent[i]) {
           maxScore = scoreStudent[i];
       }
   }
   System.out.println(maxScore);
   
   for (int i = 0; i < scoreStudent.length; i++) {
       if(scoreStudent[i]+10>=maxScore ) {
           System.out.println(scoreStudent[i]+"A");
       }else if (scoreStudent[i]+20>=maxScore) {
           System.out.println(scoreStudent[i]+"B");
       }else if (scoreStudent[i]+30>=maxScore) {
           System.out.println(scoreStudent[i]+"C");
       }else {
           System.out.println(scoreStudent[i]+"D");
       }
   }
}

}

3.3多维数组的使用

二维数组的使用：

1.规定：二维数组分为 外层数组的元素，内层数组的元素
int[]arr = new int[4][3];
->外层元素：arr[0],arr[1]等
->内层元素：arr[0][0]，arr[1][2]等

1. 二维数组的声明和初始化
2. 如何调用数组的指定位置的元素
3. 如何获取数组的长度
4. 如何遍历数组元素
5. 数组元素的默认初始化值
6. 数组的内存解析

package com.atguigu.java;
import java.util.Scanner;
/*

• 1. 一维数组的声明和初始化

  如何调用数组的指定位置的元素
  3.
  如何获取数组的长度
  4.
  如何遍历数组元素
  5.
  数组元素的默认初始化值
  针对初始化方式一： String[][]arr2 =new String[3][2];
  外层元素的初始化值为：地址值
  内层元素的初始化值为：与一维数组初始化情况相同

  针对初始化方式二：Double[][]arr2 =new Double[3][];
  外层元素的初始化值为：null
  内层元素的初始化值为：不能调用，否则报错
  6.
  数组的内存解析*/
  public class ArrayTest {
  public static void main(String[] args) {

  //1. 二维数组的声明和初始化
  int []arr =new int[1];
  //正确
  int []arra= {1,2,3,4,5};// 类型推断

  //静态初始化
  int[][] arr1 =new int[][] {{1,2,3},{4,5},{6,7,8}};
  //动态初始化1
  String[][]arr2 =new String[3][2];
  //动态初始化2
  String[][]arr3 =new String[3][];
  //System.out.println(arr3[1][0]);报错，空指针
  //正确
  int[] arr4[]=new int[][] {{1,2,3},{4,5},{6,7,8}};
  int[] arr5[]={{1,2,3},{4,5},{6,7,8}};

  //2.如何调用数组的指定位置的元素
  System.out.println(arr1[0][1]);//2
  System.out.println(arr2[1][1]);//null

  arr3[1]=new String[4];//arr3的数组中的第二个元素再指向一个新的数组
  System.out.println(arr3[1][0]);

  // 3. 如何获取数组的长度
  System.out.println(arr.length);//3 理解为一维数组的长度
  System.out.println(arr4[0].length);//3取决于arr3的数组中的第一个元素再指向一个新的数组中的个数
  System.out.println(arr4[1].length);//2

  //4.如何遍历数组元素
  for (int i = 0; i < arr4.length; i++) {
  for (int j = 0; j < arr4[i].length; j++) {
  System.out.println(arr4[i][j]+"----");
  }

  }

  /*
  * 5.数组元素的默认初始化值
  *
  */

  int[][]arr6 =new int[4][3];
  System.out.println(arr6[0]);//地址值[I@28a418fc ("[“表示是一维的)
  System.out.println(arr6[0][0]);//0
  System.out.println(arr6);//[[I@5305068a (”[["表示是二维的)

  float[][] arr7=new float[4][3];
  System.out.println(arr7[0]);//地址值[F@1f32e575 ("["表示是一维的)
  System.out.println(arr7[0][0]);//0.0

  String[][] arr8=new String[4][3];
  System.out.println(arr8[1]);//地址值[Ljava.lang.String;@279f2327 ("["表示是一维的)
  System.out.println(arr8[1][1]);//null

  Double [][] arr9=new Double[4][];
  System.out.println(arr9[1]);//null
  System.out.println(arr9[1][0]);//报错

  }
  }

二维数组的内存解析

int[][] arr=new int[][] {{3,6,8},{12,9},{7,0,6,4}};
int sum = 0;

   for(int i = 0;i<arr.length;i++) {
       for(int j = 0;j<arr[i].length;j++) {
           sum += arr[i][j];
       }
   }
   System.out.println(sum);

练习3
a)no
b)yes
c)no
d)no
e)yes
f)no

//1.声明并初始化二维数组
int[][] arr = new int[10][];

   //2.给数组的元素赋值
   for(int i=0;i<arr.length;i++) {
       arr[i] = new int[i + 1];
       
       //2.1给首末元素赋值
       arr[i][0] = 1;
       arr[i][i] = 1;
       //2.2给每行的非首末元素赋值
       if(i>1) {
           for (int j = 1; j < arr[i].length-1; j++) {
              arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
           }
       }
   }
   
   //3.遍历二维数组
   for (int i = 0; i < arr.length; i++) {
       for (int j = 0; j<arr[i].length; j++) {
           System.out.print(arr[i][j]+"   ");
       }
       System.out.println();
   }

拓展：创建一个长度为 6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时要求元素的值各不相同
https://blog.youkuaiyun.com/qq_43437122/article/details/105598336?ops_request_misc=%25257B%252522request%25255Fid%252522%25253A%252522160803540219725271038017%252522%25252C%252522scm%252522%25253A%25252220140713.130102334.pc%25255Fall.%252522%25257D&request_id=160803540219725271038017&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_v2~rank_v29-3-105598336.pc_search_result_cache&utm_term=%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E9%95%BF%E5%BA%A6%E4%B8%BA%206%E7%9A%84int%E5%9E%8B%E6%95%B0%E7%BB%84%EF%BC%8C%E8%A6%81%E6%B1%82%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0%E7%9A%84%E5%80%BC%E9%83%BD%E5%9C%A81-30%E4%B9%8B%E9%97%B4%EF%BC%8C%E4%B8%94%E6%98%AF%E9%9A%8F%E6%9C%BA%E8%B5%8B%E5%80%BC%E3%80%82%E5%90%8C%E6%97%B6%E8%A6%81%E6%B1%82%E5%85%83%E7%B4%A0%E7%9A%84%E5%80%BC%E5%90%84%E4%B8%8D%E7%9B%B8%E5%90%8C

3.4数组中涉及的常见算法

int[] arr=new int[10];
for(int i=0;i<arr.length;i++) {
//每个元素赋值
arr[i]=(int)(Math.random()*90+10);
}

   //求最大值
   int max=arr[0];
   for (int i = 1; i < arr.length; i++) {
       if(max<arr[i]) {
           max=arr[i];
       }
   }
   
   //求最小值
   int min=arr[0];
   for (int i = 1; i < arr.length; i++) {
       if(min>arr[i]) {
           min=arr[i];
       }
   }
   
   //求和
   int sum=0;
   for (int i = 0; i < arr.length; i++) {
       sum +=arr[i];
   }
   
   //求平均值
   int average=0  
   average =sum/arr.length;
   
   //遍历数组的每个元素
   for (int j = 0; j < arr.length; j++) {
       System.out.println(arr[j]);
   }
   
   System.out.println(max);
   System.out.println(min);
   System.out.println(sum);
   System.out.println(average);

思考：array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。
int[] array1=new int[] {2,3,5,7,11,13,17,19};
int[] array2;

   //遍历array1
   for(int i=0;i<array1.length;i++) {
       System.out.println(array1[i]);
   }
   
   //array1赋值给array2（把地址给了array2）
            //不能称做数组的赋值
   array2=array1;

   //真正的复制数组
   array2=new int[array1.length];
   for(int i=0;i<array1.length;i++) {
       array2[i]=array1[i];
   }
   
   for(int i=0;i<array2.length;i++) {
       if(i%2==0) {
           array2[i]=i;
       }
       
   }
   //遍历array1
   for(int i=0;i<array1.length;i++) {
       System.out.println(array1[i]);
   }

数组的反转

String[] arr=new String[] {“aa”,“bb”,“cc”,“dd”};

   //数组的反转
   //方法一
   for(int i=0;i<arr.length/2;i++) {
       String temp =arr[i];
       arr[i]=arr[arr.length-i-1];
       arr[arr.length-i-1]=temp;
   }
   
   //方法二
   for(int i=0,j=arr.length-1;i<j;i++,j--) {
       String temp= arr[i];
       arr[i]=arr[j];
       arr[j]=temp;
   }

数组的查找

//查找（或搜索）
//线性查找：
String dest=“ff”;

   boolean isFlag=false;
   
   for(int i=0;i<arr.length;i++) {
       if(dest.equals(arr[i])) {
           System.out.println("找到了指定的元素，位置为："+i);
           isFlag=true;
           break;
       }
   }
   
   if(isFlag==false) {
       System.out.println("很遗憾没找到");
   }

二分法查找
//二分法查找(快)
//前提：所要查找的数组必须有序
int[] arr2=new int[] {-98,-34,2,5,48,24145};

   int dest1 =-34;
   
   int head=0;//初始的首索引
   int end= arr2.length-1;//初始的末索引
   boolean isFlag1=true;
   
   while(head<=end) {
       int middle=(head+end)/2;
       
       if(dest1==arr2[middle]) {
           System.out.println("位置为："+middle);
           isFlag1=false;
           break;
       }else if(arr2[middle]>dest1) {
           end =middle-1;
       }else {//arr2[middle]<dest1
           head=middle+1;
       }
   }
   
   if(isFlag1) {
       System.out.println("很遗憾没找到");
   }

排序算法

int[] arr=new int[] {43,32,76,-98,0,64,33,-21,32,99};

   //冒泡排序实现从小到大排序
   //冒泡排序：相邻的数字比大小，左边比右边大则将左边的数字向右移一位
   
   //一共要比arr[i]长度-1轮
   for (int i = 0; i < arr.length-1; i++) {
       //每轮要比arr[i]长度-1-i次
       for(int j=0;j<arr.length-1-i;j++) {
           if(arr[j]>arr[j+1]) {
              int temp=arr[j];
              arr[j]=arr[j+1];
              arr[j+1]=temp;
           }
       }
       
   }
   
   for (int i = 0; i < arr.length; i++) {
       System.out.print(arr[i]+" ");
   }

Arrays的工具类

package Test;
import java.util.Arrays;
/*
java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
*/
public class TestCase {
public static void main(String[] args) {
//1.判断两个数组是否相等
int[] arr1=new int[] {1,2,3,4};
int[] arr2=new int[] {3,2,1,4};
boolean isEqual=Arrays.equals(arr1, arr2);
System.out.println(isEqual);//false

   //2.输出数组信息
   System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
   
   //3.将指定值填充至数组之中
   Arrays.fill(arr1, 10);
   System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]
   
   //4.对数组进行排序
   Arrays.sort(arr2);//原码的快速排序
   System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4]
   
   //5.对排序后的数组进行二分法检索指定的值
   int[] arr3=new int[] {-98,-34,2,34,54,66,79,105,210,333};
   int index=Arrays.binarySearch(arr3, 11);//检索arr3数组中的66(如果找不到该数字会返回一个负数)
   if(index>=0) {
       System.out.println(index);
   }else {
       System.out.println("很抱歉未找到该值");
   }
   
}

}

数组的常见异常
package Test;
import java.util.Arrays;
/*
数组中的常见异常：
1.数组角标越界的异常，ArrayIndexOutofBoundsExcetion
2.空指针异常：NullPointerException
*/
public class TestCase {
public static void main(String[] args) {
//1.数组角标越界的异常，ArrayIndexOutofBoundsExcetion
int[] arr=new int[] {1,2,3,4,5};

   //左边越界
   for (int i = 0; i <= arr.length; i++) {
       System.out.println(arr[i]);
   }
   
   //右边越界
   System.out.println(arr[-2]);
   
   //2.空指针异常：NullPointerException
   //情况一:
   int[] arr1=new int[] {1,2,3};
   arr1 =null;//擦除地址
   System.out.println(arr1[0]);
   
   //情况二：
   int[][] arr2=new int[4][];
   System.out.println(arr2[0]);//可输出null
   System.out.println(arr2[0][0]);//空指针
   
   //情况三：
   String[] arr3=new String[] {"aa","bb","cc"};
   System.out.println(arr3[0].toString());//正常输出aa
   arr3=null;
   System.out.println(arr3[0].toString());//空指针
}

}