完整的java數(shù)組操作應(yīng)用知識(shí)匯總

數(shù)組是同一種類型數(shù)據(jù)的集合，其實(shí)就是一個(gè)容器。運(yùn)算的時(shí)候有很多數(shù)據(jù)參與運(yùn)算,那么首先需要做的是什么。不是如何運(yùn)算而是如何保存這些數(shù)據(jù)以便于后期的運(yùn)算，那么數(shù)組就是一種用于存儲(chǔ)數(shù)據(jù)的方式，能存數(shù)據(jù)的地方我們稱之為容器，容器里裝的東西就是數(shù)組的元素,數(shù)組可以裝任意類型的數(shù)據(jù)，雖然可以裝任意類型的數(shù)據(jù),但是定義好的數(shù)組只能裝一種元素， 也就是數(shù)組一旦定義，那么里邊存儲(chǔ)的數(shù)據(jù)類型也就確定了。

1.在Java中，無論使用數(shù)組或集合，都有邊界檢查。如果越界操作就會(huì)得到一個(gè)RuntimeException異常。

2.數(shù)組只能保存特定類型。數(shù)組可以保存原生數(shù)據(jù)類型，集合則不能。集合不以具體的類型來處理對(duì)象，它們將所有對(duì)象都按Object類型處理，集合中存放的是對(duì)象的引用而不是對(duì)象本身。

3.集合類只能保存對(duì)象的引用。而數(shù)組既可以創(chuàng)建為直接保存原生數(shù)據(jù)類型，也可以保存對(duì)象的引用。在集合中可以使用包裝類（Wrapper Class），如Integer、Double等來實(shí)現(xiàn)保存原生數(shù)據(jù)類型值。

4.對(duì)象數(shù)組和原生數(shù)據(jù)類型數(shù)組在使用上幾乎是相同的；唯一的區(qū)別是對(duì)象數(shù)組保存的是引用，原生數(shù)據(jù)類型數(shù)組保存原生數(shù)據(jù)類型的值。

int a = 10;
 
Integer integer = new Integer(a);
 
int b = integer.intValue();
 
System.out.println(a = b);

如果需要存儲(chǔ)大量的數(shù)據(jù)，例如如果需要讀取100個(gè)數(shù)，那么就需要定義100個(gè)變量，顯然重復(fù)寫100次代碼，是沒有太大意義的。如何解決這個(gè)問題，Java語言提供了數(shù)組（array）的數(shù)據(jù)結(jié)構(gòu)，是一個(gè)容器可以存儲(chǔ)相同數(shù)據(jù)類型的元素，可以將100個(gè)數(shù)存儲(chǔ)到數(shù)組中。這時(shí)候數(shù)組就有很大的幫助了~

格式一：

元素類型[]數(shù)組名 = new元素類型[元素個(gè)數(shù)或數(shù)組長度];

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

格式二：

元素類型[]數(shù)組名 = new元素類型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};
 
int[] arr = {3,5,1,7};

注意：給數(shù)組分配空間時(shí)，必須指定數(shù)組能夠存儲(chǔ)的元素個(gè)數(shù)來確定數(shù)組大小。創(chuàng)建數(shù)組之后不能修改數(shù)組的大小?？梢允褂胠ength屬性獲取數(shù)組的大小。

為了使用數(shù)組必須在程序中聲明數(shù)組，并指定數(shù)組的元素類型=左半部分：

先寫左邊明確了元素類型 是int ，容器使用數(shù)組，那么如何來標(biāo)識(shí)數(shù)組？.那么用一個(gè)特殊的符號(hào)[]中括號(hào)來表示。想要使用數(shù)組是需要給數(shù)組起一個(gè)名字的,那么我們?cè)谶@里給這個(gè)數(shù)組起名字為arr .接著跟上等號(hào)。

代碼體現(xiàn)： 

int [] arr

示例：

String[] aArray = new String[5];  
String[] bArray = {"a","b","c", "d", "e"};  
String[] cArray = new String[]{"a","b","c","d","e"}; 

注意：int arr[] 也是一種創(chuàng)建數(shù)組的格式。推薦使用int [] arr 的形式聲明數(shù)組。

創(chuàng)建數(shù)組的三種方式及區(qū)別

public static void main(String[] args) {  
    // 1.方式一  聲明 分配空間并賦值  
    int[] arr1 = {1,2,3};  
    // 2.方式二 顯示初始化  
    int[] arr2;  
    arr2 = new int[]{1,2,3};   
    // 3.方式三 顯示初始化()  
    int[] arr3;  
    arr3 = new int[3];  
}  

他們的區(qū)別，方式一：在聲明的時(shí)候直接就已經(jīng)分配空間，并賦值，方式一是不能寫成如下這種形式的。

int[] arr1;  
arr1 = {1,2,3};//錯(cuò)誤寫法 編譯不通過  

