2020年7月28日数组的声明，静态、动态初始化，遍历，内存分析

　　

/*
数组(array)：
    简单的说，就是一组数
    
    当一组数据的数据类型，意义是一样的时候，那么为了方便的统一的管理它们，我们需要
    用新的数据的存储结构来进行存储。例如：数组
    
所谓数组(Array)，就是相同数据类型的元素按一定顺序排列的集合，
就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，
然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。
组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。    

int[] scores = new int[7];
scores[0] = 89;
数组名：例如：scores
下标：范围：[0,长度-1]
    例如：[0]
元素：数组名[下标]
    例如：scores[0]

数组的长度：元素的总个数，可以这么表示：   数组名.length
*/
class Test01_Array{
    public static void main(String[] args){
        /*
        要存储本组学员的成绩，例如：第1组，有7个同学
        */
        /*
        int score1 = 89;
        int score2 = 89;
        int score3 = 67;
        int score4 = 99;
        int score5 = 89;
        int score6 = 34;
        int score7 = 89;
        
        //用7个变量存储没问题，但是如果涉及到对数据的管理：例如，求最值，排序等，就非常麻烦
        */
        int[] scores = new int[7];//用scores这一个统一的名称，来管理7个int类型的元素
        scores[0] = 89;//每一个元素都有自己的下标，编号，索引
        scores[1] = 89;
        scores[2] = 67;
        scores[3] = 99;
        scores[4] = 89;
        scores[5] = 34;
        scores[6] = 89;
    //    scores[7] = 56;// java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常
        
        System.out.println(scores.length);
    }
}

/*
原则：先声明后使用

1、声明一个数组？
语法格式;
    元素的数据类型[] 数组名;
    例如：
    存储几个学员的成绩：int[] scores;
    存储几个学员的体重：double[] weights;
    存储几个学员的姓名：String[] names;

2、    数组的初始化？
需要完成两件事：
（1）确定数组的长度
（2）确定数组的元素的值

方式一：静态初始化
    数组名 = new 元素的数据类型[]{元素的值列表};
    
说明：如果数组的声明与静态初始化合成一句时
    元素的数据类型[] 数组名 = new 元素的数据类型[]{元素的值列表};
    甚至还可以简化：当且仅当，声明与静态初始化在一句时，才能这么简化
    元素的数据类型[] 数组名 = {元素的值列表};
方式二：动态初始化

3、如何表示一个数组的元素
数组名[下标]
下标的范围：[0,长度-1]

4、如何表示数组的长度
数组名.length

5、遍历/访问数组中的元素
for(int i=0; i<数组名.length; i++){
    Ssytem.out.println(数组名[i]);
}

回忆：
变量的声明与使用
（1）变量的声明
数据类型  变量名;
（2）变量的初始化
变量名 = 变量值;

声明和初始化合成一句
数据类型  变量名 = 变量初始值;
*/
class Test02_ArrayDefineAndUse{
    public static void main(String[] args){
        //(1)声明一个数组，用来存储几个学员的成绩
        int[] scores;
        
        //(2)初始化数组
        //静态初始化
        //数组名 = new 元素的数据类型[]{元素的值列表};
        scores = new int[]{89,45,67,88,90};
        
        //如果把数组的声明与静态初始化合成一句
        //int[] scores = new int[]{89,45,67,88,90};
        //甚至还可以简化：
        //int[] scores = {89,45,67,88,90};
        
        System.out.println("数组的长度：" + scores.length);
        
        //(3)遍历数组
        //下标index的范围:[0,长度-1]
        //下标index的范围:[0,scores.length-1]
        for(int index = 0; index<scores.length; index++){
            //每一个元素，就是数组名[下标]
            System.out.println(scores[index]);
        }
    }
}

/*
1、数组的练习1：
    用一个数组，随意保存5个奇数，并且遍历显示
*/
class Test03_Exer1{
    public static void main(String[] args){
        //用一个数组，随意保存5个奇数，
        int[] array = {1,3,5,7,9};
        //遍历显示
        for(int i=0; i<array.length; i++){
            System.out.println(array[i]);
        }
    }
}

/*
2、数组的练习2：
    用一个数组，保存平年1-12月的满月天数，并且遍历显示结果：
    1月：31天
    2月：28天
    ...
*/
class Test04_Exer2{
    public static void main(String[] args){
        //用一个数组，保存平年1-12月的满月天数，
        int[] daysOfMonth = {31,28,31,30,31,30,31,31,30,31,30,31};
        
        //并且遍历显示结果
        for(int i=0; i<daysOfMonth.length; i++){
            System.out.println((i+1) + "月：" + daysOfMonth[i]);
        }
    }
}    

