第三章 数组

基本概念

1.定义
数组（Array）多个相同类型的数据按照一定的顺序排列的集合，并且使用一个名字命名，按照编号的方式对这些数据统一管理。
2.常见概念
①数组名
②下标/索引（从0开始）
③元素
④数组长度（元素的个数）
3.特点
①数组属于引用数据类型的变量，数组的元素可以是基本数据类型也可以是引用数据类型
②创建数组对象会在内存中开辟出一整块连续空间，数组名中的引用是这块连续空间的首地址
③数组长度确定后不可修改
④数组都是有序排列的
4.数组的分类
①按照维数
一维数组与多维数组（二维数组、三维数组…）
②按照数组元素的类型
基本数据类型元素的数组与引用数据类型元素的数组

一维数组的使用

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

  
// 1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
int[] ids;// 声明 int表明数组元素的类型，[]表明此为数组
ids = new int[] { 1001, 1002, 1003, 1004 };// 初始化 引用数据类型用 关键字new


// 1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[3];


// 错误的写法：
/*
 * int[] arr1 =new int[]; 
   int[5] arr2 =new int[5];
   int[] arr3 =newint[3]{1,2,3};
 */

// 总结：等于号前面的[]没有东西，一旦初始化数组就确定了数组长度。

2.如何调用数组的指定位置的数组元素：通过下标调用

   // 数组的下标从0开始，到数组长度-1结束
        names[0] = "zoran";
        names[1] = "wdb";
        names[2] = "ply";
        // names[3]="wdb";编译不报错 运行会报错，下标越界
        System.out.println(names[2]);// ply

3.如何表示、获取数组长度

// 数组属性：length
System.out.println(names.length);// 3
System.out.println(ids.length);// 4

4.如何遍历数组元素

  // 借助循环
    for (int i = 0; i <= names.length - 1; i++) {
        System.out.println(names[i]);// zoran wdb ply
    }

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

// 整型数组默认初始化值为0 （short long int byte）
int[] arr1 = new int[4];
for (int j = 0; j < arr1.length; j++) {
    System.out.println(arr1[j]);// 0 0 0 0
}
short[] arr2 = new short[4];
for (int j = 0; j < arr2.length; j++) {
    System.out.println(arr2[j]);// 0 0 0 0
}

long[] arr3 = new long[4];
for (int j = 0; j < arr3.length; j++) {
    System.out.println(arr3[j]);// 0 0 0 0
}

byte[] arr4 = new byte[4];
for (int j = 0; j < arr4.length; j++) {
    System.out.println(arr4[j]);// 0 0 0 0
}

// 浮点型数组默认初始化值为0.0 （double float）
double[] arr5 = new double[4];
for (int j = 0; j < arr5.length; j++) {
    System.out.println(arr5[j]);// 0.0 0.0 0.0 0.0
}
float[] arr6 = new float[4];
for (int j = 0; j < arr6.length; j++) {
    System.out.println(arr6[j]);// 0.0 0.0 0.0 0.0
}

// char型数组默认初始化值为0（ASII码为0，并不是'0'）
char[] arr7 = new char[4];
for (int j = 0; j < arr7.length; j++) {
    System.out.println("----" + arr7[j] + "----");// ---- ----*4
}

//boolean型数组默认初始化值为false
boolean[] arr8 = new boolean[4];
for (int j = 0; j < arr8.length; j++) {
    System.out.println(arr8[j]);//false false false false
}

//引用数据类型数组默认初始化值为null(String 是null而非'null'）
String[] arr9 = new String[4];
for (int j = 0; j < arr9.length; j++) {
    System.out.println(arr9[j]);//null null null null
}

6.数组的内存解析

暂略

综合例题

