Java数组

Java 数组

数组中的元素都是统一类型。数组的长度在创建时确定，并且在创建后不变。如果需要建立存储不同类型数组的集合，或者要求这种数据存储结构的长度可以动态变化，可以使用Java.util包中的各种集合(collection)类，如Vector等。

1. 数组的声明

可以声明任何类型的数组，包括基本数据类型和类类型的数组。数组的声明和其他类型的变量的声明一样，包括两个部分：数组的类型和数组的名字。声明数组由以下两种格式：

1. 将表示数组的[]跟随在数组变量之后
   这种格式时C，C++，Java的标准格式。例如:

   char s[];
   Point p[];		//Point是一个类
   

2. 将表示数组的[]跟随在数组类型之后
   这种格式是Java特有的，例如：

   char[] s;
   Point[] p;
   
   //这种格式中，在数组标志[]后出现的所有变量都将是数组的变量。例如：
   char[] s,m,n;        //声明了三个字符数组变量s,m,n.
   

   ==注意：==在数组的声明中不指定数组的长度

   在Java中数组是作为类来处理的。在Java中类类型变量的声明并不创建该类的对象。所以数组的声明并不创建实例数组的数据空间，而是给该数组变量分配了一个可用来引用该数组的引用空间。

2. 数组的创建与初始化

1. 用new创建数组

   数组元素所需的内存空间是通过new运算符或通过数组初始化分配的。通过new运算符创建数组的格式如下：

   new elementType[arraySize];
   

   例如，对于前面已经声明的字符串数组s，可以利用下述语句创建它的数据空间，从而创建一个能够容纳20个字符的数组：

   s = new char[20]
   

2. 数组的长度
   Java中为所有数组设置了一个表示数组元素个数的特性变量length，它作为数组的一部分存储起来。Java用该变量在运行时进行数组越界检查，应用程序中也可以访问该变量获取数组长度，格式如下：

   arrayname.length;
   //例如
   s.length;
   

   数组在创建后长度不可变，因此不能改变数组的长度，但可以使用该数组变量指向另一个全新数组，则通过该变量将不能访问到原来数组的值。例如：

   int a[] = new int[6];
   a[0] = 10;
   ...
   a = new int[10];		//不在再次声明a，此时a[0]的值为0，而不是10
   ...
   

   //创建整型数组并将其打印输出
   
   public class ArrayDome{
       public static void main(String[] args){
           int[] anArray;			//声明一个整型数组
           anArray = new int[10];	//创建数组
           
           ///给数组每个元素赋值并打印输出
           for(int i = 0;i < anArray.lenngth;i++){
               anArray[i] = i;
               System.out.print(anArray[i] + "");
           }
           System.out.println();
       }
   }
   

3. 对象数组
   除了创建基本类型数组，还可以创建对象数组。例如

   Point p[];
   p = new Point[10];			//创建包含10个Point类型对象引用的数组
   //创建10个Point对象
   for(int i = 0; i < 10 ;i++){
       p[i] = new Point(i,i+1);
   }
   

   上述语句执行后，数组p在内存中的布局如下图
   

4. 通过初始化创建数组

   Java中可以在数组声明中直接给数组赋初值。这样可以通过一条语句完成数组的声明，创建与初始化3项功能，因此是一种数组定义中的简捷方法。例如：

   //声明并创建一个有3个元素的字符串数组names
   String names[] = {"Jack","wang","Lee"};
   //声明并创建一个有两个元素的Date类型的数组dates
   Date dates[] = {
       new Date(10,9,2000),
       new Date(10,9,2001)
   };
   //数组dates的定义等价于
   Date dates[];
   dates = new Date[2];
   date[0] = new Date(10,9,2000);
   date[1] = new Date(10,9,2001);
   

   对象数组操作例子：

   //创建字符串数组并将其元素转化为小写输出
   public class ArrayOfStringDemo{
       public static void main(String[] args){
           String[] anArray = {"String One","String Two","String Three"};
           for(int i = 0;i < anArray.length;i++){
               //toLowerCase() 方法用于将大写字符转换为小写。
               System.out.println(anArray[i].toLowerCase());
           }
       }
   }
   

3. 多维数组

Java语言的多维数组可以看作是数组的数组，即n维数组的n-1维数组的数组。

1. 多维数组的声明
   多维数组的声明格式与一维数组相类似，只是要用多个[]表示数组,一般n维数组要用n对[].例如:

   int a[][];
   int[][] a;
   //上述两条语句是等价的,声明了一个二维int型数组a
   

