Java 入门探索者09（数组）

Java的数组是一种固定大小、有序且相同类型元素的集合。它可以存储同一种数据类型的多个元素，并按照索引顺序访问这些元素。

Java数组的特点包括：
1. 长度固定：一旦数组被创建，其长度就不能修改。可以通过数组的length属性来获取数组的长度。
2. 有序性：数组中的元素按照索引顺序排列，从0开始，最后一个元素的索引是length-1。
3. 同类型：数组中的元素必须是同一种数据类型。

Java数组的基本操作包括：
1. 创建数组：使用关键字new来创建一个数组，并指定数组的大小。
   ```
   int[] numbers = new int[5]; // 创建一个大小为5的整数数组
   ```
2. 访问数组元素：通过索引来访问数组中的元素。索引从0开始，最后一个元素的索引是length-1。
   ```
   int firstNumber = numbers[0]; // 获取第一个元素
   int lastNumber = numbers[numbers.length - 1]; // 获取最后一个元素
   ```
3. 修改数组元素：可以通过索引来修改数组中的元素。
   ```
   numbers[1] = 10; // 修改第二个元素为10
   ```
4. 遍历数组：可以使用循环来遍历数组中的元素。
   ```
   for (int i = 0; i < numbers.length; i++) {
       System.out.println(numbers[i]);
   }
   ```
5. 多维数组：Java也支持多维数组，即数组中的元素可以是数组。
   ```
   int[][] matrix = new int[3][3]; // 创建一个3x3的二维数组
   matrix[0][0] = 1; // 设置第一个元素为1
   int value = matrix[1][2]; // 获取第二行第三列的元素
   ```

Java数组还提供了一些有用的方法，如排序、查找等。可以使用Arrays类来操作数组。另外，Java提供了一些更高级的集合类，如ArrayList和LinkedList，它们提供了更灵活的操作和动态大小的功能。


import lesson08.Student;

public class ArrayTest01 {
    public static void main(String[] args) {
        //创建数组对象，动态初始化
        //[]表示当前的定义的是一个数组类型的数据
        //数组类型是一个引用类型数据
        //[]中不能写任何值，任意位置在对象名前后都可以
        int[] a;
        Student s[];
        //数据一旦创建成功，长度就不会发生改变
        //内存开始发生改变，创建一个长度为5的数组，且数组中的值都是默认初值为0
        a=new int[5];
        //内存开始发生改变，创建一个长度为5的数组，且数组中的值都是默认初值为null
        s=new Student[5];
        //重新给数组a赋值，原来的数组变成了垃圾，新的数组长度由元素列表的个数决定
        //且值为{1，2，3，4，5}
        a=new int[]{1,2,3,4,5};
        Student s1=new Student();
        Student s2=new Student();
        Student s3=new Student();
        Student s4=new Student();
        Student s5=new Student();
        //重新给数组s赋值，原来的数组变成了垃圾，新数组的长度由元素列表的个数决定
        //且值为{s1,s2,s3,s4,s5}
        s=new Student[]{s1,s2,s3,s4,s5};
        //声明的同时初始化，也叫静态初始化
        int[] b=new int[5];
        int[] c=new int[]{1,2,3,4,5};
        int[] d={1,2,3,4,5};

    }
}

数组越界指的是在访问数组元素时，指定的索引超出了数组的有效范围。在大多数编程语言中，数组索引从0开始，最大索引为数组长度减1。

如果在代码中访问的索引小于0或大于等于数组长度，就会发生数组越界。这种情况可能导致程序崩溃、产生异常或得到错误的结果。

例如，假设有一个长度为5的数组arr，那么arr[4]是最后一个元素，arr[5]就是越界访问。同样地，arr[-1]也是越界访问。

数组越界通常是由于以下原因引起的：
1. 指定的索引值超出了数组的有效范围；
2. 数组长度计算错误或者数组长度与实际存储的元素个数不一致；
3. 在循环中使用了错误的索引或者在索引计算中发生了错误。

为了避免数组越界错误，我们应该：
1. 检查并确保所使用的索引在有效范围内；
2. 在使用索引之前，确认数组的长度是正确的；
3. 在循环中使用正确的索引并保证索引的计算是正确的；
4. 在开发过程中进行测试和调试，及时发现并解决数组越界问题。

一些编程语言提供了边界检查功能或者抛出异常来处理数组越界，这样可以更容易地发现和修复错误。


