3.Java语言基础——数组

3.Java语言基础——数组

一、数组概述和定义格式说明

A:数组概念
	数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
	数组既可以存储基本数据类型，也可以存储引用数据类型
B:数组定义格式
	格式1： 数据类型[] 数组名；
	格式2： 数据类型   数组名[];
举例：
	int[] a； 	定义了一个int类型的数组a；
	int a[];	定义了一个int类型的a数组；
	推荐使用第一种定义方式

二、数组的初始化

A:什么是数组的初始化
	Java中的数组必须先初始化,然后才能使用。
	所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
B:初始化的分类：
	a:动态初始化:	只指定长度，由系统给出初始化值
	b:静态初始化:	给出初始化值，由系统决定长度	
	注意事项： 这两种方式，只能使用一种，不能进行动静结合	

A:动态初始化的格式：
	数据类型[] 数组名 = new 数据类型[数组长度];
	数组长度其实就是数组中元素的个数。
	举例： int[] arr = new int[3];	定义了一个int类型的数组arr，这个数组可以存放3个int类型的值
B:静态初始化的格式：
	格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
		举例： int[] arr = new int[]{1,2,3};
	简化格式：
		数据类型[] 数组名 = {元素1,元素2,…};
		举例： int[] arr = {1,2,3}

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

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

A:栈: 存放的是局部变量
	局部变量：在方法定义中或者方法声明上的变量都是局部变量。
B:堆: 存放的是所有new出来的东西
	特点：
		a: 每一个new出来的东西都会为其分配一个地制值。
		b: 每一个变量都有一个默认的值
			byte，short，int，long  -- 0
			float，double 		       -- 0.0
			char 				      -- '\u0000'
			boolean 				-- false
			引用数据类型	 -- null		
		c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
C:方法区:(面向对象部分讲解)  
D:本地方法区:(和系统相关) 
E:寄存器:(cpu使用)

package org.westos.java3;

//数组的初始化

public class ShuZu {
    public static void main(String[] args) {
        int[] a=new int[5];
        char[] b=new char[5];
        boolean[] c=new boolean[5];
        double[] d=new double[5];
        String[] e=new String[5];
        int[][] f=new int[2][];
        //f[0]=new int[5];
        System.out.println(f[0]);//null
        System.out.println('\u0000');//空格
        System.out.println(a[0]); //0
        System.out.println(b[0]); //空格
        System.out.println(c[0]); //false
        System.out.println(d[0]); //0.0
        System.out.println(e[0]); //null
        System.out.println(a); //地址值
        int[] arr={1,2,3};
        arr[0]=100;
        System.out.println(arr[0]); //100
    }
}

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

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

package org.westos.java3;

/*数组遍历：就是依次输出数组中的每一个元素。*/

public class Test {
    public static void main(String[] args) {
        int[] arr=new int[5];
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

package org.westos.java3;

/*数组获取最值(获取数组中的最大值或者最小值)*/

public class Test {
    public static void main(String[] args) {
        int[] arr={100,120,130,110,50,22};
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}

package org.westos.java3;

/*数组元素反转(就是把元素对调)*/

public class Test {
    public static void main(String[] args) {
        int[] arr={100,120,130,110,50,22};
        for (int i = 0; i < arr.length / 2; i++) {
            int t=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=t;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

package org.westos.java3;

/*数组查表法(根据键盘录入索引,查找对应星期)*/

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入第几天:");
        int i = scanner.nextInt();
        String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
        while(true) {
            if (i >= 1 && i <= 7) {
                System.out.println(arr[i - 1]);
                break;
            } else {
                System.out.println("请输入正确天数:");
                i=scanner.nextInt();
            }
        }
    }
}

package org.westos.java3;

/* 数组元素查找(查找指定元素第一次在数组中出现的索引)*/

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        int[] arr={20,100,50,10,20,100};
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==100){
                System.out.println(i);
                break;
            }
        }
    }
}

