java中數組的一些筆記,Java的數組

本文目錄一覽：

• 1、JAVA中數組的優點
• 2、java的數組有些不懂 請高人指點?????
• 3、Java語言中，數組的實現原理是什麼？
• 4、java中數組的特點？數組的聲明和初始化方法和簡單變量有什麼不同?

JAVA中數組的優點

1.1 越界檢查

1.2 length field：與傳統的C++中的數組相比，length字段可以方便的得到數組的大小；但要注意，僅僅可以得到數組的大小，不能得到數組中實際包含多少個元素，因為length 只會告訴我們最多可將多少元素置入那個數組。

1.3 初始化：對象數組在創建之初會自動初始化成null，由原始數據類型構成的數組會自動初始化成零（針對數值類型），(Char)0 （針對字符類型）或者false （針對布爾類型）。

1.4 數組作為返回值：首先，既然數組是對象，那麼就可以把這個對象作為返回值；而且，不必擔心那個數組的是否可用只要需要它就會自動存在而且垃圾收集器會在我們完成後自動將其清除

2. 通用算法

2.1 在java.util 中的Arrays 數組類容納着一系列靜態方法可簡化我們對數組的操作，總共有四個函數。equals()用於比較兩個數組是否相等、fill()可將一個值填入數組、sort()可對數組排序、而binarySearch()用於在排好序的數組中查找一個元素。所有這些方法都已為全部原始數據類型及對象重載使用。除此以外還有一個asList()方法可用它獲取任意數組然後把數組轉變成一個List 容器。

2.2 sort和binarySearch的使用：在Java 2 中有兩個辦法可提供比較功能。第一個辦法是用自然比較方法,這是通過實現java.lang.Comparable 接口來實現。Java 2 提供的第二個辦法來進行對象的比較，單獨創建一個類實現名為Comparator 的一個接口。接口提供了兩個方法分別是compare()和equals() 。不過除非考慮到一些特殊的性能方面的因素，否則我們用不着實現equals() ，因為每次創建一個類的時候它都會默認從Object 繼承，而Object 已經有了一個equals()。Comparator可以作為sort和binarySearch方法的參數。

java的數組有些不懂 請高人指點?????

java數組定義和賦值2007-11-25 18:39數組是有序數據的集合，數組中的每個元素具有相同的數組名和下標來唯一地確定數組中的元素。

§5.1一維數組

一、一維數組的定義

type arrayName[];

其中類型(type)可以為Java中任意的數據類型，包括簡單類型組合類型，數組名arrayName為一個合法的標識符，[]指明該變量是一個數組類型變量。例如：

int intArray[];

聲明了一個整型數組，數組中的每個元素為整型數據。與C、C++不同，Java在數組的定義中並不為數組元素分配內存，因此[]中不用指出數組中元素個數，即數組長度，而且對於如上定義的一個數組是不能訪問它的任何元素的。我們必須為它分配內存空間，這時要用到運算符new，其格式如下：

arrayName=new type[arraySize];

其中，arraySize指明數組的長度。如：

intArray=new int[3];

為一個整型數組分配3個int型整數所佔據的內存空間。

通常，這兩部分可以合在一起，格式如下：

type arrayName=new type[arraySize];

例如：

int intArray=new int[3];

二、一維數組元素的引用

定義了一個數組，並用運算符new為它分配了內存空間後，就可以引用數組中的每一個元素了。數組元素的引用方式為：

arrayName[index]

其中：index為數組下標，它可以為整型常數或表達式。如a[3]，b[i](i為整型)，c[6*I]等。下標 從0開始，一直到數組的長度減1。對於上面例子中的in-tArray數來說，它有3個元素，分別為：

intArray[0]，intArray[1]，intArray[2]。注意：沒有intArray[3]。

另外，與C、C++中不同，Java對數組元素要進行越界檢查以保證安全性。同時，對於每個數組都有一個屬性length指明它的長度，例如：intArray.length指明數組intArray的長度。

例5.1

public class ArrayTest{

public static void main(String args[]){

int i;

int a[]=newint[5];

for(i=0;i＜5;i++)

a[i]=i;

for(i=a.length-1;i＞=0;i–)

System.out.println(“a[“+i+”]=”+a[i]);

}

}

運行結果如下：

C:\＞java ArrayTest

a[4]=4

a[3]=3

a[2]=2

a[1]=1

a[0]=0

該程序對數組中的每個元素賦值，然後按逆序輸出。

三、一維數組的初始化

對數組元素可以按照上述的例子進行賦值。也可以在定義數組的同時進行初始化。

例如：

int a[]={1，2，3，4，5};

用逗號(，)分隔數組的各個元素，系統自動為數組分配一定空間。

