fourarray数组

 

数组的概念和数组变量的定义【重点】
数组的初始化及使用【重点的重点】        ---------------最核心的内容--------------
数组的内存图【理解】
数组的练习【重点的重点】               ---------------最核心的内容--------------
数组的常见问题【理解】
​
快捷键：
    生产输出语句： 表达式.sout
    数组遍历:
        数组名.fori: 正着遍历
        数组名.forr: 倒着遍历

第一章 数组定义和访问【理解】

1.1 容器的概念

一个变量中只能存储一个数据,新的数据进来,老的数据将被替换,如果需要存储多个数据,需要使用容器(大的容器)
​
容器概念
    容器：是将多个数据存储到一起，每个数据称为该容器的元素。
    生活中的容器：水杯，衣柜，鞋柜, 教室
​
数组：
    1.概念: java中的数组就是一个容器,可以存储多个数据,但是多个数据的类型必须保持一致
    2.特点:
        (1)可以存储多个数据
        (2)多个数据的类型必须保持一致
        (3)数组的长度一旦确定,将永远不可以发生改变
            
public class Demo01Box {        //------此代码不用敲------
    public static void main(String[] args) {
        
        //比如我们班有80个学生需要参加考试,每个学生对应一个成绩(整数)
        //可以定义80个int变量
        int a = 80;
        int b = 90;
        int c = 70;
        int d = 50;
        int e = 85;
        int f = 95;
        int g = 59;
        int h = 63;
​
        //需要求总分
        int sum = a + b + c + d + e + f + g + h;
​
        //需要求平均分
        int avg = sum/80;
​
        //需要求最高分和最低分: 实现起来非常麻烦
               
    }
}
           

1.2 数组变量的定义

数组变量的概念: 
​
1.数组变量定义格式一：        推荐使用
    数据类型[] 数组名称;
    
2.数组变量定义格式二：        不推荐使用的
    数据类型 数组名称[];
        
3.练习:
    (1)定义一个存储int类型数组的变量arrayA
    (2)定义一个存储double类型数组的变量arrayB
    (3)定义一个存储char类型数组的变量arrayC
​
4.关于 int[] arrayA的理解:
    (1)这里只是定义一个可以存储一个int数组容器的变量,但是没有向该变量中存储数组容器
    (2)相当于教室的门牌号,但是该门牌号并没有对应的教室

public class Demo02ArrayVar {
    public static void main(String[] args) {
                
        //(1)定义一个存储int类型数组的变量arrayA
        //int类型数组: 就是一个存储int数据的数组容器
        int[] arrayA;
        
        //(2)定义一个存储double类型数组的变量arrayB
        //double类型数组: 就是一个存储double数据的数组容器
        //double[] arrayB;
        double arrayB[];//不推荐
        
        //(3)定义一个存储char类型数组的变量arrayC
        //char类型数组: 就是一个存储char数据的数组容器
        char[] arrayC;
    }
}
​

 

1.3 数组的第一种初始化方式

