第六天笔记

第六天笔记

1复习 数组概述与格式

A:为什么要有数组

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

B:数组概念

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

C:数组定义格式

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

public class MyDemo {
    //ctrl+alt+空格 可以手动提示
    public static void main(String[] args) {
        //方法：对一段功能逻辑的封装，以实现重复调用，提高代码的复用性。
        //1.方法定义在类中
        //2.方法跟方法是平级关系，不能嵌套定义。
        //3.方法不调用不执行。
        //retrun 结束并返回，如果方法明确了返回值类型，那么必须由retrun带回一个与明确类型一致的结果。
        //如果是void 那么retrun可以省略不写。
        //你以后定义一个方法，要明确两个东西 返回值 参数
        //方法重载：允许一个类中，定义多个同名方法，只要他们的参数个数或参数类型不同即可。跟返回值类型没关系。
        //数组：是一个容器，可以存储多个相同数据类型的元素。
        //数组即可以存储基本数据类型，也可以存储引用数据类型
        //引用数据类型：数组 类 接口 等
        //数组必须初始化才能使用。
        //所谓初始化，就是为数组开辟内存空间，并未数组元素赋值。
      /*  B:
        初始化的分类：
        a:
        动态初始化:
        只指定长度，由系统给出初始化值
        b:
        静态初始化:
        给出初始化值，由系统决定长度

        数组的元素会编有索引，从0开始。
        我们根据索引可以获取数组元素的值，也可以给数组元素重新赋值。
        */
    }
}

2.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使用)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cA6mxAXk-1586269380272)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1586268828927.png)]

3数组的初始化

A:什么是数组的初始化

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

B:初始化的分类：

​ a:动态初始化: 只指定长度，由系统给出初始化值
​ b:静态初始化: 给出初始化值，由系统决定长度
​ 注意事项： 这两种方式，只能使用一种，不能进行动静结合

C:动态初始化的格式：

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

D：案例演示

​ 输出数组名称和数组元素

动态初始化

public static void main(String[] args) {
    //数组的动态初始化
    int[] arr=new int[3];
    //方式2 不推荐
    //int arr2[] = new int[3];
}

数组的静态初始化

A:静态初始化的格式：

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

B:画图演示

​ a：定义一个数组，输出数组名称和数组中的元素值

public static void main(String[] args) {
    //数组的静态初始化:由系统计算长度，由我们给元素赋值
    int[] arr=new int[]{10,20,30,40,50};
    System.out.println(arr);
    arr[0]=100;
    System.out.println(arr[0]);
    System.out.println(arr[4]);
    //数组的静态初始化 简写语法  省略掉new
    int[] arr2 = {10, 20, 30, 40, 50};
}

3数组的内存分配（一个数组、两个数组、三个数组）

A:定义一个数组，输出数组名称和数组中的元素值，给数组赋值，再次输出数组名称和数组中的元素值
B:定义两个数组，分别输出数组名称和数组中的元素值，分别给两个数组赋值，再次输出数组名称和数组中的元素值J
C:定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。
最后，再次输出第一个数组数组名称和元素。

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 one=arr[0];
    int two = arr[1];
    int three = arr[2];
    System.out.println(one);
    System.out.println(two);
    System.out.println(three);
}

public static void main(String[] args) {
    int[] arr1 = new int[3];
    System.out.println(arr1);
    arr1[0]=200;

    int[] arr2 = new int[3];
    System.out.println(arr2);
    arr2[1]=300;

    System.out.println(arr1[0]);//200
    System.out.println(arr1[1]); //0
    System.out.println(arr1[2]); //0

    System.out.println(arr2[0]);//0
    System.out.println(arr2[1]);//300
    System.out.println(arr2[2]);//0
}

public static void main(String[] args) {
    int[] arr1=new int[3];
    arr1[0]=10;
    arr1[1] = 20;
    arr1[2] = 30;
    int[] arr2 = new int[3];
    arr2[0] = 100;
    arr2[1] = 200;
    arr2[2] = 300;
    int[] arr3=arr1;//在数组内存图中，arr3 new出的东西指向arr1的地制值
    arr3[0]=60;
    arr3[1]=500;
    System.out.println(arr1[0]); //60
    System.out.println(arr1[1]); //500
    System.out.println(arr1[2]); //30
    System.out.println("=============================");
    System.out.println(arr2[0]); //100
    System.out.println(arr2[1]); //200
    System.out.println(arr2[2]); //300
    System.out.println("=============================");
    System.out.println(arr3[0]); //60
    System.out.println(arr3[1]); //500
    System.out.println(arr3[2]); //30

    System.out.println("====================");
    //输出数组的地址值
    System.out.println(arr1);
    System.out.println(arr2);
    System.out.println(arr3);
    //判断两个地址值是否相等
    System.out.println(arr1==arr3);
}