public class ArrayTest02 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};
        //使用数组的前提必须要先进行初始化
        //使用方式为数组名[下标]下标又称索引
        //索引从0开始，最大值为数组长度-1，如果超过这个值就会发生数组越界
        System.out.println(a[4]);
        //数组的遍历，将数组中的元素拿出来进行相关操作
        for (int i=0;i<5;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
        //for each循环
        for (int i:a){
            System.out.print(i+" ");
        }
        int[] f=new int[20];
        for (int i=0;i<20;i++){
            if (i<2){
                f[i]=1;
                f[i]=1;
            }else {
                f[i]=f[i-1]+f[i-2];
            }
            System.out.print(f[i]+" ");
        }
    }

}


Java数组是一种存储固定大小的相同类型元素的容器。数组提供了一组丰富的方法来操作和访问数组中的元素。以下是Java数组中常用的方法：

1. length属性：用于获取数组的长度，表示数组中元素的个数。
```java
int[] array = {1, 2, 3, 4, 5};
int length = array.length; // length为5
```

2. 访问数组元素：通过索引访问数组元素，索引从0开始计数。
```java
int[] array = {1, 2, 3, 4, 5};
int firstElement = array[0]; // firstElement为1
```

3. clone()方法：用于复制一个数组，创建一个具有相同元素的新数组。
```java
int[] array = {1, 2, 3, 4, 5};
int[] newArray = array.clone(); // 复制array数组到newArray数组
```

4. toString()方法：将数组转换为字符串。
```java
int[] array = {1, 2, 3, 4, 5};
String arrayString = Arrays.toString(array); // arrayString为"[1, 2, 3, 4, 5]"
```

5. sort()方法：对数组元素进行排序（默认按升序排序）。
```java
int[] array = {5, 2, 3, 1, 4};
Arrays.sort(array); // 数组元素按升序排序
```

6. binarySearch()方法：在已排序的数组中使用二分查找算法查找指定元素的索引。
```java
int[] array = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(array, 3); // index为2
```

7. equals()方法：比较两个数组是否相等（长度相等且对应元素相等）。
```java
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
boolean areEqual = Arrays.equals(array1, array2); // areEqual为true
```

8. fill()方法：用指定的值填充整个数组。
```java
int[] array = new int[5];
Arrays.fill(array, 1); // 数组元素全部填充为1
```

9. copyOf()方法：复制数组的前n个元素到一个新数组中。
```java
int[] array = {1, 2, 3, 4, 5};
int[] newArray = Arrays.copyOf(array, 3); // 复制array数组的前3个元素到newArray数组
```

10. copyOfRange()方法：复制数组的指定范围内的元素到一个新数组中。
```java
int[] array = {1, 2, 3, 4, 5};
int[] newArray = Arrays.copyOfRange(array, 1, 4); // 复制array数组的索引1到3的元素到newArray数组
```

这些方法只是Java数组类中的一部分方法，还有更多方法可根据具体需求使用。


import java.util.Arrays;
public class ArrayTest03 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};
        //length属性用于获取数组长度的，也就是表示数组中元素的个数
        System.out.println(a.length);
        //数组复制，将原数组中的数据复制到新数组中，不够的位置用默认初值表示
        int b[]= Arrays.copyOf(a,10);
        //数组复制，将原数组中的指定位置开始的数据到指定位置结束的数据进行复制
        //开始位置的索引指代的数据要复制，结束位置索引指引的数据不复制
        int c[] = Arrays.copyOfRange(a,1,5);
        int d[] = new int[10];
        //从指定位置开始复制，到新数组的指定位置
        //第一个参数是原数组，第二个参数是开始复制的起始位置的索引，第三个位置是新数组
        //第四个参数是新数组中开始复制的起始位置，第五个参数是复制多长
        System.arraycopy(a,1,d,3,4);
        //数组初始化方法，将数组中的值全部赋值成同一个值
        Arrays.fill(d,5);
        for (int i:b
        ) {
            System.out.print(i+" ");
        }
    }
}

在Java中，可以使用Arrays类的sort()方法对数组进行升序排序。sort()方法接受一个数组作为参数，并按升序重新排列数组的元素。

下面是一个示例代码，演示如何对一个整数数组进行升序排序：

```java
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9};
        
        Arrays.sort(numbers);
        
        System.out.println("升序排序后的数组：");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}
```

输出结果：

```
升序排序后的数组：
1
2
5
8
9
```

