04 java基础_数组

2019独角兽企业重金招聘Python工程师标准>>>

04 java基础_数组

数组相关概念

v      在java语言中，数组是一种复合数据类型（引用数据类型）。数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

 

v     java中的一个数组是一个对象。

一维数组的定义

v      一维数组的定义方式为：

§        type arrayName[]; 或者 type[] arrayName;

§        其中类型(type)可以为java中任意的数据类型，包括简单类型和组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。

java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素的个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。必须经过初始化后，才能应用数组的元素。

一维数组的初始化(静态)

v      一维数组定义之后，必须经过初始化才可以引用。数组的初始化分为静态初始化和动态初始化两种；

 

v     静态初始化：在定义数组的同时对数组元素进行初始化

动态初始化：使用运算符new为数组分配空间，对于简单类型的数组，

一维数组初始化注意点

v      对于动态初始化一维数组;如果只new(即只分配了内存空间)没有赋值; 整型数组所有元素为0; 浮点型数组所有元素为0.0; 布尔型数组所有元素为false; 对类类型数组所有元素为null;

一维数组的使用

v      当定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。元素的引用方式为：arrayName[index]

v      另外，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度。

 

多维数组

在任何语言中，多维数组都被看作数组的数组。比如二维数组是一个特殊的一维数组，其每一个元素又是一个一维数组。

二维数组的定义

v      二维数组的定义方式:

§        type arrayName[ ][ ]; 或者 type[ ][ ] arrayName;

v      也可以这么写：

§        type[] arrayName[];

v      与一维数组一样，这时对数组元素也没有分配内存空间，同样要使用运算符new来分配内存，然后才可以访问每个元素。

二维数组初始化(静态)

v      二维数组的初始化也分为静态和动态两种。

 

v      静态初始化：在定义数组的同时为数组分配空间。
int  intArray[ ][ ]={{1,2},{2,3},{3,4}};//不必指出数组每一维的大小，系统会根据初始化时给出的初始值的个数自动算出数组每一维的大小。

 

二维数组初始化(动态)

v      动态初始化：对多维数组来说，分配内存空间有下面两种方法：

§        直接为每一维分配空间;

v      从最高维开始(而且必须从最高维开始)，分别为每一维分配空间，如：

int ary[ ][ ]=new int[2][ ];

ary[0]=new int[2];

ary[1]=new int[3];

ary[0][0]=11; ary[0][1]=12;

…

v      通过上面可以看出，高维数组是特殊的一维数组;

v      获取高维数组的第一维长度: ary.length; 获取第一维中第一个元素数组长度为: ary[0].length;依次类推;

 

补充：java数组初始化详解：

一维数组
1)   int[] a;   //声明,没有初始化

2)   int[] a=new int[5];  //初始化为默认值,int型为0

3)   int[] a={1,2,3,4,5};   //初始化为给定值

4)   int[]a=new int[]{1,2,3,4,5};   //同(3) 
     int[] a=new int[5]{1,2,3,4,5};   //错误,如果提供了数组初始化操作，则不能定义维表达式

5)   int[] a;  
     a=new int[5];    //正确,同(2)一样

int[] a;
      a={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用，如（3）

6)   int a[];
     a[0]=1;   //错误,因为数组没有初始化,不能赋值
     a[1]=2; 

二维数组
1)   int[][] a;  //声明,没有初始化

2)   int[][] a=new int[2][3];    //初始化为默认值,int型为0

3)   int[][] a={{1,2},{2,3},{3,4}};   //初始化为给定值
     int[][] a={{1,2},{2,3},{3,4,5}};   //没有错,数组空间不是连续分配的，所以不要求每一维的大小相同

4)   int[][] a=new int[2][];
     a[0]=new int[3];  //a[0]其实就是一个数组
     a[1]=new int[4];  //每一维的大小可以不一样;

5)   int[][]a=new int[][]{{1,2},{2,3},{3,4,5}};   //同(3) 
     int[] a=new int[5]{{1,2},{2,3},{3,4,5}};  //错误,如果提供了数组初始化操作，则不能定义维表达式

int[][] a=new int[2][];
     a[0]={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用

6)   int[][] a=new int[2][];
     a[0][1]=1;   //错误,第二维没有初始化,不能赋值,java.lang.NullPointerException异常

总结:1.二维就是数组的数组,里面的数组大小不要求一样
       2.不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化

 

1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。

实例：
TestD.java(动态)

程序代码

public class TestD
{
    public static void main(String args[]) {
        int a[] ;
        a = new int[3] ;
        a[0] = 0 ;
        a[1] = 1 ;
        a[2] = 2 ;
        Date days[] ;
        days = new Date[3] ;
        days[0] = new Date(2008,4,5) ;
        days[1] = new Date(2008,2,31) ;
        days[2] = new Date(2008,4,4) ;
    }
}

class Date
{
    int year,month,day ;
    Date(int year ,int month ,int day) {
        this.year = year ;
        this.month = month ;
        this.day = day ;
    }
}

TestS.java(静态):

程序代码

public class TestS
{
    public static void main(String args[]) {
        int a[] = {0,1,2} ;
        Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;
    }
}

class Time
{
    int hour,min,sec ;
    Time(int hour ,int min ,int sec) {
        this.hour = hour ;
        this.min = min ;
        this.sec = sec ;
    }
}

TestDefault.java(默认):

程序代码

public class TestDefault
{
    public static void main(String args[]) {
        int a [] = new int [5] ;
        System.out.println("" + a[3]) ;
    }
} 

 

 

 

转载于:https://my.oschina.net/u/2552902/blog/543904