Java数组

数组

  数组是为了能够一次性保存一组数据
  数组是复合数据类型之一

什么是数组？

  相同数据类型的数据按照顺序组成的复合数据类型就是数组。
    1. 相同数据类型的数据----将来被保存到数组中的数据都是同一类型。
    2. 按照顺序
    3. 复合数据类型

如何定义一个一维数组？

  格式: 数据类型 数组名称[]；
  数据类型 []数组名称；
  数组的定义与变量的定义相似，只是需要”[]”与变量区分，因此上”[]”就是数组的标志。
  名称的前面/后面出现一个“[]”就是一维数组，有两个”[][]”就是二维数组，两个以上就是多维数组。

如何创建一个一维数组？

  创建数组实际上就是为数组开辟指定的存储空间，用来保存一组数组。
  1. 先定义，后创建
     数据类型 数组名称[]；
     数据类型 []数组名称；
     数组名称 = new 数据类型[指定的存储空间];
     指定的存储空间是一个整数int

  2. 定义+创建
     数据类型 数组名称[ ] = new 数据类型[指定的存储空间];
     数据类型 [ ]数组名称 = new 数据类型[指定的存储空间];
例如：

public  class  ShuZuDemo1{
	public static  void main(String args[]){
		//格式: 数据类型  数组名称[]；
		//定义--数据类型  []数组名称；
		int shuzu1[];
        char []shuzu2;
		//1.先定义，后创建
		int shuzu3[];
		shuzu3=new int[4];
		char []shuzu4;
		shuzu4 = new char[5];
		//shuzu4 = [5]new char;//错误
		//shuzu4 = new char[];//错误
		//shuzu4 = new char[2.5];//错误

		//2.定义+创建
		int shuzu5[]=new int[4];
        char []shuzu6=new char[5];
	}
}

如何为一维数组赋值？

  1.逐个赋值—就是挨个为数组的每一个存储空间存放数据值。
  因为是按照顺序存放数据的，顺序是从0开始的，每一顺序编号就是一个数组的存储空间，这个顺序编号就叫下标。
  当保存在数组中的数据超过数组指定的存储空间就是会出错。
    java.lang.ArrayIndexOutOfBoundsException: 5
  格式: 数组名称[下标] = 数据值;

  2.直接赋值—就是在创建数组的时候将数据值保存到数组中。
    2.1 new 数据类型[]{数据值1，数据值2，…，数据值n};
    创建数组的时候不能指定存储空间
    2.2 数据类型 数组名称[]={数据值1，数据值2，…，数据值n};
例如：

public  class  ShuZuDemo2{
	public static  void main(String args[]){
		char shuzu1[]=new char[5];
		//1.逐个赋值
		shuzu1[0]='A';
		shuzu1[1]='B';
		shuzu1[2]='C';
		shuzu1[3]='D';
		shuzu1[4]='E';
		//shuzu1[5]='F'; //java.lang.ArrayIndexOutOfBoundsException: 5
		//2.直接赋值---就是在创建数组的时候将数据值保存到数组中。
		//2.1 new 数据类型[]{数据值1，数据值2，...，数据值n};
		int shuzu2[];
		shuzu2 = new int[]{100,200,300};
        //创建数组的时候不能指定存储空间
		//double shuzu3[]=new double[4]{12.5,23.8,456.7,23.9};//错误
		//2.2 数据类型  数组名称[]={数据值1，数据值2，...，数据值n};
		char  shuzu4[]={'h','e','l','l','o'};	
	}
}

如何从一维数组中取值？

  只要能够得到数组的存储位置，就能得到数组中的数据值。
  格式:数组名称[下标]
  shuzu1[2]—从shuzu1这个数组中得到第3个位置中保存的数据值。
例如:

System.out.println("取出数组中的最后一个值---"+shuzu1[4]);

一维数组的length属性

  length表示指定空间大小
例如：

	int shuzu2[]=new int[4];
	shuzu2[0]=120;
	shuzu2[2]=119;
	System.out.println("shuzu2的length属性---"+shuzu2.length); //4
	//length表示数组元素个数【指定空间大小】
	char shuzu3[]={'h','e','l','l','o'};
	System.out.println("shuzu3的length属性---"+shuzu3.length); //5

数组的内存结构

循环遍历一维数组

public  class  ShuZuDemo4{
	public static  void main(String args[]){
		char shuzu1[]={'h','e','l','l','o'};
		//for循环遍历数组
		for(int i=0;i<shuzu1.length;i++){
			System.out.println("char数组shuzu1--"+shuzu1[i]);
		}
		//while循环遍历数组
        int j=0;
        while(j<shuzu1.length){
			System.out.println("char数组shuzu1--"+shuzu1[j]);
			j++;
		}
		int k=0;
		do{
           System.out.println("char数组shuzu1--"+shuzu1[k]);
		   k++;
		}while(k<shuzu1.length);
	}
}

增强的for循环遍历一维数组

  增强的for循环格式:
  for(数组的数据类型 变量名称 : 被遍历的数组名称){
  循环体;
  }
例如

	char shuzu1[]={'h','e','l','l','o'};
	for(char value:shuzu1){
		System.out.println("char数组shuzu1--"+value);
	}

二维数组

  二维数组跟一维数组语法格式相似，就是比一维数组多了一个[]
  二维数组可以保存一个类似表格一样的数据，所以我们可以认为二维数组就是一个表格。
  因此可以将第一个[]比作为表格中的行，第二个[]比作为表格中的列。
例如：

int  shuzu1[][];
	 shuzu1 = new int[2][3];

int  shuzu1[][]=new int[2][3];

二维数组赋值

  1.逐个赋值—就是挨个为数组的每一个存储空间存放数据值。
例如:

int shuzu1[][]=new int[2][3];
	shuzu1[0][0]=100;
	shuzu1[0][1]=200;
	shuzu1[0][2]=300;
	shuzu1[1][0]=100;
	shuzu1[1][1]=200;
	shuzu1[1][2]=300;

shuzu1[0][0]=100	shuzu1[0][1]=200;	shuzu1[0][2]=300;
shuzu1[1][0]=100;	shuzu1[1][1]=200;	shuzu1[1][2]=300;

  2.直接赋值—就是在创建数组的时候将数据值保存到数组中。
    2.1 new 数据类型[][]{{数据值1,数据值2,…数据n},{数据值1,数据值2,…数据n}};
      创建数组的时候不能指定存储空间
    2.2 数据类型 数组名称[]={{数据值1,数据值2,…数据n},{数据值1,数据值2,…数据n}};

int  shuzu1[][]=new int[][]{{100,200,300},{400,500,600}};
int  shuzu1[][]={{100,200,300},{400,500,600}};

从二维数组中取值

  只要能够得到数组的存储位置，就能得到数组中的数据值。
  格式:数组名称[行][列]；
  shuzu1[2][3]—从shuzu1这个数组中得到第3行，第4列中保存的数据值。

二维数组的length属性指代行数

循环遍历二维数组

  使用双层循环结构，外层控制行，内层控制列

	int  shuzu2[][]={{100,200,300},{400,500,600},{700,800,900}};
	for(int i=0;i<shuzu2.length;i++){
		for(int j=0;j<3;j++){
			System.out.println("shuzu2的值==="+shuzu2[i][j]);
		}
	}

总结