数组

数组

1.一维数组

为什么要有数组

​ 现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。

结论：
数组是存储多个变量(元素)的东西(容器)，这多个变量的数据类型要一致。

1.01数组概述和定义格式说明

1.数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型(四类八种)，也可以存储引用数据类型(内存地址)。（包含数组，类，接口。简单点，也就是说，new出来的数据就是引用数据类型。）

​ 数组定义完之后，每个元素会分配有索引（角标）从0开始。

2.数组定义格式
格式1： 数据类型[] 数组名；
格式2： 数据类型 数组名[];

​ 推荐使用第一种定义方式。

1.02数组的初始化动态初始化

什么是数组的初始化：

​ Java中的数组必须先初始化,然后才能使用。
​ 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

初始化的分类：
动态初始化: 只指定长度，由系统给出初始化值。
静态初始化: 给出初始化值，由系统决定长度。

注意事项： 这两种方式，只能使用一种，不能进行动静结合。

​ 动态初始化的格式：

​ 数据类型[] 数组名 = new 数据类型[数组长度];
​ 数组长度其实就是数组中元素的个数。

例如：

public static void main(String[] args) {
    int[] arr=new int[3];
    System.out.println(arr); //打印数组的地址值。
    arr[0]=10;
    arr[1]=20;
    arr[2]=30;

    int num=arr[0];
    System.out.println(num);
    System.out.println(arr[1]);
    System.out.println(arr[2]);

}

• 数组有一个属性，叫做length 可以获取数组的长度 int len=arr.length;

  数组中最后一个元素的索引=数组长度-1；

1.03数组的初始化静态初始化

静态初始化的格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例： int[] arr = {1,2,3};

1.04 Java中的内存分配以及栈和堆的区别

Java虚拟机在执行Java程序的过程中会把它管理的内存划分成若干个不同的数据区域。

1.栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。

​ 局部变量属于方法，随着方法的调用，而产生，随着方法的调用完毕而消失。

补充方法定义和方法声明

2.堆: 存放的是所有new出来的东西。

​ a: 每一个new出来的东西都会为其分配一个地址值。

​ b: 每一个变量都有一个默认的值
​ byte，short，int，long – 0
​ float，double – 0.0
​ char – ‘\u0000’
​ boolean – false
​ 引用数据类型 – null 
​ c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收。

1.04数组的遍历：

public static void main(String[] args) {
    int[] arr3 = {20, 30, 40, 50};
    System.out.println(arr3[0]);
    System.out.println(arr3[1]);
    System.out.println(arr3[2]);
    System.out.println(arr3[3]);
    //数组中最后一个元素的索引=数组长度-1
    System.out.println(arr3[arr3.length-1]);


    System.out.println("=================================");
    //数组的遍历。

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

    System.out.println("===========================================");
    //反向遍历
    for (int i =arr3.length-1;i>=0;i--) {
        System.out.println(arr3[i]);
    }
}

1.05数组操作的两个常见小问题越界和空指针

1:ArrayIndexOutOfBoundsException: 数组索引越界异常
原因：你访问了不存在的索引。
2:NullPointerException: 空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

1.06例题

例题1：定义一个数组，输出数组名称和数组中的元素值，给数组赋值，再次输出数组名称和数组中的元素值。

public static void main(String[] args) {
    int[] arr=new int[4];
    System.out.println(arr);//输出数组的地址
    arr[0]=12;
    arr[1]=5;
    arr[2]=14;
    arr[3]=78;
    int one=arr[0];
    int two=arr[1];
    int three=arr[2];
    int four=arr[3];
    System.out.println(one);
    System.out.println(two);
    System.out.println(three);
    System.out.println(four);
}

