Java编程基础06——数组

1.数组概述和定义格式说明

A:为什么要有数组(容器)：为了存储同种数据类型的多个值
B:数组概念：数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器；数组既可以存储基本数据类型，也可以存储引用数据类型。
C:数组定义格式：数据类型[] 数组名 = new 数据类型[数组的长度];

public class Demo_Array { //数组array

public static void main(String[] args) {
    int x = 10;
    x = 20;
    System.out.println(x);
    //    数据类型[] 数组名 = new 数据类型[数组的长度];
    int[] arr = new int[5];               //动态的定义数组，长度为五；在内存中开辟5块连续的空间
    /*
    左边：
    int    代表数组的数据类型，
    []    代表有几个中括号，就代表几维数组；
    arr    数组名，只要是合法的标识符。

    右边：
    new    代表的是创建新的实体或对象，
    int    数组的数据类型
    []    代表有几个中括号，就代表几维数组；
    5    代表的是数组的长度
    */
    System.out.println(arr);
}

}

2.数组的初始化动态初始化(掌握)

A:什么是数组的初始化
- 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
B:如何对数组进行初始化
- a:动态初始化只指定长度，由系统给出初始化值
- 基本数据类型的默认初始化值:
- byte short int long : 0
- float double : 0.0
- boolean : false
- char :'u0000' unicode :char在内存中占两个字节,即16个二进制位; u0000,每一个0代表的是16进制的0:那么4个0就代表16个二进制位
- 引用数据类型的默认初始化值:null
- int[] arr = new int[5];
- b:静态初始化给出初始化值，根据值的个数由系统决定长度
C:动态初始化的格式：
- 数据类型[] 数组名 = new 数据类型[数组长度];
D:案例演示
- 输出数组名称和数组元素

[I@61064425
[        代表的是数组，有几个‘[’就代表几维数组
I        代表的是数据类型 int
@        是固定的
1064425 代表的是十六进制的地址值

class Demo_Array {  //数组array
    public static void main(String[] args) {
        // a:动态初始化 只指定长度，由系统给出初始化值
        int [] arr = new int[5];   //动态的定义数组：5代表的是在计算机内存中开辟的连续的五块空间
        System.out.println(arr[0]);
        arr[0] = 10;               //显式的赋值
        System.out.println(arr[0]);
        System.out.println(arr);   //返回结果[I@61064425
    }
}

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

A:栈(掌握)：存储局部变量，定义在方法声明上或者方法中的变量;
B:堆(掌握)：存储new出来的数组或对象
C:方法区：面向对象部分讲解
D:本地方法区：和系统相关
E:寄存器：给CPU使用

4.数组的内存图解(掌握)

一个数组
二个不同的数组
三个引用，有两个数组的引用指向同一个地址

图片描述

class Demo_Array{
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        arr[0] = 10;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr);
        
    }
}

class Demo_Array{
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        int[] arr2 = new int[5];
        int[] arr3 = arr2;
        System.out.println(arr1);
        System.out.println(arr2);
        System.out.println(arr3);
        arr1[0] = 10;
        arr1[1] = 20;
        arr2[1] = 30;
        arr3[1] = 40;
        arr3[2] = 50;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println("----------------");
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);
        System.out.println(arr2[4]);
        System.out.println("----------------");
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        System.out.println(arr3[4]);    
    }
}
方法是栈内存的:先进后出 栈帧 压栈 弹栈

5.数组的初始化静态初始化及内存图(掌握)

静态初始化给出初始化值，根据值的个数由系统决定长度
A:静态初始化的格式：
- 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
- 简化格式：
  - 数据类型[] 数组名 = {元素1,元素2,…};
B:案例演示
- 对数组的解释
- 输出数组名称和数组元素
C:画图演示
- 一个数组

class Demo_Array{
    public static void main(String[] args) {
        //int [] arr = new int[]{11,22,33,44,55};   //静态创建数组
        int [] arr2 = {11,22,33,44,55};

        //int [] arr;
        //arr = new int[]{11,22,33,44,55};

        //int [] arr2;                //简写格式：必须是声明与赋值写在同一行
        //arr2 = {11,22,33,44,55};


        System.out.println(arr2);
        System.out.println(arr2[0]);
    }
}