五、二维数组概述及格式

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

A:二维数组格式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个元素
B:注意事项
	A:以下格式也可以表示二维数组
		a:数据类型 数组名[][] = new 数据类型[m][n];
		b:数据类型[] 数组名[] = new 数据类型[m][n];
		这两种格式不推荐使用
	B:注意下面定义的区别
		int x,y;
		int[] x,y[];	
		
		区别是:
		 int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
		 x=new int[3];	
  		 y=new int[3][];

A:二维数组格式2
	数据类型[][] 变量名 = new 数据类型[m][];
		m表示这个二维数组有多少个一维数组
		这一次没有直接给出一维数组的元素个数，可以动态的给出。
	举例：
		int[][] arr = new int[3][];
		arr[0] = new int[2];
		arr[1] = new int[3];
		arr[2] = new int[1];

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

package org.westos.java3;

/* D:案例演示
	定义二维数组，输出二维数组名称，输出每一个一维数组名称，输出二维数组的2个元素*/

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        int[][] arr=new int[5][0];
        System.out.println(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//有地址值
        }
        //System.out.println(arr[0][0]);//ArrayIndexOutOfBoundsException
        System.out.println("=========================================");
        int[][] arr1=new int[5][];
        System.out.println(arr1);
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);//null
        }
        //System.out.println(arr1[0][0]);//NullPointerException
        System.out.println("=========================================");
        int[][] arr2=new int[5][3];
        System.out.println(arr2);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);//有地址值
        }
        System.out.println(arr2[0][0]);//0
        System.out.println("=========================================");
        int num=0;
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                num++;
                System.out.print(arr2[i][j]+" ");
            }
            System.out.print(",");

        }
        System.out.println(num);
    }
}

package org.westos.java3;

import sun.font.FontRunIterator;

/*B:案例演示
        定义一个二维数组,打印每一个二维数组中的一维数组,再打印每一个二维数组中的元素*/
public class ShuZu2 {
    public static void main(String[] args) {
        int[][] arr=new int[][]{{1,2,3},{0,1,2},{0,1}};
        int[][] arr2={{},{}};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.print("\n");
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+" ");
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j]+" ");
            }
            System.out.println();
        }
    }
}

package org.westos.java3;

public class Test4 {
    public static void main(String[] args) {
        int[] x,y[];
        x=new int[5]; //一维数组
        y=new int[4][]; //二维数组
        int[] arr=new int[5];
        int[] arr2=arr;
        int[] arr3=new int[5];
        arr2[0]=5;
        System.out.println(arr2[0]); //5
        System.out.println(arr[0]);  //5
        System.out.println(arr3[0]); //0
    }
}

package org.westos.java3;
/*A:案例演示
        需求：公司年销售额求和
        某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度：22,66,44
        第二季度：77,33,88
        第三季度：25,45,65
        第四季度：11,66,99*/
public class ShuZu3 {
    public static void main(String[] args) {
/*        int[][] arr=new int[4][];
        arr[0]=new int[]{22,66,44};
        arr[1]=new int[]{77,33,88};
        arr[2]=new int[]{25,45,65};
        arr[3]=new int[]{11,66,99};*/

        int[][] arr =new int[][]{{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum+=arr[i][j];
            }
        }
        System.out.println("公司年销售额为:"+sum+"万元");
    }
}

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

		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:遍历这个二维数组。

package org.westos.java3;

import java.util.Scanner;

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

        1
        1 1
        1 2 1
        1 3 3 1
        1 4 6 4 1
        1 5 10 10 5 1*/
public class ShuZu5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数:");
        int a = scanner.nextInt();
        int[][] arr=new int[a][a];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < i + 1; j++) {
                if(j==0||j==i){
                    arr[i][j]=1;
                    continue;
                }
                arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < i+1; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

package org.westos.java3;

import java.util.Scanner;

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

        1
        1 1
        1 2 1
        1 3 3 1
        1 4 6 4 1
        1 5 10 10 5 1*/
public class ShuZu4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数:");
        int a = scanner.nextInt();
        int[][] arr=new int[a][];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=new int[i+1];
            for (int j = 0; j < arr[i].length; j++) {
                if(j==0||j==i){
                    arr[i][j]=1;
                    continue;
                }
                arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }

    }
}

