Java 一维数组 数据类型[] 数组名；详资

Java数组的定义

数组就是存储同一类型若干数据的容器。
定义数组的语法:
数据类型 [] 数组名 = new 数据类型[数组长度];此乃正宗Java写法
数据类型 数组名[] = new 数据类型[数组长度];这是C++中写法
如, 定义一个可以存储5个int类型数据的数组:
int[] data =new int[5];

说明:
● data是一个数组名,== 其实就是一个变量名==, 数组是Java的一种引用数据类型, data数组名中存储的是数组的引用(起始地址)。
● new运算符在堆区分配一块连续的存储空间, 这块连续的存储空间可以容纳5个int类型的数据, 把这块存储空间的引用保存到data数组名中。
再如, 定义一个数组,存储10个double类型的数据：

doubule[] data2 = new double[10];

Java访问数组元素

数组中为每个数组元素指定一个索引值, 这个索引值是从0开始的, 通过数组的索引值访问每个元素。
data数组有5个元素, 分别为: data[0] , data[1] , data[2] , data[3] , data[4]。
长度为5的数组，最大下标是4；
长度为n得数组，最大下标是n-1;

为什么通过索引值可以访问到数组的元素？

之所以能够通过索引值访问到数组中的元素主要是我们已经知道嘞数组的数据类型也就知道了存储此类型的一个数据所需要的存储空间，通过数组名中存储的起始地址位置，再加上我们需要访问的数据的内存大小就可以直接获得此数据的内存地址，有了地址我们还怕找不到数据。

package com.wkcto.chapter03.demo01;

import java.util.Arrays;

/**
 * 数组的定义,元素的访问与遍历
 */
public class Test01 {
   

	public static void main(String[] args) {
   
		//1) 定义一个数组,存储5个int类型数据
		int [] data = new int[5];
		//定义数组,存储10个double类型数据
		double [] data2 = new double[10];
		//定义数组, 存储8个String字符串
		String[] data3  = new String[8];
		
		//2) 给数组元素赋值, 通过索引值访问每个元素
		data[0] = 123;
		data[1] = 123;
		data[2] = 123;
		data[3] = 123;
		data[4] = 123;
		//3) 注意, 数组下标(索引值)不能越界
//		data[5] = 123;  	//java.lang.ArrayIndexOutOfBoundsException: 5  数组索引值越界异常
		
		//4) 打印data数组每个元素的值
		/*System.out.println( data[0] );
		System.out.println( data[1] );
		System.out.println( data[2] );
		System.out.println( data[3] );
		System.out.println( data[4] );*/
		//数组有一个length属性,表示数组的长度
		for( int i = 0 ; i < data.length ;  i++){
   
			System.out.println( data[i] );
		}
		
		//5)遍历数组元素时, 还可以使用增强的for循环,也称foreach循环
		for (int xx : data) {
   
			//依次把数组中的每个元素赋值给局部变量xx
			System.out.print( xx + "\t");
		}
		System.out.println();
		
		//6)在输出数组的每个元素时,还可以调用Arrays工具类的toString()方法, 可以把数组的元素转换为字符串
		System.out.println( Arrays.toString(data));
		
	}

}

public class Test{
   
    public static void main(String[] args) {
   
        Cat[] cats= new Cat[6];

        for(int i=0;i< cats.length;i++){
   
            cats[i] = new Cat(i+1);
        }
        for(Cat cat:cats){
   
            System.out.println(cat.heiget);
        }
    }
    static class Cat{
   
        int heiget;

        public Cat() {
   
        }

        public Cat(int heiget) {
   
            this.heiget = heiget;
        }

        public int getHeiget() {
   
            return heiget;
        }

        public void setHeiget(int heiget) {
   
            this.heiget = heiget;
        }
    }
}

Java数组的静态初始化

package com.wkcto.chapter03.demo01;

import java.util.Arrays;
/**
 * 数组的静态初始化 
 */
public class Test02 {
   

	public static void main(String[] args) {
   
		//定义数组
		int [] data = new int[8];
		//给数组元素赋值
		data[2]	 = 666;
		//遍历数组的元素
		for(int i = 0 ;  i<data.length; i++){
   
			System.out.print( data[i] + "\t");
		}
		System.out.println( );
		/*
		 * 1) 创建了数组后, 系统会给数组进行默认的初始化
		 * 	整数数组,把所有元素默认初始化为0
		 * 	小数数组,把所有元素默认初始化为0.0
		 * 	字符数组,把所有元素默认初始化为码值为0的字符, '\u0000'
		 * 	布尔数组,把所有元素默认初始化为false
		 * 	引用数组,把所有元素默认初始化为null
		 */
		
		//2)在创建数组的同时,可以给数组的元素赋初值, 这叫数组的静态初始化
		//在数组静态初始化时, 不需要指定数组的长度, 数组的长度由初始化元素的个数决定
		int [] mydata = new int[]{
   3,6,9,8};
		System.out.println( mydata.length );  		//4
		//数组的静态初始化,可以简化为:
		int [] mydata2 = {
   1,4,7};
		for (int xx : mydata2) {
   
			System.out.print( xx + "\t");
		}
		System.out.println( );
		
		//3)数组名之间的相互赋值
		data = mydata; 		//把mydata的值赋值给data, mydata存储的是一个数组的引用, 现在mydata和data引用了同一个数组
		System.out.println( Arrays.toString(data )); 		//[3, 6, 9, 8]
		data[0] = 88;
		System.out.println( Arrays.toString(mydata));   	//[88, 6, 9, 8]
		
		//4) 给数组重新赋值
		data = new int[] {
   6,6,6}; 		//data指向 了新的数组
		System.out.println( Arrays.toString(data ));
//		data = {8,8,8}; 		//简化的静态初始化,仅用于数组的静态初始化,不能用于数组的赋值
				
	}

}

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test {
   

    public static void main(String[] args) {
   
        String[] strings = new String[6];
        for (String a:strings
             ) {
   
            System.out.println(a);
        }
        int