//从键盘读入学生成绩，找出最高分并输出学生成绩等级；
//成绩>=最高分-10 等级为A
//成绩>=最高分-20 等级为B
//成绩>=最高分-30 等级为C
//其余          等级为D
import java.util.Scanner;
public class ArrayDemo {
public static void main(String[] args) {
     //1.使用Scanner读取学生个数
     //2.创建int数组储存学生成绩，动态初始化
     //3.给数组元素赋值
     //4.求出数组元素中最大值
     //5.根据学生成绩与最高分的差值得到每个学生的等级和成绩
     int maxScore = 0;
     char level;
     Scanner scan = new Scanner(System.in);
     System.out.print("请输入学生个数:");
     int studentSum=scan.nextInt();
     int[] grade=new int[studentSum];
     System.out.println("请输入学生成绩:");
     for(int i=0;i<grade.length;i++) {
          int score =scan.nextInt();   
          grade[i]=score;   //这里尤其要注意，在给score键入赋值后，要将socre存入数组；存取思想尤为重要！
          if(maxScore<grade[i]) {
              maxScore=grade[i];
              
          }
     }
     System.out.println("成绩最大值为："+maxScore);
     
     
     for(int i=0;i<grade.length;i++) {
          if(maxScore-grade[i]<=10) {
           level='A';
          }else if(maxScore-grade[i]<=20) {
              level='B';
          }else if(maxScore-grade[i]<=30) {
              level='C';
          }else {
              level='D';
          }
          
          System.out.println("学生"+"成绩为"+grade[i]+",  等级为："+level);
     }
}
}

多维数组的使用(二维数组)

对于二维数组的理解，可以看成一维数组array1又作为另外一个一维数组array2的元素存在，从数组底层运行机制来看，其实没有多维数组

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

//静态初始化
     int[] arr =new int[] {1,2,3};
     int[][] arr1 =new int[][] {{1,2,3},{4,5},{6,7}};
     //动态初始化1
     String [][] arr2 =new String[3][2];//三行两列
     //动态初始化2
     String [][] arr3 =new String [3][];//三行
     //错误的情况
     //String [][] arr4=new Sting [][4];行数一定要有

2.如何调用二维数组的指定位置的元素

  System.out.println(arr1[0][1]);//第0行第列的元素 2
     System.out.println(arr1[2][1]);//7
     System.out.println(arr2[1][1]);//null
     //System.out.println(arr1[1][2]);空指针异常

3.如何获取数组的长度

//以数组为元素，共3个元素
     System.out.println(arr1.length);//3
     System.out.println(arr1[0].length);//3 取决于作为元素的一维数组的元素个数

4.如何遍历数组

//通过循环嵌套
     for(int i=0;i<arr1.length;i++) {
          for(int j=0;j<arr1[i].length;j++) {
              System.out.println(arr1[i][j]+" ");//1 2 3  4 5 6 7
          }
          System.out.println();
     }

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

//①行列均赋值：int[][] arr6=new int[4][3];
     //外层元素初始化值为地址值
     //内层元素的初始化值与一维数组一致
     //②行赋值;int[][] arr6 =new int[4][]
     //外层元素初始化值为null
     //内层元素不能调用 否则报错
     //规定：二层数组分为外层数组的元素，内层数组的元素
          //int[][] arr5=new int[4][3];
          //外层元素：arr[0],arr[1]等
          //内层元素:arr[0][0]等
     
     int[][] arr6=new int[4][3];
     System.out.println(arr6[0]);//[I@2401f4c3 ← 地址值
     System.out.println(arr6);//[[I@7637f22 ← 地址值
     System.out.println(arr6[0][0]);//0
     
     //float  : 0.0
     //String : null  etc

6.二维数组的内存解析

略

7.二维数组的使用

//举例1
public class UseArray {
//使用二维数组打印一个10行的杨辉三角
//第一行有1个元素，第n行有n个元素
//每一行的第一个元素和最后一个元素都是1
//从第三行开始，对于非第一个元素和最后一个元素的元素
//即：yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
     public static void main(String[] args) {
           //1.声明并初始化二维数组
          int [][] yh=new int [10][];
          //2.给数组元素赋值
          for(int i=0;i<yh.length;i++) {
              yh[i]=new int[i+1];//第i行有i+1个元素
              
              //2.1给首末元素赋值
              yh[i][0]=1;
              yh[i][i]=1;
              //2.2给每一行的非首末元素赋值
          //   if(i>1) {
                   for(int j=1;j<yh[i].length-1;j++) {
                        yh[i][j]=yh[i-1][j-1]+yh[i-1][j];
                   }
              //}
          }
          
          //3.遍历输出
          for(int i=0;i<yh.length;i++) {
              for(int j=0;j<yh[i].length;j++) {
                   System.out.print(yh[i][j]+"  ");
              }
              System.out.println();
          }
     }
}