與C中不同，這時Java不要求數組為靜態(static)。

四、一維數組程序舉例：

例5.2Fibonacci數列

Fibonacci數列的定義為：

F1=F2=1，Fn=Fn-1+Fn-2(n＞=3)

public classFibonacci{

public static void main(String args[]){

int i;

int f[]=new int[10];

f[0]=f[1]=1;

for(i=2;i＜10;i++)

f[i]=f[i-1]+f[i-2];

for(i=1;i＜=10;i++)

System.out.println(“F[“+i+”]=”+f[i-1]);

}

}

運行結果為：

C:\＞java Fibonacci

F[1]=1

F[2]=1

F[3]=2

F[4]=3

F[5]=5

F[6]=8

F[7]=13

F[8]=21

F[9]=34

F[10]=55

例5.3冒泡法排序(從小到大)

冒泡法排序對相鄰的兩個元素進行比較，並把小的元素交到前面。

public class BubbleSort{

public static void main(String args[]){

int i，j;

int intArray[]={30，1，-9，70，25};

int l=intArray.length;

for(i=0;i＜l-1;i++)

for(j=i+1;j＜l;j++)

if(intArray[i]＞intArray[j]){

int t=intArray[i];

intArray[i]=intArray[j];

intArray[j]=t;

}

for(i=0;i＜l;i++)

System.out.println(intArray[i]+””);

}

}

運行結果為：

C:\＞java BubbleSort

-9

1

25

30

70

§5.2多維數組

與C、C++一樣，Java中多維數組被看作數組的數組。例如二維數組為一個特殊的一維數組，其每個元素又是一個一維數組。下面我們主要以二維數為例來進行說明，高維的情況是類似的。

一、二維數組的定義

二維數組的定義方式為：

type arrayName[][];

例如：

int intArray[][];

與一維數組一樣，這時對數組元素也沒有分配內存空間，同要使用運算符new來分配內存，然後才可以訪問每個元素。

對高維數組來說，分配內存空間有下面幾種方法：

1直接為每一維分配空間，如：

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

2從最高維開始，分別為每一維分配空間，如：

int a[][]=new int[2][];

a[0]=new int[3];

a[1]=new int[3];

完成1中相同的功能。這一點與C、C++是不同的，在C、C++中必須一次指明每一維的長度。

二、二維數組元素的引用

對二維數組中每個元素，引用方式為：arrayName[index1][index2] 其中index1、index2為下標，可為整型常數或表達式，如a[2][3]等，同樣，每一維的下標都從0開始。

三、二維數組的初始化

有兩種方式：

1直接對每個元素進行賦值。

2在定義數組的同時進行初始化。

如：int a[][]={{2，3}，{1，5}，{3，4}};

定義了一個3×2的數組，並對每個元素賦值。

四、二維數組舉例：

例5.4矩陣相乘

兩個矩陣Am×n、Bn×l相乘得到Cm×l，每個元素Cij= aik*bk (i=1..m，n=1..n)

public class MatrixMultiply{

public static void main(String args[]){

int i，j，k;

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

int b[][]={{1，5，2，8}，{5，9，10，-3}，{2，7，-5，-18}};

int c[][]=new int[2][4];

for(i=0;i＜2;i++)

for(j=0;j＜3;j++)

a[i][j]=(i+1)*(j+2);

for(i=0;i＜2;i++){

for(j=0;j＜4;j++){

c[i][j]=0;

for(k=0;k＜3;k++)

c[i][j]+=a[i][k]*b[k][j];

}

}

System.out.println(“\n***MatrixA***”);

for(i=0;i＜2;i++){

for(j=0;j＜3;j++)

System.out.print(a[i][j]+””);

System.out.println();

}

System.out.println(“\n***MatrixB***”);

for(i=0;i＜3;i++){

for(j=0;j＜4;j++)

System.out.print(b[i][j]+””);

System.out.println();

}

System.out.println(“\n***MatrixC***”);

for(i=0;i＜2;i++){

for(j=0;j＜4;j++)

System.out.print(c[i][j]+””);

System.out.println();

}

}

}

其結果為：

C:\＞java MatrixMultiply

for(j=0;j＜4;j++)

System.out.print(c[i][j]+””);

System.out.println();

}

}

}

其結果為：

C:\＞java MatrixMultiply

***MatrixA***

2 3 4

4 6 8

***MatrixB***

1 5 2 8

5 9 10 -3

2 7 -5 -18

***MatrixC***

25 65 14 -65

50 130 28 -130

如果你學過線性代數，應該可以比較好地理解多維數組。

多維數組和矩陣結合緊密。

a[i][j]就是第i-1行的第j-1列的元素，因為下標是從0開始的。

