第三章 数组的使用（1.2）

Java中，数组必须经过声明、内存分配、初始化后才能使用。

2.1、数组的声明

语法格式：
<1> 数据类型 数组名 [] ;
或者
<2> 数组类型[] 数组名 ;

注意：
建议使用<2>种的数组声明格式，因为可以把“数据类型[ ]”看作一种特殊的数据类型。

例如：

//  数组的声明
    int nums[];
    //或者
    int[] nums;

2.2、为数组分配内存空间

通过new运算符可以为数组元素分配内存空间。

语法格式：
数组名 = new 数组类型 [ 数组长度 ]；

例如：

//  为数组分配内存空间
    nums = new int[10];

注意：
数组的声明和内存分配可以一起来定义：
语法格式：
数据类型 数组名[] = new 数组类型[数组长度];
例如：

//  数组的声明和内存分配一起来定义
    int nums[] = new int[10];

2.3、为数组元素初始化

语法格式：
数组名[元素下标] = 元素；
（这样为数组元素初始化，属于，数组元素的动态分配，可以更为灵活的更改数组中的指定元素值。）
例如：

//  为数组元素初始化
    nums[0] = 110;
    nums[1] = 111;
    nums[2] = 112;
    nums[3] = 113;
    nums[4] = 114;
    nums[5] = 115;
    nums[6] = 116;
    nums[7] = 117;
    nums[8] = 118;
    nums[9] = 119;

注意：
数组声明、为数组元素分配内存、数组元素初始化，这三步可以合并在一起写。
语法格式：
数据类型[] 数组名 = {数组元素};
或
数据类型[] 数组名 = new 数据类型[]{数组元素};
例如：

//  数组的声明、内存分配和初始化一起来定义
    int nums[] = new int[]{110,111,112,113,114,115,116,117,118,119};
    
  //  注意：此时无需指定数组的大小(长度)。

2.3.1、数组没有初始化时的默认值

如果没为数组元素初始化，则数组元素则会使用默认值。 byte、 short、 int、 long类型的数组元素的默认值是 0， float、double类型数组的元素默认值是 0.0， boolean类型数组元素的默认值是 false， char类型的数组元素默认值是 '\u0000'， 引用类型数组元素的默认值是 null。
如下表：

序号	数据类型	默认初始值
1	Byte	0
2	Short	0
3	Int	0
4	Long	0
5	Float	0.0
6	Double	0.0
7	Boolean	false
8	char	\u0000
9	引用数组类型	null

例如：

类Array:
    public class Array {
      public static void main(String[] args) {
      
        // 数组的声明和分配内存空间，但是不给数组元素初始化
        byte[]  bytes  = new byte[2];
        short[] shorts = new short[2];
        int[]   ints   = new int[2];
        long[]  longs  = new long[2];
        float[] floats = new float[2];
        double[]  doubles  = new double[2];
        boolean[] booleans = new boolean[2];
        char[]    chars    = new char[2];
        String[]  strings  = new String[2];
        
        //输出8种基本数据类型和引用数据类型的默认值
        System.out.println("bytes[0]="+bytes[0]);
        System.out.println("shorts[0]="+shorts[0]);
        System.out.println("ints[0]="+ints[0]);
        System.out.println("longs[0]="+longs[0]);
        System.out.println("floats[0]="+floats[0]);
        System.out.println("doubles[0]="+doubles[0]);
        System.out.println("chars[0]="+chars[0]);
        System.out.println("strings[0]="+strings[0]);
      }
    }

2.3.2、数组初始化的举例

例1：数组的声明、为数组分配内存空间、为数组元素初始化分步进行完成。

public class Array {
	public static void main(String[] args) {
	
		// 声明数组
		int[] nums;
		String names[];

		// 为数组元素分配内存空间
		nums = new int[2];
		names = new String[3];

		// 初始化数组元素
		nums[0] = 520;
		nums[1] = 1314;
		names[0] = "Java";
		names[1] = "Python";
		names[2] = "C/C++";
	}
}

例2：数组的声明和分配内存空间一起完成，最后为数组元素初始化。

public class Array {
	public static void main(String[] args) {
	
		// 数组的声明和内存分配
		int[] nums = new int[2];
		String names[] = new String[3];

		// 初始化数组元素
		nums[0] = 520;
		nums[1] = 1314;
		names[0] = "Java";
		names[1] = "Python";
		names[2] = "C/C++";
	}
}

例3：数组的声明、为数组分配内存空间和为数组元素初始化一起完成。

public class Array {
	public static void main(String[] args) {
	
		// 数组的声明、内存分配和初始化一起完成
		int[] nums = new int[]{520,1314};
		String names[] = new String[]{"Java","Python","C/C++"};
	}
}

2.4、访问数组元素

语法格式：
数组名[数组下标]
例如：

     //访问数组元素
     String names[] = new String[]{"Java","Python","C/C++"};
     //访问数组元素
     System.out.println("names[0]"+names[0]);
     System.out.println("names[1]"+names[1]);
     System.out.println("names[2]"+names[2]);

注意：
数组和for循环的组合使用。
1>：

    //声明、分配内存、初始化数组names
    String names[] = new String[]{"Java","Python","C/C++"};
    //访问数组元素
    for(int i=0;i<names.length;i++){
      System.out.println("names["+i+"]"+names[i]);
    }

2>:

    //声明、分配内存、初始化数组names
    String names[] = new String[]{"Java","Python","C/C++"};
    //访问数组元素
    for(String str:names){
      System.out.println(str);
    }

解释：在2>for循环中，只需要一个变量和数组名就不能输出该数组的所有元素。
语法格式：

for( 声明循环变量  : 数组名称 ){
    System.out.println(循环变量名);
}
注意：
1、声明循环变量时，声明的变量类型要和数组的类型形同；
2、声明循环变量 = 循环变量类型 + 循环变量名称。