方式二和方式三,聲明和內(nèi)存分配是分開的，如上面的例子，

int[] arr2;  和  int[] arr3;  

這一步是在?？臻g分配一個(gè)引用，存放的是一個(gè)引用，null

arr2 = new int[]{1,2,3};<span style="font-family: Arial, Helvetica, sans-serif;">arr3 = new int[3];</span>  

到這一步的時(shí)候jvm才開始在內(nèi)存堆區(qū)域分配空間，并賦值，方式二直接賦值 1,2,3  方式三 默認(rèn)初始化，基本類型是 0  布爾類型是 false 引用類型為null，

注：內(nèi)存一旦分配不能改變，所有說數(shù)組長度固定

方式一：不使用運(yùn)算符new

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

方式二：使用運(yùn)算符new

int[] arr2 = new int[] { 1, 2, 3, 4, 5 };
int[] arr3=new int[3];
arr3[0]=1;
arr3[1]=5;
arr3[2]=6;

如果數(shù)組初始化中不使用運(yùn)算符new。需要注意：下列寫法是錯(cuò)誤的。

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

此時(shí)初始化數(shù)組，必須將聲明，創(chuàng)建，初始化都放在一條語句中個(gè)，分開會(huì)產(chǎn)生語法錯(cuò)誤。

所以只能如下寫：

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

Arrays類是一個(gè)非常有用數(shù)組工具類，里面有很多工具方法，檢索、填充、排序、比較、toString()等。

下面給個(gè)例子：

import java.util.Arrays; 

/** 
* 數(shù)組綜合測(cè)試 
* 
* @author leizhimin 2009-7-28 12:35:41 
*/ 
public class TestArrays { 
        public static void main(String[] args) { 
                int[] i = new int[10]; 
                //填充數(shù)組 
                Arrays.fill(i, 2); 
                //遍歷數(shù)組 
                for (int x : i) { 
                        System.out.print(x + " "); 
                } 
                //toString()數(shù)組 
                System.out.println("\n" + Arrays.toString(i)); 
                //復(fù)制數(shù)組 
                int[] b = new int[12]; 
                System.arraycopy(i, 0, b, 2, 5); 
                System.out.println(Arrays.toString(b)); 
                //一維數(shù)組的比較 
                int[] c = new int[3]; 
                int[] d = new int[3]; 
                Arrays.fill(c, 3); 
                Arrays.fill(d, 3); 
                System.out.println(c.equals(d)); 
                System.out.println(Arrays.equals(c, d)); 
                System.out.println("-------------"); 
                int[][] a1 = {{1, 2, 3}, {4, 5, 6}}; 
                int[][] a2 = {{1, 2, 3}, {4, 5, 6}}; 
                System.out.println(a1.equals(a2)); 
                System.out.println(Arrays.equals(a1, a2)); 
                System.out.println(Arrays.deepEquals(a1, a2)); 
                //深度toString() 
                System.out.println(Arrays.toString(a1)); 
                System.out.println(Arrays.deepToString(a1)); 

                //數(shù)組的排序 
                int[] a3 = {3, 2, 5, 4, 1}; 
                System.out.println(Arrays.toString(a3)); 
                Arrays.sort(a3); 
                System.out.println(Arrays.toString(a3)); 
                //一維數(shù)組數(shù)值檢索 
                int index1 = Arrays.binarySearch(a3, 4); 
                int index2 = Arrays.binarySearch(a3, -12); 
                int index3 = Arrays.binarySearch(a3, 8); 
                System.out.println(index1 + " " + index2 + " " + index3); 
        } 
}

執(zhí)行結(jié)果：

