JAVA中的数组

1 数组概述和定义格式说明(了解)
    数组的概述：
        它是装同一种数据的容器。而这个容器的容量，长度是一定的。
        
    数组的格式：
        动态初始化：
            数据类型[]  数组名 = new 数据类型[数组的开辟空间大小的整数];
            
            int[] arr = new int[3];        
                数组的长度:arr.length;
                数组的角标从0开始，最大能取到 数组的长度-1
                
            arr[0] =11;
            arr[1] =22;
            arr[2] =33;            
            
        
    动态初始化的默认值：
            创建的int 类型数组，动态初始化，系统给默认值，为0.
            创建String 类型，数组，动态初始化的时候，系统给默认值null
            
            小数类型的  数组动态初始化，元素默认值 0.0
            boolean 类型，数组动态初始化，元素默认值 false
            

2 数组的初始化动态初始化【掌握】
        动态初始化：
            数据类型[]  数组名 = new 数据类型[数组的开辟空间大小的整数];
            
            int[] arr = new int[3];        
                数组的长度:arr.length;
                数组的角标从0开始，最大能取到 数组的长度-1
                
            arr[0] =11;
            arr[1] =22;
            arr[2] =33;            
            
    练习： 要求，创建一个String类型的数组，然后给他动态初始化，
                开辟，5个空间
                
                然后给前三个索引位置，赋值 
                分别为  I   like  java 
            
3 数组打印出的地址值的解析。【掌握】
    [Ljava.lang.String;@4eafccbe
    
    [        数据类型，是数组。
    L 后边是地址值具体的内容
    java.lang.String 定义是String 类型的数组。
    @4eafccbe    在内存空间分配的地址值
            这个地址值，是内存随机分配给你的数组的。
            当内存中数据销毁之后，会继续重新分配数组的地址。
    
4 、Java中的内存分配以及栈和堆的区别【掌握】
        栈 ：cpu 寄存区
        
                所有的方法，进栈。
                所有的局部变量引用，进栈。
        
                栈遵循的存取规则：
                    先进的，后出
                    后进的，先出。
                存储的时候，使用压栈的方式存储
                
                当栈爆满的时候，优先销毁的是，后进去的。

        堆 ：内存条，开辟内存区
                new 出来的所有东西，进堆。
                
                存储的数据，在堆中，随机开辟空间位置，没有具体的顺序。
                内存爆满的时候，随机销毁数据。
                电脑关机的时候，内存中所有数据销毁。
    
    
            
5 获取数组中的值的方法：            
        新建一个类，定义一个int 类型的数组。开辟空间3个。然后分别赋值。
        然后来获取到数组中，每个索引对应位置的，数据。
        
        并输出打印该数组中存储的数据。
    
    1、如何输出数组中元素的值：
        (1)第一种方式：通过数组的索引引用，单个输出的方式。
            数组名[对应索引]
        
            int[] arr = new int[3];
            arr[0] = 234;
            arr[1] = 21211;
            arr[2] = 54;
            System.out.println("--------普通方式，输出数组中的内容--------");
            System.out.println(arr[0] +","+arr[1]+","+arr[2]);
            System.out.println(arr[1]);
            System.out.println(arr[2]);
        
     （2）、第二钟方式，通过遍历的方式来输出打印。
            遍历先要知道数组的知识点：
                数组，角标，从0 开始，最大能取到 长度-1
                数组的长度，可以用 ：arr.length 来获取。
            
                int[] arr = new int[3];
                //遍历，就是循环查询找到数组中的每一个元素。称之为遍历。
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }
        

6 数组的内存图解2二个数组(了解)【见图解及视频】
        //创建的int 类型数组，动态初始化，系统给默认值，为0.
        int[] a = new int[3];
        a[0] =1;
        a[1] =2;
        
        //创建String 类型，数组，动态初始化的时候，系统给默认值null
        String[] s= new String[5];
        s[0] ="asdf";
        s[4] ="qwer";
        
        //分别遍历两个数组，查看输出结果。
        //遍历int[] a 数组
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+",");
        }
        System.out.println("\n------------------");
        //遍历String[] s数组。
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i]+",");
        }

7 数组的内存图解3三个引用两个数组(了解)【见图解及视频】
        
        public class Test03 {
            public static void main(String[] args) {
                
                //创建的int 类型数组，动态初始化，系统给默认值，为0.
                int[] a = new int[3];
                int[] b = a;
                a[0] =1;
                a[1] =2;
                
                //创建String 类型，数组，动态初始化的时候，系统给默认值null
                String[] s= new String[5];
                s[0] ="asdf";
                s[4] ="qwer";
                
                //分别遍历两个数组，查看输出结果。
                //遍历int[] a 数组
                for (int i = 0; i < a.length; i++) {
                    System.out.print(a[i]+",");
                }
                System.out.println("\n------------------");
                //遍历String[] s数组。
                for (int i = 0; i < s.length; i++) {
                    System.out.print(s[i]+",");
                }
                
                System.out.println("\n------------------");
                
                for (int i = 0; i <b.length; i++) {
                    System.out.print(b[i]+",");
                }
                System.out.println("\n------------------");
                //分别输出打印一下，三个数组，他们的内存地址值。
                System.out.println(a);
                System.out.println(b);
                System.out.println(s);
                
            }

        }