/*
3、数组的练习3：
    用一个数组，保存星期一到星期天的7个英语单词，
    从键盘输入1-7，显示对应的单词
*/    
class Test05_Exer3{
    public static void main(String[] args){
        //用一个数组，保存星期一到星期天的7个英语单词，
        String[] weeks = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
        
        //    从键盘输入1-7，显示对应的单词
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入星期（1-7）：");
        int week = input.nextInt();
        
        if(week<1 || week>7){
            System.out.println("输入有误！");
        }else{
            //week对应的英语单词在weeks数组中
            //week=1，weeks[0]
            //week=2，weeks[1]
            //...
            System.out.println(week+"对应的星期的单词是：" + weeks[week-1]);
        }
        
    }
}

/*
数组的存储：
1、数组下标为什么从0开始？
    下标表示的是这个元素的位置距离首地址的偏移量
2、数组名中存储的是什么
    数组名中存储的是数组在堆中一整块区域的首地址
3、数组的元素如何存储
    在堆中，依次连续的存储的

说明：
数组名，其实也是变量。

回忆：
变量的声明和初始化
    数据类型  变量名 = 变量值;
现在：
    int[] array = {1,3,5,7,9};
    其中的 int[]也是一种数据类型，数组类型，它是一种引用数据类型
    
    引用，表示引用一个“对象”，引用堆中的一块内存
    Java程序是在JVM中运行，JVM中的内存最最主要的两块区域：栈和堆
    其中的栈就是存储我们的局部变量（现在见到的变量都是局部变量），
        堆中存储的是对象
*/
class Test06_ArraySaveInMemory{
    public static void main(String[] args){
        int[] array = new int[]{1,3,5,7,9};
        //int[] array = {1,3,5,7,9};
        
        System.out.println(array);//打印数组名
        //结果：[I@15db9742
        //这个值是，数组对象的类型@对象的hashCode编码值
        //其中[I，表示int[]类型
        //15db9742是这个数组对象的hashCode编码值，类似于每个人都有一个身份证号
    }
}

/*
数组的定义和初始化、使用的方式二：
1、数组的声明？不变
    元素的数据类型[] 数组名;

2、数组的初始化
（1）确定数组的长度
（2）确定数组的元素的值

方式一：静态初始化
    数组名 = new 元素的数据类型[]{元素的值列表};
    
    说明：（1）数组的长度由{}中的值的个数决定。
        （2）元素的值，在{}中直接指定
    
方式二：动态初始化
    数组名 = new 元素的数据类型[长度];
    说明：（1）数组的长度在[]指定 
          （2）如果没有手动赋值之前，数组的元素有默认值
          元素是基本数据类型：
          byte,short,int,long：0
          float,double：0.0
          char：u0000 字符编码为0的空字符
          boolean：false
          元素是引用数据类型：null
          （3）给元素手动赋值
          如果没有什么规律，就一个一个赋值；
          如果有规律，可以使用循环赋值；

3、如何表示数组的长度？
数组名.length

4、如何表示一个数组的元素
数组名[下标]
下标的范围：[0,长度-1]

5、遍历数组
for(int i=0; i<数组的长度; i++){
    System.out.println(数组名[i]);
}    
*/
class Test07_ArrayDefineAndUse2{
    public static void main(String[] args){
        //例如：声明一个数组，用来存储26个大写的英文字母
        //(1)声明数组
        //char[] letters;
        
        //(2)动态初始化
        //数组名 = new 元素的数据类型[长度];
        //①确定数组的长度
        //letters = new char[26];
        
        //可以把声明与确定数组的长度合成一句
        char[] letters = new char[26];
        
        //(3)遍历数组的元素
        for(int i=0; i<letters.length; i++){
            System.out.println((int)letters[i]);//发现默认值是u0000
        }
        
        //②确定数组的元素的值
        //letters[0] = 'A';
        //letters[1] = 'B';
        //...
        for(int i=0; i<letters.length; i++){
            //数组的元素 = 值;
            letters[i] = (char)('A' + i);
        }
        
        System.out.println("-------------------------------");
        //(4)遍历数组的元素
        for(int i=0; i<letters.length; i++){
            System.out.println(letters[i]);//发现默认值是u0000
        }
    }
}