2. 多为数组的实例化

   多维数组的实例化可以采用多种方式,并可以采用构造规则数组和不规则数组

   • 直接为每一堆分配内存,创建规则数组.例如:

     int a[][];
     a = new int[4][4];
     

     上述第一条语句声明了一个int型二维数组a,第二条语句创建了一个有4行4列元素的数组.由于Java中的二维数组是数组的数组,所以创建二维数组a实际上是分配了4个int型数组的引用空间,它们分别指向4个能容纳4个int型数组的空间.如图所示
     

   • 从最高维起,分别为每一维分配空间.这种方式可以构造不规则数组.例如:

     int a[][] = new int[2][];	//只有最后维可以不给值,其他都要给
     a[0] = new int [10];
     a[1] = new int [5];
     //上述语句声明并创建了一个二维不规则数组.
     

     ==注意:==上述第一条语句的new表达式中,数组的最高维的长度必须指定,其他维可以不给出

   //利用二维int型数组表达一个矩阵,创建该数组并将其元素打印输出
   public class ArrayOfArraysDemo1{
       public static void main(String[] args){
           int[][] aMatrix = new int[4][];		//aMatrix指向由4个引用组成的数组
           
           //创建每个int数组,并赋值
           for(int i = 0;i < aMatrix[i].length;j++){
               aMatrix[i] = new int[5];
               for(int j = 0;j < aMatrix[i].length;j++){
                   aMatrix[i][j] = i + j;
               }
           }
           //将数组打印输出
           for(int i = 0;i < aMatrix.length;i++){
               for(int j = 0;j < aMatrix[i].length;j++){
                   System.out.print(aMatrix[i][j] + "")
               }
               System,out.println();
           }
       } 
   }
   

   //通过初始化创建二维数组,并将数组元素打印输出
   public class ArrayOfArraysDemo2{
       public static void main(Sttring[] args){
           String[][] cartoons = {
               {"Flintatones","Fred","Wilna","Pebbles","Dino"},
               {"Rubbles","Barney","Jane","Elroy","Judy","Rosie","Astro"},
               {"Scooby Doo Gang","Scooby Doo","Shaggy","Velna","Fred","Daphne"}
           };
           
           for(int i = 0;i < cartoons.length;i++){
               System.out.print("cartoons[" + i + "]" + "," + cartoons[i].length + "elements:");
               for(int j = 0;j < cartoons[i].length;j++){
                   System.out.print(cartoons[i][j] + (j<cartoons[i].length - 1 ? "," : " "));
               }
               System.out.println();
           }
       }
   }
   

4. 增强的for循环

作用:为了便于对数组和集合中的元素进行迭代梳理.定义如下:

for(类型 标识符:可迭代的表达式)	语句;

其中,括号中的"类型 标识符"指定了一种类型的标识符,该标识符的类型应与冒号后面的表达式的类型兼容.“可迭代类型的表达式"一般是数组或集合,”:"可理解为in.例如:

int[] numbers = {1,2,3,4,5,6,7,8,9,10};
for(int element : numbers){
    System.out.print(element);
}
//上述循环可被读为:
for each element in numbers do {...}

因此这种形式的for循环使程序更加易于理解并更加紧凑,应该尽量采用

//增强for循环实例
public class NewArrayOfStringDemo{
    public static void main(String[] args){
        String[] anArray = {"String one","String Two","String Three"};
        for(String s : anArray){
            //toLowerCase() 方法用于将大写字符转换为小写。
            System.out.print(s.toLowerCase());
        }
    }
}

5. 数组的复制

数组变量之间赋值时引用赋值,不能实现数组数据复制,例如:

int a[] = new int[];
int b[];
b = a;
//上述关系如下图所示

进行数组数据的复制,要使Java语言在java.lang.System类中提供的数组复制方法,该方法的定义如下:

public static void arraycopy(Object source,
                             int srcIndex,Object dest,int destIndex,int length)
//scouce---源数组;
//srcIndex---源数组开始复制的位置;
//dest---目的数组;
//destIndex---目的数组中开始存放复制数据的位置;
//length---复制元素的个数

//将一个字符数组的部分数据复制到另一个数组中
public class ArrayCopyDemo{
    public static void main(String[] args){
        char[] copyFrom = {'d','e','a','f','f','e','i','n','a','t','t','e','d'};
        char[] copyTo = new char[7];
        
        System.arraycopy(copyFrom,2,copyTo,0,7);
        System.out.println(new String(copyTo));
    }
}
//运行如下图