day 05 Java基础学习笔记

数组

数组概念

1. 数组是储存同一种类型多个元素的集合，也就是一个容器，这个容器有了名字就是数组名；
2. 数组就是在内存开辟一块空间，这些内存空间在使用上是连续的，连续的下标值可以访问所有数组元素；
3. 数组既可以存储基本数据类型，也可以存储引用数据类型，

-String[] args引用数据类型

-int[] buf jib基本数据类型

-byte[] nums 基本数据类型

数组的定义格式

数组定义格式：数据类型[] 数组名

• int[] a;定义一个int型数组，里面包含都是int类型元素；
• String[] b;定义一个String型数组，里面包含的都是String类型元素；

数组的初始化

所谓初始化就是为数组中数组元素在内存中分配空间，并给数组内元素赋值。

动态初始化

• 数组的创建与元素赋值分开；
• 初始化时只指定数组长度，系统会给元素分配默认初始化值，这个初始值可以在后面修改；
• 格式：数据类型[] 祖名 = new 数据类型[数组长度]；

• 数组的类型其实就是后面元素的类型，数组长度就是后面元素的个数；

  int[] a = new int[3]; 
  

  这一条语句实际进行了三部操作，首先在栈空间中定义了变量s，并给赋初始值为null，在堆空间中开辟空间给数组，并将其中元素赋初始值，将数组的地址赋给栈中的变量s。

静态初始化

• 创建数组的时候就给数组元素赋值，由系统确定数组长度。

  数据类型[] 数组名 = new{元素1，元素2...}；
  数据类型[] 数组名 = {元素1，元素2...}；
  

Java中的内存分配

栈（stack）和堆（heap）内存

• 栈：存放局部变量
• 堆：存放的所有new出来的东西

堆内存的特点：

1. 每一个new出来的东西都有地址值
2. 堆中的每一个变量都有默认值 byte、short、int、long等类型默认值为0；浮点类型默认值为0.0；布尔类型的默认值为false；应用数据类型默认值为null；
3. 堆内存在使用后就变成了垃圾，但是需要在JVM空闲的时候才会回收这些堆空间

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

数组索引越界

ArrayIndexOutOfBoundsException

访问到了数组中的不存在的索引时发生，索引值超出了索引值的范围：-1，大于等于数组长度等

空指针异常

NullPointerException

数组引用变量没有指向实体，却在操作实体中的元素

    class ArrayDemo6 {
        public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};
        //System.out.println(arr[3]);//数组越界
        //引用类型的常量：空常量 null
        arr = null;
        System.out.println(arr[0]);
    }
}

数组遍历（依次输出数组中的每一个元素）

    class HomeTest2 {
        public static void main(String[] args) {
            int[] arr = {10,20,30,40};
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+" ");
            }
        }
    }

数组获取最值（获取数组中的最大值，最小值）

    public class HomeTest3 {
        public static void main(String[] args) {
            int[] arr = {35,42,37,49};
            int max = max(arr);//调用方法
            int min = min(arr);//调用方法
            sop("最大值为："+max);
            sop("最小值为："+min);
        }
        //定义打印方法
        public static void sop(Object cont){
            System.out.println(cont);
        }
        //定义方法求最大值，需要返回值
        public static int max(int[] arr){
            int max = arr[0];//将数组中第一个元素的值赋给max
            for (int i = 0; i < arr.length; i++) {  //遍历其他元素
                if(arr[i]>max){    //将数组中每个元素值与max进行比较
                    max = arr[i];  //如果有比max值得大的元素，就将这个元素的值赋给max
                }
            }
            return max;  
        }
        //定义方法求最小值
        public static int min(int[] arr){
            int min = arr[0];//将数组中第一个元素的值赋给min
            for (int i = 0; i < arr.length; i++) {  //遍历其他元素
                if(arr[i]<min){    //将数组中每个元素值与min进行比较
                    min = arr[i];  //如果有比min值小得的元素，就将这个元素的值赋给min
                }

数组元素逆序 （就是把元素对调）

    public class HomeTest4 {
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};

    print(arr);
    System.out.println();
    printD(arr);
    print(arr);
}
//定义打印方法
public static void sop(Object cont){
    System.out.println(cont);
}
//定义方法打印出数组元素排列顺序
public static void print(int[] arr){
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+" ");
    }
}
//定义方法数反转组元素排列顺序
public static void printD(int[] arr){
    int temp = 0;
    for (int i = 0; i < arr.length/2; i++) {
        temp = arr[i];   
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i]=temp;
    }
}

}

数组查表法（根据键盘录入索引，查找对应的元素）

    import java.util.Scanner;
    class HomeHest5 {
        public static void main(String[] args) {
            Scanner s = new Scanner(System.in);
            System.out.println("请输入要查找的元素：");
                    int a = s.nextInt();
            String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期日",};
            System.out.println("今天是；"+arr[a-1]);
        }
        public static int print(String[] arr){
            int i = 0;
            if(i<arr.length){
                System.out.println(arr);
            }
            return i;
        }
    }