数组的第一种初始化方式(动态初始化: 指定数组长度)
    1.格式:       
        数据类型[] 数组名称 = new 数据类型[长度];
  
    2.格式解释:     
        (1)左侧数据类型: 表示该数组容器中可以存储什么类型的数据
        (2)左侧[]: 代表数组的意思
        (3)数组名称: 就是一个标识符,方便使用数组
        (4)=: 表示赋值的意思,把=号右侧的数组容器在内存中的地址值,赋值给=号左侧的数组变量
        (5)new: JVM在内部创建数组的过程
        (6)右侧数据类型: 和左侧保持一致
        (7)长度: 规定了数组容器中可以存储多少个数据
        
    3.练习:
        (1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayA
        (2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayB
        (3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayC      
 

public class Demo03ArrayInit {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayA
        int[] arrayA = new int[3];
​
        //(2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayB
        double[] arrayB = new double[7];
​
        //(3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayC
        char[] arrayC = new char[5];
    }
}
​

1.4 数组的第二种初始化方式

数组的第二种初始化方式(标准格式静态初始化: 指定元素)
1.格式:
     数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,...,元素n}; 
​
2.注意:       
    (1)右侧{}中的数组元素之间使用逗号(,)隔开,最后一个元素后面没有逗号
    (2)右侧[]中不能写长度,只要写就报错,JVM会根据{}中元素的个数推导数组的长度
    
3.练习:
    (1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
    (2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
    (3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
             

public class Demo04ArrayInit {
    public static void main(String[] args) {
        //(1) 创建一个int类型的数组, 存储多个int数据100, 200, 300, 给该数组起个名称叫做arrayA
        int[] arrayA = new int[]{100, 200, 300};
​
        //(2) 创建一个double类型的数组, 存储多个double数据1.1, 2.2, 3.3, 4.4, 给该数组起个名称叫做arrayB
        double[] arrayB = new double[]{1.1, 2.2, 3.3, 4.4};
​
        //(3) 创建一个char类型的数组, 存储多个char数据 '真', '的', '好', '想', '你', 给该数组起个名称叫做arrayC
        char[] arrayC = new char[]{'真', '的', '好', '想', '你'};
    }
}
​

1.5 数组的第三种初始化方式

数组的第三种初始化方式(简化格式静态初始化: 指定元素)
1.格式:   	
	数据类型[] 数组名称 = {元素1,元素2,...,元素n};	

2.练习:
	(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
	(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
	(3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC

3.注意:
  	(1)右侧{}中的数组元素之间使用逗号(,)隔开,最后一个元素后面没有逗号
    (2)不能写长度,只要写就报错,JVM会根据{}中元素的个数推导数组的长度
    (3)虽然没有写new,但是底层仍然有new的过程,完成数组的创建
    (4)动态初始化和标准格式的静态初始化数组,可以分成两步完成
    (5)简化格式静态初始化,只能一步完成,不可以分成两步(java中的用法规定)

public class Demo05ArrayInit {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,存储多个int数据100,200,300,给该数组起个名称叫做arrayA
        int[] arrayA = {100, 200, 300};

        //(2)创建一个double类型的数组,存储多个double数据1.1,2.2,3.3,4.4,给该数组起个名称叫做arrayB
        double[] arrayB = {1.1, 2.2, 3.3, 4.4};

        //(3)创建一个char类型的数组,存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
        char[] arrayC = {'真', '的', '好', '想', '你'};

        int num;
        num = 100;
        System.out.println(num);
        num = 200;
        System.out.println(num);

        //----------------以下内容作为了解--------------------
        //(4)动态初始化和标准格式的静态初始化数组,可以分成两步完成
        int[] arr;
        arr = new int[3];//动态初始化
        //....
        arr = new int[]{10,20,30,50,80};//标准格式静态初始化

        //arr = {100,200,300,500};//错误的: 不允许

        int[] arr2 = {100,200,300,500};
    }
}

1.6 数组的使用

/*
    数组的使用:
        1.数组名称: 代表数组在内存空间中的地址值,是一个十六进制的int数字

        2.索引编号:
            (1)数组中的每个数据,称为数组元素
            (2)数组为其内部的每个元素进行编号,专业术语叫做索引(角标),从0开始到数组长度减1
            (3)索引编号必须是一个>=0的int数据

        3.数组元素的访问:
            数组名称[索引编号];
            array[0]: 代表数组array中索引编号为0的元素
            array[2]: 代表数组array中索引编号为2的元素

        4.获取数组长度(数组中可以存储元素的个数)
            每个数组内部都有一个length属性,其实就是一个int变量,记录了该数组中可以存储的元素的数量
            使用格式:
                数组名称.length: 获取数组长度,其实一个int数字
                注意:
                    length后面没有(),添加()是错误的

 */
public class Demo01ArrayUse {
    public static void main(String[] args) {
        int num = 100;

        //定义int数组array,并采用标准格式静态初始化
        int[] array = new int[]{100, 200, 300};//100的索引编号是0,200的索引编号是1,300的索引编号是2

        System.out.println(array);//地址值: [I@1540e19d

        //打印100
        System.out.println(array[0]);//打印数组array中索引编号为0的元素: 100

        //打印200
        System.out.println(array[1]);//打印数组array中索引编号为1的元素: 200

        //打印300
        System.out.println(array[2]);//打印数组array中索引编号为2的元素: 300

        //把100改成1000
        //把int数字1000,存储到数组array中的索引编号为0的元素中,原有的数据100将被替换/覆盖
        array[0] = 1000;

        //把200改成2000
        //把int数字2000,存储到数组array中的索引编号为1的元素中,原有的数据200将被替换/覆盖
        array[1] = 2000;

        //把300改成3000
        //把int数字3000,存储到数组array中的索引编号为2的元素中,原有的数据300将被替换/覆盖
        array[2] = 3000;

        System.out.println("-------------");
        System.out.println(array[0]);//打印数组array中索引编号为0的元素: 1000
        System.out.println(array[1]);//打印数组array中索引编号为0的元素: 2000
        System.out.println(array[2]);//打印数组array中索引编号为0的元素: 3000

        System.out.println("-------------");
        //获取数组长度
        int size = array.length;//获取数组长度,保存到int变量size中
        System.out.println("数组长度: "+size);//3
        System.out.println("数组长度: "+array.length);//3
        /*
            array[array.length-1]: 是在获取数组中的某个元素,[]中写必须是一个int数字
            但是目前没有直接写int数字,而是先获取数组长度,再把数组长度减1后的结果作为索引
            先计算array.length-1: 3-1 ==> 2
            然后array[array.length-1] ==> array[2] ==> 3000
         */
        System.out.println(array[array.length-1]);//3000
    }
}

第二章 数组练习【重点】

2.1 数组遍历

/*
    数组遍历：
        就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

    注意for循环的结束条件的两种写法:
        <=array.length - 1
        <array.length
 */
public class Demo01ArrayEach {
    public static void main(String[] args) {
        //定义int数组array,并采用简化格式初始化
        int[] array = {100, 200, 300};
        System.out.println(array);//地址值
        System.out.println(array[0]);//100
        System.out.println(array[1]);//200
        System.out.println(array[2]);//300
        System.out.println("------------");

        //以上代码重复,只有代表索引的int数字0,1,2是不同的
        //使用for循环获取代表索引的int数字0,1,2
        for (int i = 0; i < 3; i++) {
            System.out.println("索引编号: " + i + " 对应的元素值: " + array[i]);
        }
        System.out.println("------------");

        //以上for循环中,数字3写死了,可以使用数组的长度(array.length)代替
        for (int i = 0; i < array.length; i++) {
            //System.out.println("索引编号: "+i+" 对应的元素值: "+array[i]);
            System.out.println(array[i]);
        }
        System.out.println("------------");

        for (int i = 0; i <= array.length-1; i++) {
            System.out.println(array[i]);
        }
    }
}

2.2 求int数组元素和

/*
    需求:
        计算一个int数组的元素之和

    实现步骤:
        1.创建int数组array,并初始化
        2.定义int变量sum,初始值0,用来累加计算数组元素的和
        3.使用for循环遍历数组
        4.把数组中当前元素值累加到求和变量sum中
        5.for循环结束后,打印sum的值
 */
public class Demo04SumArray {
    public static void main(String[] args) {
        //1.创建int数组array,并初始化
        int[] array = {100, 200, 300, 400};

        //2.定义int变量sum,初始值0,用来累加计算数组元素的和
        int sum = 0;

        //3.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //4.把数组中当前元素值累加到求和变量sum中
            sum = sum + array[i];//sum += array[i]
        }
        //5.for循环结束后,打印sum的值
        System.out.println("数组元素和: " + sum);
    }
}

2.3 求int数组偶数和以及偶数的个数

/*
    扩展练习:
    有个int数组,内部存储元素 8,5,7,13,16,10,11,18,30,15,17
    要求:
        1.打印所有的偶数数字
        2.打印所有的偶数数字之和
        3.打印所有的偶数数字的个数
    实现步骤:
        1.创建int数组array,并初始化
        2.定义int变量sum,初始值0,用来累加偶数元素的和
        3.定义int变量count,初始值0,用来统计偶数元素的个数
        4.使用for循环变量数组array
        4.1 判断如果当前元素是偶数
        4.2 打印当前偶数元素
        4.3 把当前偶数元素累加到求和变量sum中
        4.4 计数器count的值增加1
        5.for循环结束后,打印sum和count的值
 */
public class Demo05SumCountArray {
    public static void main(String[] args) {
        //1.创建int数组array,并初始化
        int[] array = {8, 5, 7, 13, 16, 10, 11, 18, 30, 15, 17};

        //2.定义int变量sum,初始值0,用来累加偶数元素的和
        int sum = 0;

        //3.定义int变量count,初始值0,用来统计偶数元素的个数
        int count = 0;

        //4.使用for循环变量数组array
        for (int i = 0; i < array.length; i++) {
            //4.1 判断如果当前元素是偶数
            if (array[i] % 2 == 0) {
                //4.2 打印当前偶数元素
                System.out.println(array[i]);

                //4.3 把当前偶数元素累加到求和变量sum中
                sum += array[i];

                //4.4 计数器count的值增加1
                count++;
            }

        }
        //5.for循环结束后,打印sum和count的值
        System.out.println("所有的偶数元素和: " + sum);
        System.out.println("所有的偶数元素的个数: " + count);
    }
}

2.4 求三个int数字的最大值

/*
    需求:
        求三个int数字的最大值

    实现步骤:
       1.定义3个int变量a,b,c,并分别初始化
       2.假设变量a中的值是最大的,保存到int变量max中
       3.使用if判断,如果b的值大于max,说明max中的值已经不是最大的了
       3.1 把b的值赋值给max
       4.使用if判断,如果c的值大于max,说明max中的值已经不是最大的了
       4.1 把c的值赋值给max
       5.打印max的值
 */
public class Demo02Max {
    public static void main(String[] args) {
        //1.定义3个int变量a,b,c,并分别初始化
        int a = 100, b = 200, c = 300;

        //2.假设变量a中的值是最大的,保存到int变量max中
        int max = a;

        //3.使用if判断,如果b的值大于max,说明max中的值已经不是最大的了
        if (b > max) {
            //3.1 把b的值赋值给max
            max = b;
        }

        //4.使用if判断,如果c的值大于max,说明max中的值已经不是最大的了
        if (c > max) {
            //4.1 把c的值赋值给max
            max = c;
        }
        //5.打印max的值
        System.out.println("最大值: " + max);
    }
}

图解:

2.5 数组获取最大值元素

需求:
	求int数组元素最大值
        
实现步骤:
	1.定义int数组array,并根据题目需求进行初始化
	2.假设索引为0的元素是最大的,保存到int变量max中
	3.使用for循环依次获取后面(从索引1开始)的每个元素
	3.1 如果当前元素值 大于 max,说明max中已经不是最大的了
	3.2 把当前元素值,赋值给max
	4.for循环结束后,打印max的值	
	
注意:
	1.求数组最大值/最小值/求和/计数,这些变量必须在for循环的前面定义
	2.for循环内部完成计算
	3.for循环的后面进行打印输出

public class Demo03ArrayMax {
    public static void main(String[] args) {
        //1.定义int数组array,并根据题目需求进行初始化
        int[] array = {5, 15, 2000, 10000, 100, 4000};

        //2.假设索引为0的元素是最大的,保存到int变量max中
        int max = array[0];

        //3.使用for循环依次获取后面(从索引1开始)的每个元素
        for (int i = 1; i < array.length; i++) {
            //3.1 如果当前元素值 大于 max,说明max中已经不是最大的了
            if (array[i] > max) {
                //3.2 把当前元素值,赋值给max
                max = array[i];
            }
        }
        //4.for循环结束后,打印max的值
        System.out.println("最大值: "+max);
    }
}

图解分析:

执行流程:

第三章 数组原理内存图【理解】

3.1 java中的内存分配

1.方法区: 存储可以运行的class文件。
2.方法栈: 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
3.堆内存 存储对象或者数组，new来创建的，都存储在堆内存。
4.寄存器 给CPU使用，和我们开发无关							  不关心
5.本地方法栈 JVM在使用操作系统功能的时候使用，和我们开发无关。		不关心

今天主要使用:
	1.栈内存: 运行方法的,存储方法中定义的变量的
	2.堆内存: 存储的是所有new出来的内容
        

图解:

3.2 数组内存图

/*
    一个数组内存图
        1.动态初始化数组,元素有默认值
            (1)基本类型
                整数数组: 0
                小数数组: 0.0
                布尔数组: false
                字符数组: 空白字符
            (2)引用类型
                所有引用类型数组: null
        2.注意
            (1)数组变量保存数组在堆内存空间的地址值
            (2)通过数组变量中保存的地址值,找到堆内存空间的具体的数组
            (3)再通过索引编号,找到要操作的该数组中的具体的某个元素
 */
public class Demo01OneArray {
    public static void main(String[] args) {
        //定义int数组one,并动态初始化
        int[] one = new int[3];
        System.out.println(one);//地址值
        System.out.println(one[0]);//默认值:0
        System.out.println(one[1]);//默认值:0
        System.out.println(one[2]);//默认值:0

        one[0] = 100;
        one[1] = 200;
        one[2] = 300;

        System.out.println(one);//地址值
        System.out.println(one[0]);//100
        System.out.println(one[1]);//200
        System.out.println(one[2]);//300
    }
}

图解:

第四章 数组操作的常见问题【了解】

4.1 数组越界异常

数组操作的常见问题一:
	数组索引越界(超出了范围)异常
        1.问题描述:
			java中使用java.lang.ArrayIndexOutOfBoundsException类用来描述索引越界问题的
			
        2.产生原因:            
			当使用int数字作为索引获取数组元素时,索引值已经超出了数组的索引范围,
			无法获取该索引对应的元素
			(1)打印异常信息
			(2)停止程序的执行
			
        3.解决方案:
			(1)不使用超出索引范围的int数字来获取数组元素
			(2)修改索引越界的数字,让它在数组索引范围内

public class Demo01Problem {
    public static void main(String[] args) {
        //定义int数组array,并采用简化格式静态初始化
        int[] one = {100,200,300};
        System.out.println(one);//地址值
        System.out.println(one[0]);//100
        System.out.println(one[1]);//200
        System.out.println(one[2]);//300
        //System.out.println(one[3]);//索引3不存在,报异常,导致程序停止执行
        System.out.println(".................");
    }
}

图解:

4.2 数组空指针异常

数组操作的常见问题二:
	空指针异常
    	1.问题描述: 
			java中使用java.lang.NullPointerException类,来描述空指针异常
			
        2.产生原因:        	
			null是引用类型的空常量,可以给任意引用类型的变量赋值,但是一旦引用变量的值是null时,
			说明该引用变量已经不再执行堆内存的任何空间,也就不能范围堆内存空间中的元素了
			数组变量的值是null时,说明该数组变量已经不再执行堆内存空间的任何数组了,
			所以就无法通过索引的方式访问数组元素了,只要访问,就会报出空指针异常
			(1)打印异常信息
			(2)停止程序的执行
			
        3.解决方案:
        	(1)不使用值是null的数组变量来获取数组元素
            (2)找到数组变量值是null的地方,给数组变量重新赋值,让改数组变量重新指向一个新的数组空间
            

public class Demo02Problem {
    public static void main(String[] args) {
        //定义int数组array,并采用简化格式静态初始化
        int[] one = {100,200,300};

        System.out.println(one);//地址值

        System.out.println(one[0]);//100

        System.out.println(one[1]);//200

        System.out.println(one[2]);//300

        one = null;

        System.out.println(one);//null

        //System.out.println(one[0]);//报出空指针异常: 导致程序停止运行并打印异常信息

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

 

第五章 循环知识(循环跳转)补充

5.1 break语句

• 使用场景：终止switch或者循环

  • 在选择结构switch语句中

  • 在循环语句中

  • 离开使用场景的存在是没有意义的

案例：

观察以下代码的执行结果，分析break的作用

/*
    break的作用:
        1.可以使用在循环和switch语句中,其它位置不可用
        2.break是用来结束所在的循环的
            (1)一旦执行break,本次循环的循环体的后续代码不再执行
            (2)一旦执行break,剩余次数的循环也不再执行
            (3)相当于从执行break的位置,直接跳转到break所在的循环的后面执行
 */
public class Demo04Break {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {           
            if (i % 5 == 0) {
                break;
            }
            System.out.println("HelloWorld....." + i);
        }
        System.out.println("main....end....");
    }
}

 

5.2 continue语句

• 使用场景：结束本次循环，继续下一次的循环

  • 只能使用在循环语句中

案例：

观察以下代码的执行结果，分析break的作用

/*
    continue的作用:
        1.提前结束本次循环,继续进行下一次循环
        2.continue只影响本次循环,break影响所有循环
        3.continue只能使用在循环语句中
 */
public class Demo05Continue {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {            
            if (i % 5 == 0) {
                continue;
            }
            System.out.println("HelloWorld....." + i);
        }
        System.out.println("main....end....");
    }
}

图解:

5.3 continue练习

• 案例需求

朋友聚会的时候可能会玩一个游戏：逢七过。 ​ 规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。 ​ 为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足 逢七必过规则 的数据。 ​ 这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。

• 思路

  1:数据在1-100之间，用for循环实现数据的获取 2:根据规则，用if语句实现数据的判断：如果个位是7，或者十位是7，或者能够被7整除,则跳过(continue) 3:在控制台输出满足规则的数据

• 代码实现

/*
	字包含7或者是7的倍数:
        包含7: 个位是7 或者 十位是7
        7的倍数: 数字%7 == 0
        
	实现步骤:
        1.使用for循环遍历获取1到100之间的数字
        2.计算当前数字的个位和十位,分别保存到int变量ge和shi中
        3.判断: 如果 个位是7 或者 十位是7 或者 当前数字是7的倍数,执行continue
        4.如果不满足以上条件: 输出该数字
*/
public class Test06ContinueFQG {
    public static void main(String[] args) {
        //1.使用for循环遍历获取1到100之间的数字
        for (int num = 0; num < 100; num++) {
            //2.计算当前数字的个位和十位,分别保存到int变量ge和shi中
            int ge = num%10;//个位
            int shi = num/10%10;//十位
            //3.判断: 如果 个位是7 或者 十位是7 或者 当前数字是7的倍数,执行continue
            if ((ge == 7 || shi == 7) || (num % 7 == 0)) {
                continue;
            }
            //4.如果不满足以上条件: 输出该数字
            System.out.println(num);
        }
    }
}