120.Java_數組

時間 2019-11-20

標籤 120.java java 數組欄目 Java 简体版

原文原文鏈接

數組

1.綜述

　　數組是相同類型數據的有序集合。數組描述的是相同類型的若干個數據，按照必定的前後次序排列組合而成。java

　　其中，每個數據稱做一個元素，每一個元素能夠經過一個索引(下標)來訪問它們。數組

　　數組的三個基本特色：ide

　　　　1. 長度是肯定的。數組一旦被建立，它的大小就是不能夠改變的。post

　　　　2. 其元素必須是相同類型，不容許出現混合類型。學習

　　　　3. 數組類型能夠是任何數據類型，包括基本類型和引用類型。this

　　數組變量屬引用類型，數組也能夠當作是對象，數組中的每一個元素至關於該對象的成員變量。spa

　　數組自己就是對象，Java中對象是在堆中的，所以數組不管保存原始類型仍是其餘對象類型，數組對象自己是在堆中存儲的。3d

2.一維數組簡介

2.1 聲明方式

一維數組
type[]  arr_name; //（推薦使用這種方式）
type  arr_name[];

注意：code

1. 聲明的時候並無實例化任何對象，只有在實例化數組對象時，JVM才分配空間，這時才與長度有關。
2. 聲明一個數組的時候並無數組真正被建立。
3. 構造一個數組，必須指定長度。對象

//建立基本類型一維數組
public class Test {
    public static void main(String args[]) {
        int[] s = null; // 聲明數組；
        s = new int[10]; // 給數組分配空間；
        for (int i = 0; i < 10; i++) {
            s[i] = 2 * i + 1;//給數組元素賦值；
            System.out.println(s[i]);
        } 
    }
}

 1 //建立引用類型一維數組
 2 class Man{
 3     private int age;
 4     private int id;
 5     public Man(int id,int age) {
 6         super();
 7         this.age = age;
 8         this.id = id;
 9     }
10 }
11 public class AppMain {
12     public static void main(String[] args) {
13         Man[] mans;  //聲明引用類型數組； 
14         mans = new Man[10];  //給引用類型數組分配空間；
15          
16         Man m1 = new Man(1,11);
17         Man m2 = new Man(2,22);  
18          
19         mans[0]=m1;//給引用類型數組元素賦值；
20         mans[1]=m2;//給引用類型數組元素賦值；
21     }
22 }

2.2 初始化

　　數組的初始化方式總共有三種：靜態初始化、動態初始化、默認初始化。

2.2.1 靜態初始化

　　除了用new關鍵字來產生數組之外，還能夠直接在定義數組的同時就爲數組元素分配空間並賦值。

int[] a = { 1, 2, 3 };// 靜態初始化基本類型數組；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 靜態初始化引用類型數組；

//表格數據模型是計算機世界最廣泛的模型
//可使用一個一維數組存儲表格每一行
Object[] a1 = {111,"num1",18,"first","2001-1-11"};
Object[] a2 = {112,"num2",19,"second","2001-11-11"};
Object[] a3 = {113,"num3",20,"last","2001-1-1"};
//此處基本數據類型」1001」，本質不是Object對象。
//JAVA編譯器會自動把基本數據類型「自動裝箱」成包裝類對象。

2.2.2 動態初始化

數組定義與爲數組元素分配空間並賦值的操做分開進行

int[] a1 = new int[2];//動態初始化數組，先分配空間；
a1[0]=1;//給數組元素賦值；
a1[1]=2;//給數組元素賦值；

2.2.3 數組的默認初始化

數組是引用類型，它的元素至關於類的實例變量，

所以數組一經分配空間，其中的每一個元素也被按照實例變量一樣的方式被隱式初始化。

//數組的默認初始化
int a2[] = new int[2]; // 默認值：0,0
boolean[] b = new boolean[2]; // 默認值：false,false
String[] s = new String[2]; // 默認值：null, null

2.3 數組遍歷

2.3.1 length

數組元素下標的合法區間：[0, length-1]

能夠經過下標來遍歷數組中的元素，遍歷時能夠讀取元素的值或者修改元素的值

 1 //使用循環遍歷初始化和讀取數組
 2 public class Test {
 3     public static void main(String[] args) {
 4         int[] a = new int[4];
 5         //初始化數組元素的值
 6         for(int i=0;i<a.length;i++){
 7             a[i] = 100*i;
 8         }
 9         //讀取元素的值
10         for(int i=0;i<a.length;i++){
11             System.out.println(a[i]);
12         }
13     }
14 }

length字段的使用
對於一維數組，「數組名.length」的值就是數組中元素的個數；
對於二維數組「數組名.length」的值是它含有的一維數組的個數 
例如： float   boy  []=new float[4];
                  boy.length的值爲4.
      int  [][] a = new int[3][8];
                   a.length的值是3.
                   a[0].length的值是8
                   a[1].length的值是8
                   a[2].length的值是8

2.3.2 for - each

加強for循環for-each是JDK1.5新增長的功能，

專門用於讀取數組或集合中全部的元素，即對數組進行遍歷

1 //加強for循環
2 public class Test {
3     public static void main(String[] args) {
4         String[] ss = { "aa", "bbb", "ccc", "ddd" };
5         for (String temp : ss) {
6             System.out.println(temp);
7         }
8     }
9 }