数组元素查找（查找指定元素第一次在数组中出现的索引）

    class HomeTest6 {
        public static void main(String[] args) {
            int[] arr = {10,20,30,40,50};
            int a = getIndex(arr,20);
            System.out.println("20在数组中第一次出现的索引是："+a);
            int b = getIndex(arr,30);
            System.out.println("30在数组中第一次出现的索引是："+b);
            int c = getIndex(arr,40);
            System.out.println("40在数组中第一次出现的索引是："+c);
        }
        public static int getIndex(int[] arr,int a){
            for (int i = 0; i < arr.length; i++) {
                if(arr[i]==a){
                    return i;
                }
            }
            return -1;
        }
    }

二维数组

二维数组定义方式一：每个元素长度相同

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

二维数组定义方式二：每个元素长度不一定相同

动态初始化

    数据类型[][] 变量名 = new 数据类型[m][];
    m表示这个二维数组有多少个一维数组
    由于每个元素指向的一维数组长度不是固定的，所以没有直接给出，可以在接下来的程序中动态的指定每个元素具体指向的是多少个元素的一维数组
    举例：
    int[][] arr = new int[3][];//在栈内存中定义一个变量，指向堆内存中的一个数组
    arr[0] = new int[2];    //被指向的数组的第一个元素指向另一个长度为2的一维数组
    arr[1] = new int[1];    //被指向的数组的第二个元素指向另一个长度为1的一维数组
    arr[2] = new int[3];    //被指向的数组的第三个元素指向另一个长度为3的一维数组

静态初始化

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

二维数组的遍历

动态初始化

    class ArrayTest {
        public static void main(String[] args) {
            //定义二维数组变量arr指向有四个一维数组的二维数组
            int[][] arr= new int[4][];
            //对二维元素赋值 ，动态指定每个元素指向一维数组
            arr[0] = new int[4];
            arr[1] = new int[3];
            arr[2] = new int[3];
            arr[3] = new int[2];
            print2DArr(arr);//调用方法
        }
        //自定义打印方法
        public static void sop(int cont){
            System.out.print(cont);
        }
        //自定义方法打印二维数组
        public static void print2DArr(int[][] arr){
            for(int i = 0;i<arr.length;i++){
                for(int j = 0;j<arr[i].length;j++){
                    sop(arr[i][j]);
                }
                System.out.println();//内循环完换行
            }
        }
    }

静态初始化

    public class ArrayTest1 {
        public static void main(String[] args) {
            int[][] arr = new int[][]{{1},{1,2},{3,4,5},{6,7,8,9},{10,11,12,13,14}};
            print2DArr(arr);//调用打印二维数组方法
        }
        //自定义打印方法
        public static void sop(int cont){
            System.out.print(cont+" ");
        }
        //自定义方法打印二维数组
        public static void print2DArr(int[][] arr){
            for(int i = 0;i<arr.length;i++){
                for(int j = 0;j<arr[i].length;j++){
                    sop(arr[i][j]);
                }
                System.out.println();//内循环完换行
            }
        }
    }

数组练习

定义一个int数组，5个元素，从键盘输入5个int值，保存到这个数组中，然后编写三个方法：分别用来对一个int型数组求最大值，最小值，平均值（注意返回值类型），调用这三个方法对输入的数组进行计算。

    import java.util.Scanner;
    class HomeWork1 {
        public static void main(String[] args) {
            Scanner s = new Scanner(System.in);
            System.out.println("请输入第一个整数：");
            int num1= s.nextInt();
            System.out.println("请输入第二个整数：");
            int num2= s.nextInt();
            System.out.println("请输入第三个整数：");
            int num3= s.nextInt();
            System.out.println("请输入第四个整数：");
            int num4= s.nextInt();
            System.out.println("请输入第五个整数：");
            int num5= s.nextInt();
            int[] arr ={num1,num2,num3,num4,num5};
            int sum = sum(arr);
            int min = min(arr);
            double avg = avg(arr);
            sop("他们的和为："+sum);
            sop("他们的最小值："+min);
            sop("他们的平均值："+avg);

        }
        //定义方法对数组求和，有返回值
        public static int sum(int[] arr){
            int sum = 0;
            for (int i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            return sum;
        }
        //自定义打印方法
        public static void sop(Object cont){
            System.out.println(cont);
        }
        //定义方法求最小值
        public static int min(int[] arr){
            int min = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if(min > arr[i]){
                    min = arr[i];
                }
            }
            return min;
        }
        //定义方法求平均值
        public static double avg(int[] arr){
            int sum = sum(arr);
            double avg = sum/5;
            return avg;
        }
    }

某公司按照季度和月份统计的数据如下：单位(万元)

第一季度：22,66,44 第二季度：77,33,88 第三季度：25,45,65 第四季度：11,66,99 要求使用二维数组保存所有季度的数据，然后遍历求出和。

    class HomeWork2 {
        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 < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    sum += arr[i][j];
                }
            }
            System.out.println("总和为："+sum);
        }
    }