数组

1、数组: 用于批量声明同种类型的多个变量
2、数组变量 、数组类型 、数组元素、数组长度 、下标(索引) 、数组常量
3、通过 数组变量名称[ 下标 ] 可以对 数组中指定位置的元素进行 取值 或 赋值操作
4、遍历数组

public class Array1 {

    public static void main(String[] args) {
        
        // first 是一个数组类型的变量，即【数组变量】
        // int[] 是 first 变量的类型，即【数组类型】
        // 数组中所存放的每个数值，比如 10 , 20 , 30 , 40 , 50 等 都是数组中的【元素】
        int[] first = { 10 , 20 , 30 , 40 , 50 }; // Java 建议采用的风格
        // Java 语言中 原点运算符 可以理解为 汉语 中的 "的" ，比如 first.length 可以读成 first 的 length
        System.out.println( first.length ); // 通过 length 属性可以获取 【数组长度】 ( 数组中可以容纳的最大元素个数 )
        System.out.println( first[ 0 ] ); // 数组【下标(索引)】从零开始 
        System.out.println( first[ 1 ] );  // 可以通过【 数组变量名称[ 下标 ] 】来获取指定位置的元素
        System.out.println( first[ 2 ] );
        System.out.println( first[ 3 ] );
        System.out.println( first[ 4 ] );

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

        first[ 3 ] = 100 ; // 可以通过【 数组变量名称[ 下标 ] 】来为指定位置的元素赋值
        first[ 2 ] = 200 ;

        // 【遍历数组】: 将数组中的每个元素按照一定顺序依次访问一遍
        for (int i = 0 ; i < first.length; i++) {
            System.out.print( first[ i ] + "\t" ); // 可以通过【 数组变量名称[ 下标 ] 】来获取指定位置的元素
        }
        System.out.println();

        // 在 声明数组后，可以通过 { } 形式直接为 数组变量 赋值，这里以 { } 形式书写的内容就是【数组常量】
        // { 10 , 20 , 30 , 40 , 50 , 60 } 就是所谓的数组常量
        int second[] = { 10 , 20 , 30 , 40 , 50 , 60 }; // C/C++ 惯用的风格
        System.out.println( second.length );

        for (int i = 0 ; i < second.length; i++) {
            System.out.print( second[ i ] + "\t" );
        }
        System.out.println();

    }

}

1、数组、数组元素
     【数组】( array ) 是具有确定顺序的若干个相同类型的变量的集合。
     数组中的每个变量被称作数组【元素】( element )

2、数组变量 、数组类型

         类型  变量名称 ;
         类型  变量名称 =  数组常量  ;

3、数组长度

          通过 【数组变量名称.length】 可以获取数组长度

4、下标(索引)

           因为数组中依次序存放了若干变量，因此可以通过顺序关系来访问其中的变量
           用来访问数组中指定位置(次序)的数字就是所谓的 下标 ，也称作 索引

5、数组常量

6、数组变量 不是 基本数据类型的变量，
     数组变量中存储的不是数值本身而是一个地址，
     通过这个地址可以找到真正的存放数据的内存区域

public class Array2 {

    public static void main(String[] args) {
        
        // first 是变量名称，int 是变量的类型
        int first = 100 ; // 基本数据类型的变量中直接存储相应的取值
        System.out.println( first ); 

        // second 是变量名称，也就是 数组变量名称 ，简称 数组名称
        // int[] 是 second 变量的类型，int[] 既确定了 second 变量的类型，也确定了 second 所对应数组中各个元素的类型
        int[] second = { 10 , 20 , 30 }; // 数组常量 { 10 , 20 , 30 } 确定了 second 对应的数组中每个变量的值 和 second 数组的长度
        System.out.println( second ); 

        // 对于非基本数据类型的变量来说，可以通过 System.identityHashCode( reference ) 方法来获取该变量中所存储的 "地址"
        int address = System.identityHashCode( second ); // 这个方法 死记硬背 也要背下来，将来可以帮很多忙
        System.out.println( address );

        // 通过 for 循环 遍历数组
        for ( int i = 0; i < second.length; i++ ) {
            int element = second[ i ] ; // 通过 数组变量名称[ 下标 ] 来获取相应的元素
            System.out.print( element + "\t");
        }
        System.out.println();

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

        // 对比 C/C++
        // int third[ 5 ] ; // 与 C 语言不同，Java 中不支持这种写法
        int[] third = new int[ 5 ]; // Java 语言中创建数组的方法
        System.out.println( third.length ); 
        for ( int i = 0; i < third.length; i++ ) {
            int element = third[ i ] ;
            System.out.print( element + "\t");
        }
        System.out.println();

        System.out.println( System.identityHashCode( third ) );

    }

}