2 2 2 2 2 2 2 2 2 2    
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2] 
[0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0] 
false 
true 
------------- 
false 
false 
true 
[[I@3e25a5, [I@19821f] 
[[1, 2, 3], [4, 5, 6]] 
[3, 2, 5, 4, 1] 
[1, 2, 3, 4, 5] 
3 -1 -6 

Process finished with exit code 0

public static void main(String[] args) {
int[] x = { 1, 2, 3 };
for (int y = 0; y < 3; y++) {
System.out.println(x[y]);
// System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;
} // 那么這就是數(shù)組的第一個(gè)常見操作.遍歷
}

數(shù)組中有一個(gè)屬性可以獲取到數(shù)組中元素的個(gè)數(shù),也就是數(shù)組的長度.數(shù)組名.length

public static void main(String[] args) {
int[] x = { 1, 2, 3 };
for (int y = 0; y < x.length; y++) {
System.out.println(x[y]);
// System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;
} // 那么這就是數(shù)組的第一個(gè)常見操作.遍歷
}

java.lang.System
 
public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

參數(shù)：

src - 源數(shù)組。
srcPos - 源數(shù)組中的起始位置。
dest - 目標(biāo)數(shù)組。
destPos - 目標(biāo)數(shù)據(jù)中的起始位置。
length - 要復(fù)制的數(shù)組元素的數(shù)量。

1、數(shù)組角標(biāo)越界異常:，注意：數(shù)組的角標(biāo)從0開始。

public static void main(String[] args) {
int[] x = { 1, 2, 3 };
System.out.println(x[3]);
//java.lang.ArrayIndexOutOfBoundsException
}

2、空指針異常:

public static void main(String[] args) {
int[] x = { 1, 2, 3 };
x = null;
System.out.println(x[1]);
// java.lang.NullPointerException
}

數(shù)組:
什么時(shí)候使用數(shù)組:當(dāng)元素較多時(shí)為了方便操作這些數(shù)組,會(huì)先進(jìn)行來臨時(shí)存儲(chǔ)，所使用的容器就是數(shù)組。

特點(diǎn):
數(shù)組長度是固定的。

1、一個(gè)數(shù)組取出最大值

 /*定義一個(gè)獲取最大值的功能：
1、確定結(jié)果 ：返回值類型 int
2、未知內(nèi)容：要獲取哪個(gè)數(shù)組的最大值沒有確定，則是數(shù)組沒有確定
 

思路：

1、定義一個(gè)變量，記錄住數(shù)組的比較大的元素。
2、遍歷整個(gè)數(shù)組，讓數(shù)組的每一個(gè)元素都和該變量進(jìn)行對(duì)比即可。
3、當(dāng)變量遇到比它大的元素，則讓該變量記錄該元素的值，當(dāng)循環(huán)結(jié)束時(shí)，最大   值產(chǎn)生了

*/
public static int getMax(int[] arr)
{
//定義變量記錄較大的值，初始化為數(shù)組中的任意一個(gè)元素。
int max = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}

2、直接排序

使用直接排序?qū)?shù)組進(jìn)行排序：

 /*

 選擇排序。

 以一個(gè)角標(biāo)的元素和其他元素進(jìn)行比較。

 在內(nèi)循環(huán)第一次結(jié)束，最值出現(xiàn)的頭角標(biāo)位置上。

*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)//為什么y的初始化值是 x+1？因?yàn)槊恳淮伪容^，
//都用x角標(biāo)上的元素和下一個(gè)元素進(jìn)行比較。
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
 }

3、冒泡排序

/*
冒泡排序。
比較方式：相鄰兩個(gè)元素進(jìn)行比較。如果滿足條件就進(jìn)行位置置換。
原理：內(nèi)循環(huán)結(jié)束一次，最值出現(xiàn)在尾角標(biāo)位置。
*/
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-x-1; y++)//-x:讓每次參與比較的元減。
//-1:避免角標(biāo)越界。
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}

4、折半查找（二分法）

/*
為了提高查找效率，可使用折半查找的方式，注意：這種查找只對(duì)有序的數(shù)組有效。
這種方式也成為二分查找法。
*/
public static int halfSeach(int[] arr,int key)
{
int min,mid,max;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}

5、數(shù)組翻轉(zhuǎn)

/*
反轉(zhuǎn)其實(shí)就是頭角標(biāo)和尾角標(biāo)的元素進(jìn)行位置的置換，
然后在讓頭角標(biāo)自增。尾角標(biāo)自減。
當(dāng)頭角標(biāo)<尾角標(biāo)時(shí)，可以進(jìn)行置換的動(dòng)作。
*/
public static void reverseArray(int[] arr)
{
for(int start=0,end=arr.length-1; start<end; start++,end--)
{
swap(arr,start,end);
}
}
//對(duì)數(shù)組的元素進(jìn)行位置的置換。
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

6、多維數(shù)組

Java語言中，多維數(shù)組被看作數(shù)組的數(shù)組。

①二維數(shù)組的定義

type arrayName[ ][ ]；   
type [ ][ ]arrayName; 

②二維數(shù)組的初始化

靜態(tài)初始化

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

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

動(dòng)態(tài)初始化

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

arrayName = new type[arrayLength1][arrayLength2];   
int a[ ][ ] = new int[2][3]； 

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

arrayName = new type[arrayLength1][ ];   
arrayName[0] = new type[arrayLength20];   
arrayName[1] = new type[arrayLength21];   
…   
arrayName[arrayLength1-1] = new type[arrayLength2n]; 

例： 二維簡單數(shù)據(jù)類型數(shù)組的動(dòng)態(tài)初始化如下：

int a[ ][ ] = new int[2][ ]；   
a[0] = new int[3];   
a[1] = new int[5]; 

對(duì)二維復(fù)合數(shù)據(jù)類型的數(shù)組，必須首先為最高維分配引用空間，然后再順次為低維分配空間。而且，必須為每個(gè)數(shù)組元素單獨(dú)分配空間。

