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
        }
    }
}
原文地址:https://www.cnblogs.com/douyunpeng/p/13393098.html