免责声明：java基础资料均来自于韩顺平老师的《循序渐进学Java零基础》教案，具体视频内容可以去B站观看，这些资料仅用于学习交流，不得转载用于商业活动

1.数组

数组可用存放多个同一类型的数据，数组也是一种数据类型，是引用类型

1.1 一维数组

1.1.1 使用方式1-动态初始化

语法：数据类型 数组名[]=new 数据类型[大小]

int a[]=new int[5];// 创建了一个数组，名字是a,存放5个int

a[0]数组的引用（使用/访问/获取数组元素）

数组名[下标/索引/index]:比如你要使用a数组的第3个数 a[2],数组的下标从0开始

 1 public class Array01 {
 2     public static void main(String[] args) {
 3         //循环输入5个成绩，保存到double数组，并输出
 4         Scanner sc=new Scanner(System.in);
 5         double score[]=new double[5];
 6         for(int i=0;i<score.length;i++){
 7             System.out.print("请输入第"+(i+1)+"个学生的成绩：");
 8             score[i]=sc.nextDouble();
 9         }
10         System.out.println(Arrays.toString(score));
11     }
12 }

 1.1.2 使用方式2-动态初始化

先声明数组

语法：数据类型 数组名[];也可以 数据类型[] 数组名；

int a[];或者 int[] a;

创建数组

语法：数组名=new 数据类型[大小];

a=new int[10];

 1 public class Array02 {
 2     public static void main(String[] args) {
 3         //循环输入5个成绩，保存到double数组，并输出
 4         Scanner sc=new Scanner(System.in);
 5         double score[];
 6         score=new double[5];
 7         for(int i=0;i<score.length;i++){
 8             System.out.print("请输入第"+(i+1)+"个学生的成绩：");
 9             score[i]=sc.nextDouble();
10         }
11         System.out.println(Arrays.toString(score));
12     }
13 }

 1.1.2 使用方式3-静态初始化

初始化数组

语法：数据类型 数组名[]={元素值1,元素值2,...,元素值n}

int a[]={2,6,8,9,7,68,79};

public class Array03 {
    public static void main(String[] args) {
        int arr[]={3,6,8,9,7,68,79,100};
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
    }
}

数组使用注意事项和细节：

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2. 数组中的元素可用是任何数据类型，包括基本类型和引用类型，但是不能混用
3. 数组创建后，如果没有赋值，有默认值
   1. int 0,short 0,byte 0,long 0,float 0.0,double 0.0,char \u0000,boolean false,String null
4. 使用数组的步骤(1).声明数组并开辟内存空间 (2).给数组各个元素赋值 (3). 使用数组
5. 数组的下标是从0开始的
6. 数组下标必须是在指定范围内使用，否则报：下标越界异常，比如：
   1. Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
   2. int []arr=new int[5];则有效下标为0-4
7. 数组属于引用类型，数组型数据是对象

 1 public class Array04 {
 2     public static void main(String[] args) {
 3         //数组反转 arr {1，2，3，4，5}->{5,4,3,2,1}
 4         int arr[]={1,2,6,8,9};
 5         int temp=0;
 6         System.out.println("数组反转之前的数据："+ Arrays.toString(arr));
 7         for(int i=0;i<=arr.length/2;i++){
 8             temp=arr[i];
 9             arr[i]=arr[arr.length-(i+1)];
10             arr[arr.length-(i+1)]=temp;
11         }
12         System.out.println("数组反转后的结果："+Arrays.toString(arr));
13     }
14 }

 1 public class Array05 {
 2     public static void main(String[] args) {
 3         //反转数组
 4         int arr[]={1,2,6,8,9};
 5         int arr2[]=new int[arr.length];
 6         System.out.println("数组反转之前的数据："+ Arrays.toString(arr));
 7         for(int i=arr.length-1,j=0;i>=0;i--,j++){
 8             arr2[j]=arr[i];
 9         }
10         System.out.println("数组反转之后的数据"+Arrays.toString(arr2));
11     }
12 }

1.2 二维数组

多维数组我们只介绍二维数组

二维数组的应用

比如开发一个五子棋游戏，棋盘就是需要二维数组来表示

1.2.1 使用方式1-动态初始化

语法：类型 数组名[][]=new 类型[大小][大小]

比如：int a[][]=new int[2][3]

 1 public class TwoDimensionalArray01 {
 2     public static void main(String[] args) {
 3         int arr[][]=new int[2][3];
 4         Random random=new Random();
 5         for(int i=0;i<arr.length;i++){
 6             for (int j=0;j<arr[i].length;j++){
 7                 arr[i][j]= random.nextInt(100);
 8                 System.out.print(arr[i][j]+" ");
 9             }
10             System.out.println();
11         }
12     }
13 }

1.2.2 使用方式2-动态初始化

先声明：类型 数组名[][];

再定义(开辟空间) 数组名=new 类型[大小][大小]

 1 public class TwoDimensionalArray02 {
 2     public static void main(String[] args) {
 3         int arr[][];
 4         arr=new int[3][5];
 5         Random random=new Random();
 6         for(int i=0;i<arr.length;i++){
 7             for(int j=0;j<arr[i].length;j++){
 8                 arr[i][j]=random.nextInt(50);
 9                 System.out.print(arr[i][j]+" ");
10             }
11             System.out.println();
12         }
13     }
14 }

1.2.3 使用方式3-动态初始化-列数不确定

语法：类型 数组名[][]==new 类型[大小][];

 1 public class TwoDimensionalArray03 {
 2     public static void main(String[] args) {
 3         int arr[][]=new int[3][];
 4         Random random=new Random();
 5         for(int i=0;i<arr.length;i++){
 6             //给每个一维数组开空间 new
 7             //如果没有给一维数组 new ,那么 arr[i]就是 null
 8             arr[i]=new int[random.nextInt(5)+1];
 9             for(int j=0;j<arr[i].length;j++){
10                 arr[i][j]=random.nextInt(50);
11                 System.out.print(arr[i][j]+" ");
12             }
13             System.out.println();
14         }
15     }
16 }

1.2.4 使用方式4-静态初始化

定义：类型 数组名[][]={{值1,值2,...,值n},{值1,值2,...,值n},...,{值1,值2,...,值n}}

比如：int arr[][]={{1,2},{1,2,3},{1,2,3,4}}

 1 public class TwoDimensionalArray04 {
 2     public static void main(String[] args) {
 3         int arr[][]={{5,6},{1,5,6,8},{-12}};
 4         for(int i=0;i<arr.length;i++){
 5             for(int j=0;j<arr[i].length;j++){
 6                 System.out.print(arr[i][j]+" ");
 7             }
 8             System.out.println();
 9         }
10     }
11 }

二维数组使用细节和注意事项：

• 一维数组的声明方式有：int[] x或者int x[]
• 二维数组的声明方式有：int[][] y或者int[] y[] 或者 int y[][]
• 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可用相同，也可用不同。
  • 比如：map[][]是一个二维数组 int map[][]={{1,2},{1,2,3}}
  • 由map[0]是一个含有两个元素的一维数组，map[1] 是一个含有三个元素的一维数组组成，我们也称为列数不等的二维数组