//举例2
//数组复制
public class UseArra3 {
public static void main(String[] args) {
     /*//数组的复制 反转 查找（线性查早、二分法查找)
//   创建一个类，在main方法中声明array1和array2两个变量，均为int型数组
//   使用大括号{}把array1初始化为8个素数：2.3.5.7.11.13.17.19
//   显示array1的内容
//   复制array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
//   （如array[0]=0，array[]2=2）打印array1
//   
     int []array1,array2;
     array1= new int[]{2,3,5,7,11,13,17,19};
     for(int i=0;i<array1.length;i++) {
          System.out.print(array1[i]+" ");
     }
     System.out.println();
     array2= array1;//只是将array1的地址给了array2，new一次创建一个数组。
     for(int i=0;i<array2.length;i++) {
          if(i==0) {
              array2[0]=0;
          }
          if(i%2==0) {
              array2[i]=i;
          }
          System.out.print(array1[i]+" ");//只是array1发生改变了
     }*/
     
     
     //数组的复制
     int[] array1 ,array2;
     array1= new int[] {2,3,5,7,11,13,17,19};
     array2=new int[array1.length];
     for(int i=0;i<array1.length;i++) {
          array2[i]=array1[i];
          System.out.print(array1[i]);
          System.out.print(array2[i]);
     }
}
}


//举例3 数组的反转
//方式1
String[] arr=new String[]  {"JJ","DD","MM","BB","GG","AA"};
  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;
     
     }
     
//方式2
     for (int i = 0,j=arr.length-1; i < j; i++,j--) {
          String temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp;
     }
     
  for (int i = 0; i < arr.length; i++) {
          System.out.print(arr[i]+"\t");
     }




//举例4 数组的查找（搜索）
//线性查找：
     String dest = "cc";
     boolean isFlag =true;
     for (int i = 0; i < arr.length; i++) {
     if (dest.equals(arr[i])) {
          System.out.println("找到指定元素，位置为:"+i);
          isFlag=false;
          break;
          }
     }
     if(isFlag==true) {
     System.out.println("没找到");
     }
     
//二分法查找
     //前提是所要查找的数组必须有序
          int[] arr2=new  int[]{-99,-98,-52,-22,1,24,68,99,133,854};
          int dest=24;
          int  head=0;//初始首索引
          int end =arr2.length-1;//初始末索引
          boolean isFlag=true;
     while(head<=end) {
          int middle=(head+end)/2;
          if(dest==arr2[middle]) {
              System.out.println("get it!");
              isFlag=false;
              break;
          }else if(arr2[middle]>dest) {
              end=middle-1;
          }else {
              head=middle+1;
          }
     }
     
     if (isFlag==true) {
          System.out.println("no");
     }
     


//举例5 冒泡排序
//数组前后元素对比，大的放到后面，共要排序n-1趟
int[] arr=new int[] {55,-78,662,-2478,98,22,68,45,-8,0};
     for (int i = 0; i < arr.length-1; i++) {
          for (int j = 0; j < arr.length-i-1; 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]+"\t");
     }
}
}


//举例6 快速排序
略 

8.Arrays工具类

 int [] arr1=new int[]{1,2,3,4};
 int [] arr2=new int[]{1,3,2,4};

 //1.boolean equals(int[] a,int[] b);判断两个数组是否相等
 boolean isEquals=Arrays.equals(arr1, arr2);
 System.out.println(isEquals);

 //2.String toString(int[] a);输出数组信息
 System.out.println(Arrays.toString(arr1));

 //3.void fill(int[]a,int val);将指定值填充到数组
 Arrays.fill(arr1, 10);//全部换成10
 System.out.println(Arrays.toString(arr1));//10 10 10  10

 //4.void sort (int[] a)；对数组进行排序
 Arrays.sort(arr2);
 System.out.println(Arrays.toString(arr2));

 //5.int binarySearch(int[] a,int key);二分查找
 int[] arr3=new  int[]{-99,-98,-52,-22,1,24,68,99,133,854};
 int dext =Arrays.binarySearch(arr3, 0);
 System.out.println(dext);//返回索引位置

9.数组常见异常

/*
1.数组角标越界异常：ArrayIndexOutOfBoundsExcetion
                                 数组   角标         越界         异常

2.空指针异常：NullPointerExcetion
                        空    指针    异常

*/