package org.westos.java3;

public class Test2 {
/*    A:案例演示
    看程序写结果，并画内存图解释*/
    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        System.out.println("a: " + a + ",b: " + b); // a:10,b:20
        change(a,b);
        System.out.println("a: " + a + ",b: " + b); // a:10,b:20

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

    public static void change(int a,int b)  {

        System.out.println("a: " + a + ",b: " + b); // a:10,b:20
        a = b;
        b = a + b;
        System.out.println("a: " + a + ",b: " + b); // a:20,b:40
    }

    public static void change(int[] arr){
        for(int x = 0 ; x < arr.length ; x++){
            if(arr[x]%2 == 0){
                arr[x] *= 2;
            }
        }
    }
}

总结:
	在调用方法时，有时需要进行参数传递，有两种情况：
    一种就是基本数据类型作为参数传递，属于值传递，就是把实参的值传过去，形参的改变不影响实参。
    一种就是引用类型作为参数传递，属于引用传递，传递的是地址值，形参的改变会影响实参。

六、递归

A:递归概述: 方法定义中调用方法本身的现象
B:递归注意事项
	要有出口，否则就是死递归
	次数不能太多，否则就内存溢出

package org.westos.java3;
/*A:案例演示
        需求：求5的阶乘
        循环实现
        递归实现*/
public class Test2 {
    //循环实现
    public static void main(String[] args) {
        int num=1;
        for (int i = 1; i <= 5; i++) {
            num*=i;
        }
        System.out.println(num);
    }
}

package org.westos.java3;

import java.util.Scanner;

/*A:案例演示
        需求：求5的阶乘
        循环实现
        递归实现*/
public class Test2 {
    //递归实现
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("需要计算几的阶乘?");
        int n = scanner.nextInt();
        int num = jiechen(n);
        System.out.println(num);
    }
    public static int jiechen(int n){
        //StackOverflowError n过大时
        if(n==1){
            return 1;
        }else{
            return jiechen(n-1)*n;
        }
    }
}

package org.westos.java3;
/*A:案例演示:需求：兔子问题(斐波那契数列)
     有一对兔子，从出生后第3个月起每个月都生一对兔子，
     小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
     由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 ...
     1 1 2 3 5 8 13 21 ...
*/

public class Test3 {
//数组实现
    public static void main(String[] args) {
        int[] arr=new int[20];
        arr[0]=1;
        arr[1]=1;
        for (int i = 2; i < arr.length; i++) {
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println(arr[arr.length-1]);
    }
}

package org.westos.java3;
/*A:案例演示:需求：兔子问题(斐波那契数列)
     有一对兔子，从出生后第3个月起每个月都生一对兔子，
     小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
     由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 ...
     1 1 2 3 5 8 13 21 ...
*/

public class Test3 {
//循环实现
    public static void main(String[] args) {
        int a=1;
        int b=1;
        int num=0;//需要初始化变量
        for (int i = 3; i <= 20; i++) {
            int t=b;
            num=b+a;
            b=num;
            a=t;
        }
        System.out.println(num);
    }
}

package org.westos.java3;
/*A:案例演示:需求：兔子问题(斐波那契数列)
     有一对兔子，从出生后第3个月起每个月都生一对兔子，
     小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
     由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 ...
     1 1 2 3 5 8 13 21 ...
*/


public class Test3 {
//递归实现
    public static void main(String[] args) {
        int shulie = shulie(20);
        System.out.println(shulie);
    }
    public static int shulie(int n){
        if(n==1||n==2){
            return 1;
        }
        return shulie(n-1)+shulie(n-2);
    }
}