如果要对数组进行降序排序，可以使用Arrays类的sort()方法结合Collections类的reverseOrder()方法。reverseOrder()方法用于返回一个比较器，可以实现降序排序。

下面是一个示例代码，演示如何对一个整数数组进行降序排序：

```java
import java.util.Arrays;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 8, 1, 9};
        
        Arrays.sort(numbers, Collections.reverseOrder());
        
        System.out.println("降序排序后的数组：");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}
```

输出结果：

```
降序排序后的数组：
9
8
5
2
1
```

需要注意的是，如果要对基本数据类型的数组进行降序排序，需要将数组类型声明为对应的包装类，比如Integer[]、Double[]等。这是因为基本数据类型的数组无法直接使用Collections类的reverseOrder()方法。


public class ArrayTest04 {
    public static void main(String[] args) {
        //数组排序
        int a[] = {9,5,4,7,8,3,2,1,6};
        Arrays.sort(a);
        //二分查找法一定要先升序排序在查找，返回的是查到值的索引位置
        int b = Arrays.binarySearch(a,2);
        System.out.println(b);
        for (int i:a){
            System.out.println(i+" ");
        }
        //降序排序
//        for (int i=0;i<a.length-1;i++){
//            for (int j= i+1;j<a.length;j++){
//                if (a[i]<a[j]){
//                    int temp = a[i];
//                    a[i]=a[j];
//                    a[j]=temp;
//                }
//            }
//        }
//        for (int i:a){
//            System.out.println(i+" ");
//        }
    }
}

一维数组和二维数组是在编程语言中用来存储数据的数据结构。

一维数组是一个线性的数据结构，它由相同类型的元素组成，并按照一定顺序排列。每个元素都可以通过数组的索引来访问，索引从0开始，依次递增。一维数组可以是固定长度的（静态数组），也可以是动态长度的（动态数组）。

例如，一个一维数组可以存储一系列整数，如[1, 2, 3, 4, 5]。我们可以通过索引来访问数组中的元素，例如数组中的第一个元素是1，第二个元素是2，以此类推。

二维数组是一个数据表格，它由多行和多列组成。每个元素都可以通过两个索引来访问，第一个索引表示行号，第二个索引表示列号。行号和列号都从0开始，依次递增。

例如，一个2x3的二维数组可以表示为：

[1, 2, 3]
[4, 5, 6]

我们可以使用两个索引来访问数组中的元素，例如数组中的第一行第二列元素是2，第二行第三列元素是6。

二维数组可以用来表示和处理多维数据。例如，在游戏开发中，我们可以使用二维数组来表示游戏地图，每个元素表示地图上的一个位置，可以存储该位置的属性和状态。


public class ArrayTest05 {
    public static void main(String[] args) {
        //二位数组，如果一个一维数组中保存一个一维数组，那么这个数组被称为二维数组
        //动态初始化，先声明在赋值
        int[][] a;
        //new的时候，前面第一个[]中一定要写长度，第二个[]中的数组长度可以不写
        //如果写了表示二维数组中所有是一维数组都是一样的长度的
        a=new int[3][4];
        //使用元素列表初始化
        a=new int[][]{{1,2,3},{4},{5,6,7,8}};
        //给一维数组中第一个一维数组进行初始化
        a[0]=new int[3];
        //静态初始化，声明的同时初始化
        int[][] b=new int[3][];
        int[][] c=new int[][]{{1,2,3},{4},{5,6,7,8}};
        //属于静态初始化独有的写法，也是比较常用的方式之一
        int[][] d={{1,2,3},{4},{5,6,7,8}};
    }
}

当用Java编写时，可以使用双重for循环来遍历二维数组。下面是一个示例代码：

```java
public class Main {
    public static void main(String[] args) {
        // 定义一个二维数组
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        // 遍历二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.println(matrix[i][j]); // 输出当前元素
            }
        }
    }
}
```

输出结果：
```
1
2
3
4
5
6
7
8
9
```

在代码中，外层循环用于遍历每一行，内层循环用于遍历当前行的每个元素。通过 `matrix[i][j]` 可以获取当前元素的值，并对其进行操作。

public class ArrayTest06 {
    public static void main(String[] args) {
        //二维数组如何遍历
        int[][] a = {{1, 2, 3}, {4}, {5, 6, 7, 8}};
        for(int i =0;i<a.length;i++){
            for (int j=0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
}