注意：

1. for-each加強for循環在遍歷數組過程當中不能修改數組中某元素的值。
2. for-each僅適用於遍歷，不涉及有關索引(下標)的操做。

2.4數組元素的使用

一維數組經過索引（下標運算）符訪問本身的元素。如：boy[0]，boy[1]等.

須要注意的是索引從0開始，所以，數組如有4個元素，那麼索引到3爲止，若是程序使用了以下語句：
boy[4] = 384.98f;

程序能夠編譯經過，但運行時將發生ArrayIndexOutOfBoundsException異常，所以在使用數組時必須謹慎，防止索引越界。

3.多維數組

　　多維數組能夠當作以數組爲元素的數組。

　　能夠有二維、三維、甚至更多維數組，可是實際開發中用的很是少。

　　最多到二維數組(學習容器後，咱們通常使用容器，二維數組用的都不多)

3.1 二維數組

3.1.1 二維數組的聲明

聲明二維數組有下列兩種格式：

數組的元素類型 數組名[][];
數組的元素類型 [][] 數組名; 
//例如：
float a[][];
Char [][] b;

public class Test {
    public static void main(String[] args) {
        // Java中多維數組的聲明和初始化應按從低維到高維的順序進行
        int[][] a = new int[3][];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        // int a1[][]=new int[][4];//非法
    }
}

3.1.2 二維數組初始化

1）二維數組靜態初始化

//二維數組靜態初始化
public class Test {
    public static void main(String[] args) {
        int[][] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
        System.out.println(a[2][3]);
    }
}

2）二維數組的動態初始化

//二維數組的動態初始化
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[][] a = new int[3][];
        // a[0] = {1,2,5}; //錯誤，沒有聲明類型就初始化
        a[0] = new int[] { 1, 2 };
        a[1] = new int[] { 2, 2 };
        a[2] = new int[] { 2, 2, 3, 4 };
        System.out.println(a[2][3]);
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}
//能夠爲二維數組中的一維數組專門分配空間

//二維數組保存表格數據
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        Object[] a1 = {1001,"高淇",18,"講師","2006-2-14"};
        Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
        Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};
        Object[][]  emps = new Object[3][];
        emps[0] = a1;
        emps[1] = a2;
        emps[2] = a3;
        System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));  
    }
}

3.1.3 獲取數組長度

//獲取的二維數組第一維數組的長度。
System.out.println(a.length);
//獲取第二維第一個數組長度。
System.out.println(a[0].length);

length字段的使用
對於一維數組，「數組名.length」的值就是數組中元素的個數；
對於二維數組「數組名.length」的值是它含有的一維數組的個數 
例如： float   boy  []=new float[4];
                  boy.length的值爲4.
      int  [][] a = new int[3][8];
                   a.length的值是3.
                   a[0].length的值是8
                   a[1].length的值是8
                   a[2].length的值是8

4.數組與類

4.1 System類

4.1.1 數組拷貝

System類裏也包含了一個static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，

該方法能夠將src數組裏的元素值賦給dest數組的元素，

其中srcpos指定從src數組的第幾個元素開始賦值，length參數指定將src數組的多少個元素賦給dest數組的元素。

//數組拷貝
public class Test {
    public static void main(String args[]) {
        String[] s = {"test1","new1","test2","new2","test3"}; 
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }
    }
}

4.2 java.util.Arrays類

JDK提供的java.util.Arrays類，包含了經常使用的數組操做，方便咱們平常開發。

Arrays類包含了：排序、查找、填充、打印內容等常見的操做

4.2.1 打印數組

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = { 1, 2 };
        System.out.println(a); // 打印數組引用的值；
        System.out.println(Arrays.toString(a)); // 打印數組元素的值；
    }
}
// [I@15db9742
//[1,2]

注意：

此處的Arrays.toString()方法是Arrays類的靜態方法，不是前面講的Object的toString()方法。

4.2.2 數組元素的排序

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

 1 //數組元素是引用類型的排序(Comparable接口的應用)
 2 import java.util.Arrays;
 3 public class Test {
 4     public static void main(String[] args) {
 5         Man[] msMans = { new Man(3, "a"), new Man(60, "b"), new Man(2, "c") };
 6         Arrays.sort(msMans);
 7         System.out.println(Arrays.toString(msMans));
 8     }
 9 }
10  
11 class Man implements Comparable {
12     int age;
13     int id;
14     String name;
15  
16     public Man(int age, String name) {
17         super();
18         this.age = age;
19         this.name = name;
20     }
21  
22     public String toString() {
23         return this.name;
24     }
25  
26     public int compareTo(Object o) {
27         Man man = (Man) o;
28         if (this.age < man.age) {
29             return -1;
30         }
31         if (this.age > man.age) {
32             return 1;
33         }
34         return 0;
35     }
36 }

數組元素是引用類型的排序(Comparable接口的應用)

4.2.3 二分法查找

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);   //使用二分法查找，必須先對數組進行排序;
        System.out.println(Arrays.toString(a));
        //返回排序後新的索引位置,若未找到返回負數。
        System.out.println("該元素的索引："+Arrays.binarySearch(a, 12)); 
    }
}

4.2.4 數組填充

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] a= {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100);  //將2到4索引的元素替換爲100;
        System.out.println(Arrays.toString(a));
    }
}