1、静态初始化
      声明数组时直接完成对数组的初始化操作就是静态初始化
      int[] first = { 10 , 20 , 30 };

      静态初始化时可以使用 数组常量 ( 只有在 声明数组 时才可以使用 )

2、动态初始化
      声明数组时为数组中各个变量开辟内存空间并赋予【默认值】

         int[] array = new int[ 5 ] ;

         用来存放 原生类型数据 的数组中各个变量的默认值都是 零 :
              byte : 0
              short : 0
              int : 0
              long : 0
              float : 0.0f
              double : 0.0
              char : \u0000
              boolean : false

        用来存放 引用类型数据 的数组中各个变量的默认值都是 null 。

      如果期望将一组数据放入到数组中，需要在声明数组之后显式为各个变量赋值，第一次显式为数组中各个变量赋的值就是【初始值】

public class Array3 {

    public static void main(String[] args) {

        // 数组常量 只有在 声明数组 时才可以使用
        int[] first = { 10 , 20 , 30 }; //【静态初始化】
        for (int i = 0; i < first.length; i++) {
            System.out.print( first[ i ] + "\t" );
        }
        System.out.println();

        // 对于已经声明过的 数组变量 不可以再使用 数组常量 为其赋值
        // first = { 100 , 200 , 300 }; // 错误: 非法的表达式开始

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

        int[] second = new int[] { 1 , 3 , 5 , 7 , 9 } ; //【静态初始化】
        for (int i = 0; i < second.length; i++) {
            System.out.print( second[ i ] + "\t" );
        }
        System.out.println();

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

        // 声明数组
        int[] third = new int[ 5 ];  // 开辟内存空间并赋予默认值
        for (int i = 0; i < third.length; i++) {
            System.out.print( third[ i ] + "\t" );
        }
        System.out.println();

        Random rand = new Random();
        // 通过循环完成对数组的初始化
        for (int i = 0; i < third.length; i++) {
            third[ i ] = rand.nextInt( 100 );
        }
        
        for (int i = 0; i < third.length; i++) {
            System.out.print( third[ i ] + "\t" );
        }
        System.out.println();

    }

}

1、array = new int[ 5 ] ; 到底完成了哪些操作
2、通过 array 获取数组长度、访问数组元素都要首先通过 array 变量中存储的"地址"找到真正的数组
3、通过 new 关键字 在 堆内存 中 创建的数组 ，就是一个特殊的 Java 对象，很多时候将其称作 数组对象  或 数组实例

public class Array4 {

    public static void main(String[] args) {

        int[] array ; // 声明一个数组变量
        // System.out.println( array ); //【编译失败】错误: 可能尚未初始化 变量 array

        // 只有在声明数组时才可以将 数组常量 赋值给 数组变量
        // array = { 100 , 200 , 300 }; //【编译失败】错误: 非法的表达式开始

        // 1、new 负责在 堆内存 中开辟空间
        // 2、类型 ( int ) 和 数组长度 ( 5 ) 确定 new 所开辟的内存大小 ( 一个 int 变量占 4 字节，5 个就是 20 字节 ) 
        // 3、为已经创建好的 5 个 int 变量赋予默认值 ( int 类型默认值都是 0 )
        // 4、最后将 堆内存中 数组的首地址 赋值给 数组变量 ( array )
        array = new int[ 5 ];
        System.out.println( "数组变量 array 中存储的 '地址' 是: " + System.identityHashCode( array ) );

        // 通过 数组变量 array 中存储的地址找到 堆内存 中的 数组 后，再获取数组长度并输出
        System.out.println( "数组长度: " + array.length ); // 输出 array 数组 的 长度

        for (int i = 0; i < array.length; i++) {
            System.out.print( array[ i ] + "\t" ); // 通过 array 变量所存储的地址找到 堆内存中的数组后再根据 索引 访问相应位置的变量
        }
        System.out.println();

        Random rand = new Random();
        // 通过循环完成对数组的初始化
        for (int i = 0; i < array.length; i++) {
            // 通过 array 变量所存储的地址找到 堆内存中的数组后再根据 索引 为相应位置的变量赋值
            array[ i ] = rand.nextInt( 100 );
        }

        for (int i = 0; i < array.length; i++) {
            System.out.print( array[ i ] + "\t" ); 
        }
        System.out.println();

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

        int[] another = array ;
        System.out.println( "数组变量 another 中存储的 '地址' 是: " + System.identityHashCode( another ) );

        System.out.println( another == array ); // 比较两个数组变量中存储的值是否相等 ( 数组变量中存储的是地址 )

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

        int[] first = { 10 , 20 , 30 }; // int[] first = new int[] { 10 , 20 , 30 };
        int[] second = { 10 , 20 , 30 }; // int[] second = new int[] { 10 , 20 , 30 };

        System.out.println( first == second );
        System.out.println( "数组变量 first 中存储的 '地址' 是: " + System.identityHashCode( first ) );
        System.out.println( "数组变量 second 中存储的 '地址' 是: " + System.identityHashCode( second ) );

    }

}

 

