Java学习经验与总结（05）——数组

一数组的概述及其定义格式

1 为什么要有数组

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

2 什么是数组

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

3 数组的格式

格式1：数据类型[] 数组名；
格式2：数据类型数组名[];
举个例子
int [] a; 定义了一个int类型的数组a；
int a[]; 定义了一个int类型的a数组；
我们推荐使用第一种定义方式

二数组的初始化

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

1 数组的动态初始化

（1）动态初始化的格式

数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例： int[] arr = new int[4];	定义了一个int类型的数组arr，这个数组可以存放4个int类型的值。

（2）演示一下用动态数组来输出数组名称和数组元素

public class Mydemo1 {
    public static void main(String[] args) {
        int[] arr=new int[4];
        for (int i = 0; i < 4; i++) {
            arr[i]=i+1;
            System.out.println("arr["+i+"]="+arr[i]);
        }


    }


}

（3）动态初始化数组的内存图

2 数组的静态初始化

（1）静态初始化的格式

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

（2）静态初始化数组内存图

3 数组操作常见的两个小问题

（1）越界

在程序报错如下的时候称为数组的越界
ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。

（2）空指针异常

在程序报错如下的时候称为空指针异常
NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

4 数组的常用操作

（1）数组的遍历

public class Mydemo1 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        }
    }

（2）获取数组中的最大值

public class Mydemo1 {
    public static void main(String[] args) {
        int[] arr={2,4,20,2,1};int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){max=arr[i];
            }
        }
        System.out.println(max);
        }
    }

（3）数组的反转

public class Mydemo1 {
    public static void main(String[] args) {
        int[] arr = {2, 4, 20, 2, 1};
        for (int i=0,j=arr.length-1; i < j; i++,j--) {
            int t=arr[i];
            arr[i]=arr[j];
            arr[j]=t;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}

（4）数组的查表法（根据索引查元素）

package org.westos.zz;

import java.util.Scanner;

public class Mydemo1 {
    public static void main(String[] args) {
        String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入一个数字 范围是0----6");
                int index = sc.nextInt();
                String str=getEleByIndex(arr,index);
                System.out.println("这个索引所对应的元素是:"+str);
            }
            public static String getEleByIndex(String[] arr,int index){
                String str="";
                if(index>=0&&index<=arr.length-1){
                    str= arr[index];
                }else{
                    str="你索引是乱输入的没有找到对应的元素";
                }
                return str;
            }
        }

（5）数组的查表法（根据元素查索引）

package org.westos.zz;

import java.util.Scanner;

public class Mydemo1 {
    public static void main(String[] args) {
        int[] arr={100,200,300,400,500,600,700,800};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字 范围是100 200 300---800");
        int ele = sc.nextInt();
        int index=getIndexByEle(arr,ele);
        if(index==-1){
            System.out.println("你输入的值有误");
        }else{
            System.out.println("该元素在数组中的索引是:"+index);}
    }

    public static int getIndexByEle(int[] arr, int ele) {
        int index=-1;
        for (int i = 0; i < arr.length; i++) {
            if (ele == arr[i]) {
                index=i;break;
            }
        }
        return index;
    }
}

（6）对数组中的元素进行从小到大排序（冒泡排序）

package org.westos.zz;

import java.util.Scanner;

public class Mydemo1 {
    public static void main(String[] args) {
        int[] arr = {2, 3, 10, 82, 9, 14, 52};
        maopao(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }
    private static void maopao(int[]arr) {
        for (int j = 0; j < arr.length-1; j++)
            for (int i=0; i < arr.length-j-1; i++) {
                if(arr[i+1]<arr[i]){
                    int t=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=t;
                }
            }
    }
}

三二维数组的概述和格式

1 二维数组的概述

我们学校的专业每个专业有很多个学生，所以，可以用数组来存储，而我们又同时有很多个专业。
这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用
由此可见：其实二维数组其实就是每一个元素为一维数组的数组。

2 二维数组的格式

(1) 二维数组的格式1

数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
	int[][] arr = new int[3][2];
	定义了一个二维数组arr
	这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
	每个一维数组有2个元素，可以通过arr[m][n]来获取
		表示获取第m+1个一维数组的第n+1个元素

注意事项
1:以下格式也可以表示二维数组
a:数据类型数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
2:注意下面定义的区别
int x,y;
int[] x,y[];

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

（2）二维数组的格式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 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
	数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
	举例: 
		int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
		int[][] arr = {{1,2,3},{5,6},{7}};

3 二维数组的遍历

public class Mydemo1 {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{1,2}, {3, 4}, {5, 6, 7, 8}};

        for(int i=0;i<arr.length;i++){     //外循环控制二维数组的长度
            for(int j=0;j<arr[i].length;j++){    //内循环控制一维数组的长度
                System.out.println(arr[i][j]);
            }
        }
    }
}

4 二维数组的求和

（1）公司年销售求和

某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
我们分别用动态初始化和静态初始化两种方式来求一下公司的销售和
1 动态初始化

package org.westos.zz;

import java.util.Scanner;

public class Mydemo1 {
    public static void main(String[] args) {
        int sum=0;
        int[] arr1={22, 66, 44};
        int[] arr2={77, 33, 88};
        int[] arr3={25, 45, 65};
        int[] arr4={11, 66, 99};
        int[][] maxArray=new int[4][];
        maxArray[0]=arr1;
        maxArray[1]=arr2;
        maxArray[2]=arr3;
        maxArray[3]=arr4;
        for(int i=0;i<maxArray.length;i++){
            for(int j=0;j<maxArray[i].length;j++){
                sum+=maxArray[i][j];
            }
        }
        System.out.println("公司的销售和是"+sum);
    }
}

2 静态初始化

package org.westos.zz;

import java.util.Scanner;

public class Mydemo1 {
    public static void main(String[] args) {
        int sum=0;
        int[][] maxArray = new int[][]{{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
        for(int i=0;i<maxArray.length;i++){
            for(int j=0;j<maxArray[i].length;j++){
                sum+=maxArray[i][j];
            }
        }
        System.out.println("公司的销售和是"+sum);
    }
}

(2)打印杨辉三角形

package org.westos.zz;

import java.util.Scanner;

public class Mydemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输人行数");
        int n = sc.nextInt();
        int[][] arr=new int[n][n];
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
        }
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j < i; j++) {
                arr[i][j]= arr[i-1][j-1]+ arr[i - 1][j];
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <=i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}