数组基础

一、概念

       数组：相同类型数据的集合。

二、定义

      定义的方式有3种。

      A.程序员定义方法

          int [] arr = new int [5];   //(推荐)
 或者     int  arr[] =new int [] ;

   大多数时候使用的都是“程序员定义法”。推荐3星。

   B.先声明后创建

       int arr[];
       arr=new int[10];

   在不确定数组大小时，可以先定义数组名称站位。这种情况不多。

   C.直接初始化

      int arr[]={1,5,6,68,4,62};

或者  int[] arr=new int[]{1,5,6,68,4,62};

     在定义的时候就直接赋值，进行了初始化。这样做省的后面一个个再赋值。

    注意：左边的【】括号中不能加入数字定义数组长度，因为这种定义方法下数组的长度是由右边｛｝括号内的内容决定的。
三、数组的使用

    数组长度 

      Java中每个数组都有length 属性，表示数组长度。

      length属性是public，final,int 的，即length是只读的，一旦定义，就不能改变。

如何判读两个基础数据类型的数组是否为同一对象？

      数组类容的比较是否可以使用equals呢？

public class ArrayTest2
{
	public static void main(String[] args) {
		int [] a = new int[]{1,2,3};
		int [] b = {1,2,3};
		
		System.out.println(a.equals(b));

	}
}

    输出结果为false，看来无法直接使用equals 证明两个数组是同一对象。那怎么办呢？

    一种是自己写方法，另一种是利用Java.util.Arrays。

import java.util.Arrays;
public class ArrayTest2 {
	
	public static boolean isEqual(int a[], int b[]) {
		if(a==null||b==null){
			return false;
		}
		if(a.length!=b.length){
			return false;
		}
		for(int i=0;i<a.length;i++){
			if(a[i]!=b[i]){
				return false;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		int [] a = new int[]{1,2,3};
		int [] b = {1,2,3};
		
	    System.out.println(isEqual(a,b));
	    System.out.println(Arrays.equals(a, b));
	}
}

对象数组的运用

       当数组中存放的不是基础数据类型，而是对象时，其实其存放的不是对象本身，而是对象的引用。当对象生成之后，引用才指向对象。否则，引用指向为null。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 对象数组的使用
 */
public class Test2 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Dogs[] dog = new Dogs[3];

		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);
		// 为3只狗赋值
		for (int i = 0; i < dog.length; i++) {
			dog[i] = new Dogs();
			// 请从控制台输入狗名
			System.out.println("请输入第" + (i + 1) + "只狗名：");
			String name = br.readLine();
			dog[i].setName(name);

			System.out.println("请输入第" + (1 + i) + "只狗的体重：");
			String tempWeight = br.readLine();
			float weight = Float.parseFloat(tempWeight);
			dog[i].setWeight(weight);
		}
		float sum=0;
		//计算总体重,平均体重
		for(int i=0;i<dog.length;i++){
			sum+=dog[i].getWeight();
		}
		System.out.println("3只狗的总体重是："+sum+"   平均体重是："+(sum/dog.length));
	}
}

class Dogs {
	String name;
	float weight;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public float getWeight() {
		return weight;
	}

	public void setWeight(float weight) {
		this.weight = weight;
	}
}

特别注意：     dog[i] = new Dogs();  

      在开始我们已经声明并且创建了dog数组，但是在使用dog数组时，还需要对“对象”初始化，Dogs类定义时没有重写构造函数，因此初始化的时候直接是new Dogs()；

        对象数组，使用之前必须对“对象”初始化。

四、二维数组

       Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，因此二维数组的每一维可以大小不同。

       声明二维数组的时候，可以只指定第一维大小，空缺第二维大小，以后再指定第二维长度的大小，但是不能空缺第一维大小（不能只指定列数，不指定行数）。

二维数组的初始化

静态初始化

               int Array[][] = new int [][] {{1,2},{3,4,5,8}};

      或者  int Array[][] =  {{1,2},{3,4,5,8}}; (推荐)

动态初始化

a.直接为每一维分配空间

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

b.从最高维开始为每一维分配空间

      int Array[] = new int  [2][ ];

      Array[0]=new int [3];

      Array[1] =new int[2];

      Array[0][0]=1;

     Array[0][1]=1;

     ……

     Array[2][2]

/**
 * 二维数组的演示
 * @author Red
 *
 */
public class ArrayTest3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int [][] a=new int [][]{{1,2},{3,4},{1,2,3,4}};
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.print(a[i][j]+" ");
			}
			System.out.println(  );
		}
		
		
		int[][] arr = new int[2][];

		arr[0] = new int[1];
		arr[1] = new int[2];

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

输出结果是：

1 2 
3 4 
1 2 3 4 
0  
0  0