6.数组操作的两个常见小问题越界和空指针(掌握)

A:案例演示
- a:ArrayIndexOutOfBoundsException:数组索引越界异常
  - 原因：你访问了不存在的索引。
- b:NullPointerException:空指针异常
  - 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
  - int[] arr = {1,2,3};
  - arr = null;
  - System.out.println(arr[0]);

class Demo_Array{
    public static void main(String[] args) {
        int [] arr = {11,22,33,44,55};
            //System.out.println(arr[6]);  //当访问数组不存在的索引时，就会出现数组索引越界异常：arrayIndexOutOfBoundsException
            arr = null;
            System.out.println(arr[1]);
    }
}

7.数组的操作1遍历(掌握)

A:案例演示
- 数组遍历：就是依次输出数组中的每一个元素。
- 数组的属性:arr.length数组的长度
- 数组的最大索引:arr.length - 1;

public static void print(int[] arr) {
            for (int i = 0;i < arr.length ;i++ ) {
                System.out.print(arr[i] + " ");
            }
}

class Demo_Array{
    public static void main(String[] args) {
        int [] arr = {11,22,33,44,55,66,77};    //0x0011
            /*
            遍历数组
            1.明确返回值类型  void
            2.明确参数列表    int[] arr            
            */
            print(arr);        //arr = 0x0011
    }
    public static void print(int[] a) {  //a = 0x0011
        for (int i = 0 ;i < 7 ; i ++) {
            System.out.println(a[i]);
        }
    }
}

8.数组的操作2获取最值(掌握)

A:案例演示
- 数组获取最值(获取数组中的最大值最小值)

class Demo_Array{
    public static void main(String[] args) {
        int [] arr = {44,22,33,11,55,66,22};    //0x0011
        int length = arr.length;
        System.out.println(length); //println(arr.length);
            /*
            获取数组中的最大值
            1.返回值类型  int
            2.明确参数列表    int[] arr            
            */
        int max1 = getMax(arr);
        System.out.println("max1 = " + max1);
    }
    public static int getMax(int [] arr) {
        int max = arr[0];                                //定义变量max ：用来记录最大值得
        for (int i = 1;i < arr.length ; i ++ ) {        //遍历数组，获取从1索引到最大索引
            if (max < arr[i]) {                            //如果数组中的其他元素比max大
                max = arr[i];                            //就将该元素赋值给max
            }
        }
        return max;
    }
}

9.数组的操作3反转(掌握)

A:案例演示
- 数组元素反转(就是把元素对调)

class Demo_Array{
    public static void main(String[] args) {
        int [] arr = {11,22,33,44,55,66,77};
        reverseArray(arr);
        print(arr);
    }
    /*
    数组的元素反转
    1.返回值类型 void
    2.参数列表 int[] arr
    */
    public static void reverseArray(int [] arr) {
        for (int i = 0;i < arr.length / 2 ; i ++ ) {
            /*
            arr[0] 与 arr[arr.length - 1 - 1]进行对调
            arr[1] 与 arr[arr.length - 1 - 1]进 行对调
            arr[1] 与 arr[arr.length - 1 - 2]进行对调
            ...
            arr[i] 与 arr[arr.length - 1 - i]进行对调
            */
            int temp;
            temp = arr[i];
            arr[i] = arr[arr.length -1-i];
            arr[arr.length-1-i] = temp;
        }
    }
    /*
    遍历数组
    1.返回值类型 void
    2.参数列表 int[] arr
    */

    public static void print(int [] arr) {
        for (int i = 0 ;i < arr.length ; i ++ ) {
            System.out.print(arr[i] + " ");
        }
    }
}

10.数组的操作4查表法(掌握)

A:案例演示
- 数组查表法(根据键盘录入索引,查找对应星期)

import java.util.Scanner;
class Demo_Array{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期，范围是1-7：");
        int index = sc.nextInt();
        System.out.println("星期" + getWeek(index));
    }

    /*
    根据键盘录入索引,查找对应星期
    1.返回值类型 char
    2.参数列表 int week
    */
    public static char getWeek(int week) {
        char[] arr = {' ','一','二','三','四','五','六','日'};//定义了一张星期表
        return arr[week];//通过索引获取表中的元素
    }
}