比如：

一個數組：1 2 3

4 5 6

a[0][0]=1 a[0][1]=2 a[0][2]=3

a[1][0]=3 a[1][1]=5 a[1][2]=6

Java語言中，數組的實現原理是什麼？

這個涉及到編譯原理的問題，我只能說，這是一個編譯規範。在規範中比如：int[]，中的int告訴計算機這是一個整型數據，[]告訴計算機這是一個連續存儲的內存地址空間，簡單點說一個連續數據的存儲空間就是數組，數組只是一個名稱！！當然我只是簡略的這樣說，實際上數組是很複雜的！！

java中數組的特點？數組的聲明和初始化方法和簡單變量有什麼不同?

java語言中，數組是一種最簡單的複合數據類型。數組是有序數據的集合，數組中的每個元素具有相同的數據類型，可以用一個統一的數組名和下標來唯一地確定數組中的元素。數組有一維數組和多維數組。

★ 一維數組

1． 一維數組的定義

type arrayName[ ]；

類型(type)可以為Java中任意的數據類型，包括簡單類型和複合類型。

例如：

　int intArray[ ]；

　Date dateArray[];

2．一維數組的初始化

◇ 靜態初始化

int intArray[]={1,2,3,4};

String stringArray[]={“abc”, “How”, “you”};

◇ 動態初始化

　 1）簡單類型的數組

int intArray[];

intArray = new int[5];

　2）複合類型的數組

String stringArray[ ];

String stringArray = new String[3];/*為數組中每個元素開闢引用

　 空間(32位) */

stringArray[0]= new String(“How”);//為第一個數組元素開闢空間

stringArray[1]= new String(“are”);//為第二個數組元素開闢空間

stringArray[2]= new String(“you”);// 為第三個數組元素開闢空間

3．一維數組元素的引用

數組元素的引用方式為：

　arrayName[index]

index為數組下標，它可以為整型常數或表達式，下標從0開始。每個數組都有一個屬性length指明它的長度，例如：intArray.length指明數組intArray的長度。

★多維數組

Java語言中，多維數組被看作數組的數組。

1．二維數組的定義

type arrayName[ ][ ]；

type [ ][ ]arrayName;

2．二維數組的初始化

◇ 靜態初始化

int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};

Java語言中，由於把二維數組看作是數組的數組，數組空間不是連續分配的，所以不要求二維數組每一維的大小相同。

◇ 動態初始化

1) 直接為每一維分配空間，格式如下：

arrayName = new type[arrayLength1][arrayLength2];

int a[ ][ ] = new int[2][3]；

2) 從最高維開始，分別為每一維分配空間：

arrayName = new type[arrayLength1][ ];

arrayName[0] = new type[arrayLength20];

arrayName[1] = new type[arrayLength21];

…

arrayName[arrayLength1-1] = new type[arrayLength2n];

3) 例：

二維簡單數據類型數組的動態初始化如下,

int a[ ][ ] = new int[2][ ]；

a[0] = new int[3];

a[1] = new int[5];

對二維複合數據類型的數組，必須首先為最高維分配引用空間，然後再順次為低維分配空間。

而且，必須為每個數組元素單獨分配空間。

例如：

String s[ ][ ] = new String[2][ ];

s[0]= new String[2];//為最高維分配引用空間

s[1]= new String[2]; //為最高維分配引用空間

s[0][0]= new String(“Good”);// 為每個數組元素單獨分配空間

s[0][1]= new String(“Luck”);// 為每個數組元素單獨分配空間

s[1][0]= new String(“to”);// 為每個數組元素單獨分配空間

s[1][1]= new String(“You”);// 為每個數組元素單獨分配空間

3．二維數組元素的引用

對二維數組中的每個元素，引用方式為：arrayName[index1][index2]

例如： num[1][0];

4．二維數組舉例：

【例2．2】兩個矩陣相乘

public class MatrixMultiply{

　public static void main(String args[]){

　int i,j,k;

　int a[][]=new int [2][3]; //動態初始化一個二維數組

　int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//靜態初始化

一個二維數組

　int c[][]=new int[2][4]; //動態初始化一個二維數組

　for (i=0;i2;i++)

　for (j=0; j3 ;j++)

a[i][j]=(i+1)*(j+2);

　for (i=0;i2;i++){

　for (j=0;j4;j++){

c[i][j]=0;

　for(k=0;k3;k++)

　c[i][j]+=a[i][k]*b[k][j];

}

　}

　System.out.println(“*******Matrix C********”);//打印Matrix C標記

　for(i=0;i2;i++){

　for (j=0;j4;j++)

System.out.println(c[i][j]+” “);

　System.out.println();

}

　}

　}