运行结果：[I@1540e19d
12
5
14
78

例题2：定义两个数组，分别输出数组名称和数组中的元素值，分别给两个数组赋值，再次输出数组名称和数组中的元素值。

public static void main(String[] args) {
    int[] arr=new int[3];
    System.out.println(arr);//输出数组的地址
    arr[0]=12;

    int[] arr1=new int[3];
    System.out.println(arr1);//输出数组的地址
    arr1[0]=33;
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println(arr1[0]);
    System.out.println(arr1[1]);
    System.out.println(arr1[2]);
}

运行结果： [I@1540e19d
[I@677327b6
12
0
0
33
0

例题3：定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。
最后，再次输出第一个数组数组名称和元素。

public static void main(String[] args) {
    int[] arr=new int[3];
    System.out.println(arr);//输出数组的地址
    arr[0]=12;
    arr[1]=34;
    arr[2]=56;
    int[] arr1=new int[3];
    System.out.println(arr1);//输出数组的地址
    arr1[0]=33;
    arr1[1]=36;
    arr1[2]=78;
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println("---------------");
    System.out.println(arr1[0]);
    System.out.println(arr1[1]);
    System.out.println(arr1[2]);
    System.out.println("---------------");
    int[] arr3=arr1;
    arr3[0]=1;
    System.out.println(arr3[0]);
    System.out.println(arr3[1]);
    System.out.println(arr3[2]);
    System.out.println("---------------");
    System.out.println(arr3);
}

运行结果：[I@1540e19d
[I@677327b6
12
34

56

33
36

78

1
36

78

[I@677327b6

例题4：数组查表法(根据键盘录入索引,查找对应星期)。

public static void main(String[] args) {
    //数组查表法(根据键盘录入索引,查找对应星期)。
    String[] week={"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
    Scanner s = new Scanner(System.in);
    System.out.println("输入索引 0-6");
    int index=s.nextInt();
    String w=getElementByIndex(index,week);
    System.out.println(w);

}
public static String getElementByIndex(int index,String[] week){
    if(index>=0&index<=6){
        String str=week[index];
        return str;
    }else{
        return "输入的索引不正确，没有查到该元素";
    }
}

例题5：数组元素查找(查找指定元素第一次在数组中出现的索引)。

public static void main(String[] args) {
    //数组元素查找(查找指定元素第一次在数组中出现的索引)。
    String[] week= {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
    Scanner x=new Scanner(System.in);
    System.out.println("请输入一个星期");
    String s = x.nextLine();
    int index= getIndexByElement(s,week);
    System.out.println("该元素的索引是"+index);
}
public static int getIndexByElement(String s,String[] week){
    int index=-1;
    for (int i = 0; i <7 ; i++) {
        if(s.equals(week[i])){
            index=i;
            break;
        }
    }

    return index;
    //注意返回的位置
}

2.二维数组

2.01二维数组概述和格式的讲解

• 二维数组概述

  其实二维数组其实就是每一个元素为一维数组的数组。

• 二维数组格式1
  数据类型[[] [] ][][][] 变量名 = new 数据类型[[m][n]]，[n];
  m表示这个二维数组有多少个一维数组， 必须写上。
  n表示每一个一维数组的元素个数 可选

  • 注意下面定义的区别
    int x,y;
    int[] x,y[];

  • 区别是:
    int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
    x=new int[3]; 
    y=new int[3] [];

• 二维数组格式2

  数据类型[ ] [ ] 变量名 = new 数据类型 [ m] [ ] ;

  ​ m表示这个二维数组有多少个一维数组;

  ​ 这一次没有直接给出一维数组的元素个数，可以动态的给出。

  举例：
  int[][] arr[ ] [ ]=new int[3] [ ];
  arr[0] = new int[2];
  arr[1] = new int[3];
  arr[2] = new int[1];

• 二维数组格式3
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}…};
  简化版:
  数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

  这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度。

2.01例题

例题1：定义一个二维数组,输出二维数组的名称和二维数组的的每一个一维数组,然后动态给二维数组赋值一维数组，再次输出二维数组中的每一个一维数组,给二维数组中的元素赋值,输出对应的元素值。

public static void main(String[] args) {
    //后面的中括号，不给值，不会去初始化二维数组中的一维数组，二维数组中的元素的默认值是null
    int[][] arr = new int[3][];
    System.out.println(arr);// //1b6d3586
    System.out.println(arr[0]);//null
    System.out.println(arr[1]);//null
    System.out.println(arr[2]);//null
    //我们可以自己初始化三个一维数组，放到二维数组中
    int[] one = new int[2];
    System.out.println(one); //
    int[] two = new int[2];
    int[] three = new int[2];

    arr[0] = one;
    arr[1] = two;
    arr[2] = three;

    arr[0] = new int[2];
    System.out.println(arr[0]);
    arr[1] = new int[2];
    arr[2] = new int[2];

    arr[0][0] = 20;
    arr[0][1] = 200;
    arr[1][0] = 60;
    arr[1][1] = 30;
    arr[2][0] = 20;
    arr[2][1] = 900;
    System.out.println(arr[0][0]);
    System.out.println(arr[0][1]);
    System.out.println(arr[1][0]);
    System.out.println(arr[1][1]);
    System.out.println(arr[2][0]);
    System.out.println(arr[2][1]);
}

例题2：定义一个二维数组,打印每一个二维数组中的一维数组,在打印每一个二维数组中的元素。

public static void main(String[] args) {
    int[][] arr = {{10, 20, 4}, {20, 1}, {100, 300, 5}};
    //遍历二维数组
    for (int i = 0; i < arr.length; i++) {
        //System.out.println(arr[i]);
        for (int k = 0; k < arr[i].length; k++) {
            System.out.println(arr[i][k]);
        }
    }
}

例题3：需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。

public static void main(String[] args) {
    int[][] arr = {{10, 20, 4}, {20, 1}, {100, 300, 5}};
    System.out.println(arr);
    //遍历二维数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
        for (int k = 0; k < arr[i].length; k++) {
            System.out.println(arr[i][k]);

        }
    }
}

例题4：案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

public static void main(String[] args) {
    int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
    int sum=0;
    for (int i = 0; i <3 ; i++) {
        for (int j = 0; j <3 ; j++) {
            sum+=arr[i][j];
        }
    }
    System.out.println(sum);
}

例题5：

​ 需求：打印杨辉三角形(行数可以键盘录入)

	1
	1 1	
	1 2 1
	1 3 3 1
	1 4 6 4 1 
	1 5 10 10 5 1

分析：看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。

int len=6;
int[][] arr=new int[len][len];
for (int i = 0; i <len ; i++) {
    for (int j = 0; j <=i ; j++) {
        if(j==0||j==i) {
            arr[i][j]=1;
        }else{
            arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
        }
        System.out.print(arr[i][j]+"\t");

    }
    System.out.println();