11.数组的操作5基本查找(掌握)

A:案例演示
- 数组元素查找(查找指定元素第一次在数组中出现的索引)

class Noname1{
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66};
        int value = getIndex(arr,66);
        System.out.println(value);
    }
    /*
    数组元素查找（查找指定元素第一次在数组中出现的索引）
    1.返回值类型 int
    2.参数列表 int [] arr，int value
    */
    public static int getIndex(int[] arr,int value) {
        for (int i = 0; i < arr.length ;i ++ ) {//数组的遍历
            if (arr[i] == value) {
                return i;//如果数组中的元素与查找的元素匹配
            }
        }
        return -1;                    //if,for,while都有可能不满足的时候，必须注意
    }
}

12.二维数组概述和格式1的讲解(了解)

A:二维数组概述
B:二维数组格式1
- int[][] arr = new int3;
C:二维数组格式1的解释
D:注意事项
- a:以下格式也可以表示二维数组
  - 1:数据类型数组名[][] = new 数据类型m;
  - 2:数据类型[] 数组名[] = new 数据类型m;
- B:注意下面定义的区别
- ```
int x;
int y;
int x,y;

int[] x;
int[] y[];

int[] x,y[];    x是一维数组,y是二维数组
```
E:案例演示
- 定义二维数组，输出二维数组名称，一维数组名称，一个元素

13.二维数组格式1的内存图解(了解)

A:画图演示
- 画图讲解上面的二维数组名称，一维数组名称，一个元素的

class Demo_Array{
        public static void main(String[] args) {
            int[][] arr = new int[3][2];
            System.out.println(arr);    //二维数组的地址值
            System.out.println(arr[0]);    //打印二维数组中的第一个一维数组的地址值
            System.out.println(arr[0][0]);    //打印二维数组中的第一个一维数组的第一个元素
        }

}

14.二维数组格式2的讲解及其内存图解(了解)

A:二维数组格式2
- int[][] arr = new int[3][];
B:二维数组格式2的解释
C:案例演示
- 讲解格式，输出数据，并画内存图
  //这是一个二维数组;这个二维中有三个一维数组;三个一维数组都没有被初始化.
  System.out.println(arr[0]);
  System.out.println(arr[1]);
  System.out.println(arr[2]);
  arr[0] = new int[3]; //第一个一维数组中可以存在3个int值
  arr[1] = new int[5]; //第一个一维数组中可以存在5个int值
  System.out.println("--------------");
  System.out.println(arr[0]);
  System.out.println(arr[1]);
  System.out.println(arr[2]);

class Demo_Array{
    public static void main(String[] args) {
        //这是一个二维数组，二维数组中有三个一位数组，每一个一维数组并没有进行初始化定义
        int[][] arr = new int[3][];
        arr[0] = new int[3];   //将二维数组中的第一个一维数组进行动态初始化；3代表一维数组里面可以存储三个元素
        arr[1] = new int[5];

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

        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println("--------------------");
        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[1][3]);
        System.out.println(arr[1][4]);
        System.out.println("--------------------");
        System.out.println(arr[2][0]);
    }  
}

15.二维数组格式3的讲解及其内存图解(了解)

A:二维数组格式3
- int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
B:二维数组格式3的解释
C:案例演示
- 讲解格式，输出数据，并画内存图
  //这是一个二维数组,二维数组中每一个大括号都代表着一维数组
  int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
  System.out.println(arr); //[[I@15db9742 二维数组地址值
  System.out.println(arr[0]); //[I@6d06d69c 一维数组地址值
  System.out.println(arr0); //1 一维数组中的元素值

class Demo_Array{
        public static void main(String[] args) {
            //这是一个二维数组，二维数组有三个一维数组，第一个一维数组存储三个元素，后同；
            int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; 
            System.out.println(arr);        //二维数组的地址值；
            System.out.println(arr[0]);        //二维数组中的第一个一维数组的地址值；
            System.out.println(arr[0][2]);    //输入的是二维数组中的第一个数组中的第一个元素值；
        }
}

16.二维数组练习1遍历(掌握)