1、数组就是用来容纳一组相同类型的变量的
2、数组内部容纳的变量是基本数据类型还是引用类型，取决于实际需要
3、如果某个数组内部容纳的变量又是数组类型，则这个数组是个多维数组

public class Array6 {

    public static void main(String[] args) {

        char[] first = { '青' , '海' , '长' , '云' , '暗' , '雪' , '山' } ;
        System.out.println( first ); // 不是输出 "类型@哈希码" 形式 而是将 char 数组中的所有字符直接输出
        System.out.println( System.identityHashCode( first ) );

        char[] second = { '孤' , '城' , '遥' , '望' , '玉' , '门' , '关' };
        System.out.println( second ); 
        System.out.println( System.identityHashCode( second ) );

        char[] third = { '黄' , '沙' , '百' , '战' , '穿' , '金' , '甲' } ;
        System.out.println( third ); 
        System.out.println( System.identityHashCode( third ) );

        char[] fourth = { '不' , '破' , '楼' , '兰' , '终' , '不' , '还' } ;
        System.out.println( fourth ); 
        System.out.println( System.identityHashCode( fourth ) );

        // 数组常量 { first , second , third , fourth } 是由 四个 地址 组成的数组
        // 变量 x 所对应的数组是一个存放 数组 的 数组
        char[][] x = { first , second , third , fourth } ;

        /*
        char[][] x =  {
                                { '青' , '海' , '长' , '云' , '暗' , '雪' , '山' } ,
                                { '孤' , '城' , '遥' , '望' , '玉' , '门' , '关' } ,
                                { '黄' , '沙' , '百' , '战' , '穿' , '金' , '甲' } ,
                                { '不' , '破' , '楼' , '兰' , '终' , '不' , '还' }
                            };
        */

        // 遍历二维数组
        for( int i = 0 ; i < x.length ; i++ ) {
            // 取 x 对应的数组中的元素
            char[] e = x[ i ];
            // 处理获取到的元素(是个数组)
            for( int j = 0 ; j < e.length ; j++ ) {
                char ch = e[ j ] ;
                System.out.print( ch + "\t" );
            }
            System.out.println();
        }

        /*
        // 遍历二维数组
        for( int i = 0 ; i < x.length ; i++ ) {
            // 处理获取到的元素(是个数组)
            for( int j = 0 ; j < x[ i ].length ; j++ ) {
                char ch = x[ i ][ j ] ;
                System.out.print( ch + "\t" );
            }
            System.out.println();
        }
        */

    }

}

 

1、为了分类而分类: 将二维数组分为 规则二维数组 和 不规则二维数组
     如果某个数组内部的 所有数组长度都相同，则这个二维数组就是规则二维数组，否则就是 不规则二维数组
2、使用 两重 for 循环 遍历二维数组

public class Array7 {

    public static void main(String[] args) {

        // 不规则二维数组
        char[][] first = { 
                                    { '狼' , '烟' , '起' } , 
                                    { '江' , '山' , '北' , '望' } ,
                                    { '龙' , '起' , '卷' , '马' , '长' , '嘶' , '剑' , '气' , '如' , '霜' } , 
                                    { '心' , '似' , '黄' , '河' , '水' , '茫' , '茫' } 
                                } ;

        for( int i = 0 ; i < first.length ; i++ ) {
            for( int j = 0 ; j < first[ i ] .length  ;j++ ) {
                // i 表示外部数组中下标是 i 的元素(是个数组)， j 表示 内部数组中下标是 j 的元素(是个字符)
                char ch = first[ i ] [ j ] ; 
                System.out.print( ch + " " );
            }
            System.out.println();
        }

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

        // 规则二维数组
         char[][] second =  {
                                        { '青' , '海' , '长' , '云' , '暗' , '雪' , '山' } ,
                                        { '孤' , '城' , '遥' , '望' , '玉' , '门' , '关' } ,
                                        { '黄' , '沙' , '百' , '战' , '穿' , '金' , '甲' } ,
                                        { '不' , '破' , '楼' , '兰' , '终' , '不' , '还' }
                                    };     
                                    
        for( int i = 0 ; i < second.length ; i++ ) {
            // for( int j = 0 ; j < second[ i ] .length  ;j++ ) {
            for( int j = 0 ; j < second[ 0 ] .length  ;j++ ) {
                char ch = second[ i ] [ j ] ;
                System.out.print( ch + " " );
            }
            System.out.println();
        }                          

    }

}