4数组的越界和空指针问题

A:案例演示

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

public static void main(String[] args) {
    //数组角标越界问题
    //数组一旦定义，那么数组的长度 就不可变化了。
    //当你访问了没有对应角标的元素，你会出现角标越界
    int[] arr=new int[2];//0 1
    //ArrayIndexOutOfBoundsException 数组角标越界异常
    //arr[2]=200; //报错
    //ArrayIndexOutOfBoundsException 数组角标越界异常
   // System.out.println(arr[10]); 报错
    System.out.println("==========================");
    //空指针异常:NullPointerException 空指针异常
    arr = null; //把数组引用人为置null
    //arr就指向不到，堆内存的那块空间了
    System.out.println(arr.length); //报空指针异常
    arr[0]=100;
    //如果放在最后，也就是数组用完之后置空,可以让垃圾回收器及早的回收数组的这块空间
   // arr = null; //把数组引用人为置null
}

5获取数组中的最大值、最小值

public static void main(String[] args) {
    //获取数组中的最大值或最小值
    int[] arr = {200, 2100, 300, 800, 8000, -1, 100, 6000, 50};
  /*  int[] arr = {200,1200};
    //获取数组中的最大值
    int max=arr[0]>arr[1]?arr[0]:arr[1];
    System.out.println(max);*/

    //定义一个参照的数
    int max = arr[0]; //200
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) { //2100>200
            max = arr[i]; // max=8000
        }
    }
    System.out.println("最大值是" + max);

    System.out.println("======================");
    int min = arr[0]; //200
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    System.out.println("最小值是" + min);

}

6数组的默认属性和数组遍历

public static void main(String[] args) {
    //数组的一个默认属性 length 可以获取数组长度
    int[] arr=new int[3];
    arr[arr.length-1]=100;
    //length 数组自带的一个属性，可以动态获取数组的长度
    int len=arr.length;
    System.out.println(len);

    //获取数组的最后一个元素
    System.out.println(arr[2]);
    //数组最后一个元素的索引=数组的长度-1
    System.out.println(arr[arr.length-1]);
}

数组遍历

public static void main(String[] args) {
    int[] arr={100,200,300,400,500,600,700};
    //获取数组中每一个元素
   /* System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);*/
   //通过循环，去获取数组中的每一个元素，也叫做数组的遍历
    //arr.length.fori 数组遍历快速生成
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
    System.out.println("==========================");
    //数组的反向遍历   arr.length-1.forr 反向遍历快速生成
    for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
    }
}

7数据反转

public static void main(String[] args) {
    //1.反转数组中的元素
    int[] arr={50,100,200,300,400,500,600,700};
    //600 500 400 300 200 100
    //思路：遍历一半，首位尾元素交换值  采用中间变量来交换值
    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;
    }
    System.out.println("=================================");
    //遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+",");
    }
}

8根据键盘录入索引查找对应元素

public static void main(String[] args) {
   /* A:
    案例演示:
    数组查表法(根据键盘录入索引, 查找对应星期)
    //根据索引找对应的元素
    */
   String[] week={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入索引 0-6");
    int index= scanner.nextInt();
    String ele=getElement(index,week);
    System.out.println(ele);
}

private static String getElement(int index, String[] week) {
    if(index>=0&&index<=6){
        String str = week[index];
        return str;
    }else{
        return "你乱输入，没有查到";
    }
}

9根据元素查对应索引

public static void main(String[] args) {
    String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
    //根据元素查对应的索引
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入星期 星期一--------星期日");
    //录入字符串的方法
    String s = scanner.nextLine();
    int index=getIndex(s,week);//方法调用
    System.out.println("该元素对应的索引是："+index);
}

private static int getIndex(String s, String[] week) {
    int index=-1;
    for (int i = 0; i < week.length; i++) {
        if(week[i].equals(s)){ //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
           index=i;
           break;
        }
    }
    return index; //-1 就代表没找到
}

private static int getIndex2(String s, String[] week) {

    for (int i = 0; i < week.length; i++) {
        if (week[i].equals(s)) { //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
           return i;
        }
    }
    return -1; //-1 就代表没找到
}
     if(week[i].equals(s)){ //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
           index=i;
           break;
        }
    }
    return index; //-1 就代表没找到
}

private static int getIndex2(String s, String[] week) {

    for (int i = 0; i < week.length; i++) {
        if (week[i].equals(s)) { //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
           return i;
        }
    }
    return -1; //-1 就代表没找到
}