数组，二维数组。

数组

一、数组的定义和访问

1、定义数组

Java中定义数组有两种语法格式：

数据类型 数组名[ ];     //String names[]

数据类型[] 数组名;      // String[] names推荐使用

数组是什么数据类型，数组的元素就是什么数据类型

数组的特征是[ ]

数组是引用类型

2、静态初始化数组

定义数组、为数组元素分配内存、数组元素初始化，这三步可以合并在一起写。

int[] arr = new int[]{1,2,3,4,5};

int[] arr = {1,2,3,4,5};

在定义数组时直接给数组中的数据赋值这种方式称为静态初始化。

数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3};

数据类型[] 变量名 = {元素1,元素2,元素3};

int arr ={1,2,3,4,5};
System.out.println(arr[0]);

数组在计算机中的基本原理

int[] arr = {1,2,3,4,5};
1、左边 int[] arr 表示定义了一个数组类型的变量，变量名叫arr。
2、右边 {12,24,36} 表示创建一个数组对象，这个对象在内存中会有一个地址值，每次创建一个数组对象都会有不用的地址值。
3、把右边的地址值赋值给左边的arr变量
4、arr变量就可以通过地址值，找到数组这个东西

数组变量名中存在的时数组内存中的地址，数组是一种引用数据类型

数组的元素访问

数组中存储的数据我们叫做元素；而且数组中的每一个元素都有一个编号与之对应，我们把这个编号叫做索引，这个索引是从0依次递增的整数。

int arr ={1,2,3,4,5}; //静态初始化

//访问所有数据
System.out.println(arr[0]); // 1
System.out.println(arr[1]); // 2
System.out.println(arr[2]); // 3
System.out.println(arr[3]); // 4
System.out.println(arr[4]); // 5
System.out.println(arr[5]);
//没有5索引，会出现ArrayIndexOutOfBoundsException 索引越界异常
// 2、修改数组中的数据
arr[0]=11;
arr[3]=66;
System.out.println(arr[0]); //11
System.out.println(arr[3]); //66

// 3、访问数组的元素个数：数组名.length
System.out.println(arr.length);
// 获取数组的最大索引: arr.length - 1(前提是数组中存在数据)
System.out.println(arr.length - 1);
int[] arr2 = {};
// arr2[arr2.length - 1]
System.out.println(arr2.length - 1);

数组的遍历

数组的遍历就是将数组中的元素一个一个取出来。可以用for循环

int[] ages = {12, 24, 36};
for (int i = 0; i < ages.length; i++) {
    // i的取值 = 0, 1, 2
    System.out.println(ages[i]);
}

3、动态初始化

数组名 = new 数据类型[数组长度];

// 数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[6];

使用动态初始化定义数组时，根据元素类型不同，默认值也有所不同。

E g:某歌唱比赛，需要开发一个系统：可以录入6名评委的打分，录入完毕后立即输出平均分做选手得分

public class Demo01{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double scores =new double [6];
        for (int i = ; i <= 6; i ++){
            System.out.println("请输入第" + (i+1) + "个评委的成绩：");
            double score=sc.nextdouble;
            scores[i]=score;
        }
        double sum =0;
        double avg=0;
        for(int i=0;i<scores.length;i++){
            sum+=scores[i]; 
        }
        avg=sum/scores.length;
        System.out.println("选手的成绩是"+avg)
}

数组使用过程可能出现的问题

public class ArrayDemo03{
      public static void main(String[] args){
          int[] scores = {32,45,45,76};
          System.out.println(scores[5]); // 下标越界
          int[] ages = {32,43,444,32,'a'};
          System.out.println(ages[4]); // 97 报错
          int[] ages1 = {32,43,444,32L};
          ages1[2] = 100;
          ages[2] = 100L;
          System.out.println(ages1[3]); // 报错 32
   }
}

如果在数组中保存的元素可以自动提升(自动类型转化)为数组自己的类型，那是可以保存的

数组下标越界

4、数组在计算机中的执行原理

方法区、栈、堆。

方法区：字节码文件先加载到这里

栈：方法运行时所进入的内存区域，由于变量在方法中，所以变量也在这一块区域中

堆：存储new出来的东西，并分配地址。由于数组是new 出来的，所以数组也在这块区域。

int a = 10 与 int[] arr = new int[]{11,22,33}的区别

a是一个变量，在栈内存中，a变量中存储的数据就是10这个值。

arr也是一个变量，在栈中，存储的是数组对象在堆内存中的地址值

多个变量指向同一个数组的问题

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

内存原理

int[] arr2 = arr1; 内存原理为

arr2[1]=99;时 ，内存原理为

1、两个变量指向同一个数组时，两个变量记录的是同一个地址值。

2、当一个变量修改数组中的元素时，另一个变量去访问数组中的元素，元素已经被修改过了。

5、数组专项练习

数组求最值

定义一个int类型数组，求数组中元素的最大值，并打印最大值

public class Demo02{
    public static void main(String[] args){
        int[] arr={22,33,44,55,66};
        int max=arr[0];
        for(int i= 0;i<arr.length;i++){
            if(max<arr[i]){
                int temp =arr[i];
                arr[i]=max;
                max=temp;
            }
        }
        Sydtem.out.println(max);
    }
}

6、使用增强for循环遍历数组

for (元素类型 变量名 : 要迭代的对象) {
      System.out.println(变量名);
}

public class Demo03{
    public static void main(String[] args){
        int[] arr ={11,22,33,44,55,66};
        for(int e: arr){
            System.out.print(e)
        }
    }
}

1、元素类型是指数组或集合中的元素的类型。

2、变量名在循环时用来保存每个元素的值。

3、冒号后面是要遍历的数组或集合的名称。

6、二维数据组

数据类型[ ][ ] 数组名;

数据类型 数组名[ ][ ];

[][] 表示二维数组，前面的[ ]表示第一维，后面的[ ]表示第二维。

[][] 放在数组名的前面或后面都是正确的

分配内存

int[][] arr = new int[3][4];

数组元素初始化

// 二维数组初始化
int[][] arr = new int[3][4]; // 动态初始化
arr[0][0] = 1;
int[][] arr1 = new int[][]{ // 静态初始化
{1, 2, 3},
{2, 3},
{3, 4, 5, 4}
};

二维数组的迭代

for (int i = 0; i < arr1.length; i++) {
   System.out.println(arr1[i]);
   for (int i1 = 0; i1 < arr1[i].length; i1++) {
        System.out.println(arr1[i][i1]);
   }
}
   for (int[] t : arr1) {
   for (int a : t) {
   System.out.println(a);
  }
}

1, 2, 3},
{2, 3},
{3, 4, 5, 4}
};

二维数组的迭代

```java
for (int i = 0; i < arr1.length; i++) {
   System.out.println(arr1[i]);
   for (int i1 = 0; i1 < arr1[i].length; i1++) {
        System.out.println(arr1[i][i1]);
   }
}
   for (int[] t : arr1) {
   for (int a : t) {
   System.out.println(a);
  }
}