例如：

String s[ ][ ] = new String[2][ ];   
s[0]= new String[2];//為最高維分配引用空間  
s[1]= new String[2]; //為最高維分配引用空間  
s[0][0]= new String("Good");// 為每個(gè)數(shù)組元素單獨(dú)分配空間  
s[0][1]= new String("Luck");// 為每個(gè)數(shù)組元素單獨(dú)分配空間  
s[1][0]= new String("to");// 為每個(gè)數(shù)組元素單獨(dú)分配空間  
s[1][1]= new String("You");// 為每個(gè)數(shù)組元素單獨(dú)分配空間 

③二維數(shù)組元素的引用


對(duì)二維數(shù)組中的每個(gè)元素，引用方式為：

arrayName[index1][index2]

例如：

num[1][0]; 

④二維數(shù)組舉例：

【例】兩個(gè)矩陣相乘

public 
class MatrixMultiply{   
public 
static 
void main(String args[]){   
int i,j,k;   
int a[][]=new 
int [2][3]; //動(dòng)態(tài)初始化一個(gè)二維數(shù)組  
int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//靜態(tài)初始化  
 
一個(gè)二維數(shù)組   
int c[][]=new 
int[2][4]; //動(dòng)態(tài)初始化一個(gè)二維數(shù)組  
for (i=0;i<2;i++)   
for (j=0; j<3 ;j++)   
a[j]=(i+1)*(j+2);   
for (i=0;i<2;i++){   
for (j=0;j<4;j++){   
c[j]=0;   
for(k=0;k<3;k++)   
c[j]+=a[k]*b[k][j];   
}   
}   
System.out.println("*******Matrix C********");//打印Matrix C標(biāo)記  
for(i=0;i<2;i++){   
for (j=0;j<4;j++)   
System.out.println(c[j]+" ");   
System.out.println();   
}   
}   
} 

7、List相互轉(zhuǎn)換的方法

①List轉(zhuǎn)換成為數(shù)組。（這里的List是實(shí)體是ArrayList)

調(diào)用ArrayList的toArray方法。

toArray

public <T> T[] toArray(T[] a)返回一個(gè)按照正確的順序包含此列表中所有元素的數(shù)組；返回?cái)?shù)組的運(yùn)行時(shí)類型就是指定數(shù)組的運(yùn)行時(shí)類型。如果列表能放入指定的數(shù)組，則返回放入此列表元素的數(shù)組。否則，將根據(jù)指定數(shù)組的運(yùn)行時(shí)類型和此列表的大小分配一個(gè)新的數(shù)組。

如果指定的數(shù)組能容納列表并有剩余空間（即數(shù)組的元素比列表的多），那么會(huì)將數(shù)組中緊跟在集合末尾的元素設(shè)置為 null。這對(duì)確定列表的長度很有用，但只 在調(diào)用方知道列表中不包含任何 null 元素時(shí)才有用。

指定者：
接口 Collection<E> 中的 toArray

指定者：
接口 List<E> 中的 toArray

覆蓋：
類 AbstractCollection<E> 中的 toArray

參數(shù)：
a - 要存儲(chǔ)列表元素的數(shù)組，如果它足夠大的話；否則，它是一個(gè)為存儲(chǔ)列表元素而分配的、具有相同運(yùn)行時(shí)類型的新數(shù)組。

返回：
包含列表元素的數(shù)組。

拋出：
ArrayStoreException - 如果 a 的運(yùn)行時(shí)類型不是此列表中每個(gè)元素的運(yùn)行時(shí)類型的超類型。

具體用法：

List list = new ArrayList();
list.add("1");
list.add("2");
final int size =　list.size();
String[] arr = (String[])list.toArray(new String[size]);

②數(shù)組轉(zhuǎn)換成為List。

調(diào)用Arrays的asList方法.

　　

asList

　　

public static <T> List<T> asList(T... a)返回一個(gè)受指定數(shù)組支持的固定大小的列表。（對(duì)返回列表的更改會(huì)“直寫”到數(shù)組。）此方法同 Collection.toArray 一起，充當(dāng)了基于數(shù)組的 API 與基于 collection 的 API 之間的橋梁。返回的列表是可序列化的，并且實(shí)現(xiàn)了 RandomAccess。

　　

此方法還提供了一個(gè)創(chuàng)建固定長度的列表的便捷方法，該列表被初始化為包含多個(gè)元素：

　　 

List stooges = Arrays.asList("Larry", "Moe", "Curly");

　　

參數(shù)：

a - 支持列表的數(shù)組。

　　

返回：

指定數(shù)組的列表視圖。

　　

另請(qǐng)參見：

Collection.toArray()

　　

具體用法:

String[] arr = new String[] {"1", "2"};
List list = Arrays.asList(arr);