A:案例演示
- 需求：二维数组遍历
- 外循环控制的是二维数组的长度，其实就是一维数组的个数。
- 内循环控制的是一维数组的长度。

int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
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();
}
class Demo_Array{
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; 
        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();
        }
    }
}

17.二维数组练习2求和(掌握)

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

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 = sum + arr[i][j];                    //累加
    }
}
System.out.println(sum);

class Demo_Array{
    public static void main(String[] args) {
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}}; 
        int sum = 0;                    //声明一个变量sum,用来累加每一个元素
        for (int i = 0;i < arr.length ;i ++ ) {
            for (int j = 0;j < arr[i].length ; j ++ ) {
                sum = sum + arr[i][j];
            }
        }
        System.out.print(sum);
    }
}

18.思考题Java中的参数传递问题及图解(掌握)

A:案例演示(先前学的都是基本数据类型,那么数组是引用数据类型,那就看下基本数据类型和引用数据类型的参数传递问题~)
看程序写结果，并画内存图解释
基本数据类型的值传递

class Demo_Array{
        /*
        基本数据类型的值传递，不改变原值，因为方法调用后就会弹栈，而局部变量随之消失
        */
        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 ;

        public static void change(int a,int b) {  
        System.out.println("a:"+a+",b:"+b);
        a = b;
        b = a + b;
        System.out.println("a:"+a+",b:"+b);
        }
}
class Demo_Array{
        public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]);
        }
        public static void change(int[] arr) {
            for(int x=0; x<arr.length; x++) { //1,4,3,8,5
                if(arr[x]%2==0) {
                    arr[x]*=2; //arr[x] = arr[x] * 2
                }
            }
        }
}

基本数据类型的值传递，不改变原值，因为方法调用后就会弹栈，而局部变量随之消失
引用数据类型的值传递，改变原值，因为即使方法调用后弹栈，但是堆内存中的数组对象还在，可以通过地址引用继续访问。
java中只有传值，因为地址值也是只，支持者是java之父高思林。

Java编程基础06——数组

1.数组概述和定义格式说明

2.数组的初始化动态初始化(掌握)

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

4.数组的内存图解(掌握)

5.数组的初始化静态初始化及内存图(掌握)

6.数组操作的两个常见小问题越界和空指针(掌握)

7.数组的操作1遍历(掌握)

8.数组的操作2获取最值(掌握)

9.数组的操作3反转(掌握)

10.数组的操作4查表法(掌握)

11.数组的操作5基本查找(掌握)

12.二维数组概述和格式1的讲解(了解)

13.二维数组格式1的内存图解(了解)

14.二维数组格式2的讲解及其内存图解(了解)

15.二维数组格式3的讲解及其内存图解(了解)

16.二维数组练习1遍历(掌握)

17.二维数组练习2求和(掌握)

18.思考题Java中的参数传递问题及图解(掌握)

扎瓦

引用和评论

JavaWEB开发21——综合项目(图书商城)

在Java程序中监听mysql的binlog

Activiti7实战笔记

Just for fun——迅速写完快速排序

Java自定义注解实现简单的权限认证

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊

Java编程基础06——数组

1.数组概述和定义格式说明

2.数组的初始化动态初始化(掌握)

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

4.数组的内存图解(掌握)

5.数组的初始化静态初始化及内存图(掌握)

6.数组操作的两个常见小问题越界和空指针(掌握)

7.数组的操作1遍历(掌握)

8.数组的操作2获取最值(掌握)

9.数组的操作3反转(掌握)

10.数组的操作4查表法(掌握)

11.数组的操作5基本查找(掌握)

12.二维数组概述和格式1的讲解(了解)

13.二维数组格式1的内存图解(了解)

14.二维数组格式2的讲解及其内存图解(了解)

15.二维数组格式3的讲解及其内存图解(了解)

16.二维数组练习1遍历(掌握)

17.二维数组练习2求和(掌握)

18.思考题Java中的参数传递问题及图解(掌握)

扎瓦

引用和评论

JavaWEB开发21——综合项目(图书商城)

在Java程序中监听mysql的binlog

Activiti7实战笔记

Just for fun——迅速写完快速排序

Java自定义注解实现简单的权限认证

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