2. 程式人生 > >Java基礎_0306：數組的定義與使用

Java基礎_0306：數組的定義與使用

阿新 • • 發佈：2018-01-24
ima 數組長度 基本類型 對象數組 books 改變 image for循環 基本數據

數組

數組指的就是一組相關變量的集合。例如：如果說現在要想定義100個整型變量，按照傳統的思路，可能這樣定義：
int i1,i2 ,... i100，一共寫100個變量。
以上的形式的確可以滿足技術要求，但是這裏有一個問題，這100多個變量沒有任何的邏輯的控制關系，完全獨立，就會出現對象不方便管理的情況。那麽在這種情況下就可以利用數組來解決此類問題。

數組的定義語法

  • 聲明並開辟數組：

    數據類型 數組名稱 [] = new 數據類型 [長度] ;
數據類型 [] 數組名稱 = new 數據類型 [長度] ;

  • *分步完成**：

    聲明數組：數據類型 數組名稱 [] = null ;
開辟數組：數組名稱 = new 數據類型 [長度] ;

    數組操作說明

    當數組開辟空間之後，那麽可以采用“數組名稱[下標|索引]”的形式進行訪問，但是所有數組的下標都是從0開始的，即：如果是3個長度的數組，那麽下標的範圍：0 ~ 2（0、1、2一共是三個內容）。如果訪問的時候超過了數組的允許下標的長度，那麽會出現數組越界異常（ArrayIndexOutOfBoundsException）。

以上給出的數組定義結構使用的是動態初始化的方式，即：數組會首先開辟內存空間，但是數組中的內容都是其對應數據類型的默認值，如果現在聲明的是int型數組，則數組裏面的全部內容都是其默認值：0。

由於數組是一種順序的結構，並且數組的長度都是固定的，那麽可以使用循環的方式輸出，很明顯需要知道for循環，而且在Java裏面為了方便數組的輸出提供有一個“數組名稱.length”的屬性，可以取得數組長度。

定義數組

public class ArrayDemo {
    public static void main(String args[]) {
        int data[] = new int[3];    // 聲明並開辟了一個3個長度的數組
        data[0] = 10;       // 設置數組內容
        data[1] = 20;       // 設置數組內容
        data[2] = 30;       // 設置數組內容
        for (int x = 0; x < data.length; x++) { // 循環輸出數組
            System.out.print(data[x] + "、");
        }
    }
}
程序執行結果： 10、20、30、

數組操作

技術分享圖片

數組的引用傳遞

public class ArrayDemo {
    public static void main(String args[]) {
        int data[] = new int[3];    // 聲明並開辟了一個3個長度的數組
        data[0] = 10;       // 設置數組內容
        data[1] = 20;       // 設置數組內容
        data[2] = 30;       // 設置數組內容
        int temp[] = data;      // 數組引用傳遞
        temp[0] = 99;       // 修改數組內容
        for (int x = 0; x < data.length; x++) { // 循環輸出數組
            System.out.print(data[x] + "、");
        }
    }
}
程序執行結果： 99、20、30、

數組引用傳遞

技術分享圖片

數組靜態初始化

  • 格式一：簡化格式

    數據類型 數組名稱 [] = {值,值,...} ;

  • 格式二：完整格式

    數據類型 數組名稱 [] = new 數據類型 [] {值,值,...} ;

    ```
    public class ArrayDemo {
    public static void main(String args[]) {
    int data[] = new int[] { 1, 2, 3, 4, 5 }; // 數組的靜態初始化
    for (int x = 0; x < data.length; x++) { // 循環輸出數組
    System.out.print(data[x] + "、");
    }
    }
    }
    程序執行結果： 1、2、3、4、5、


#### 二維數組
 ![](http://images2017.cnblogs.com/blog/720033/201801/720033-20180124123707147-417336715.png)

 
#### 二維數組的定義語法

- **動態初始化**：

數據類型 數組名稱[][] = new 數據類型[行的個數][列的個數]；


- **靜態初始化**：

數據類型 數組名稱[][] = new 數據類型[][] {{值,值,值},{值,值,值}}


#### 觀察二維數組的定義及使用

public class ArrayDemo {
public static void main(String args[]) {
int data [][] = new int [][] {
{1,2,3} ,{4,5,6} , {7,8,9}
} ; // 定義二維數組
for (int x = 0; x < data.length; x++) {// 外層循環是控制數組的數據行內容
for (int y = 0; y < data[x].length; y++) { // 內層循環是控制數組的數據列內容
System.out.print(data[x][y] + "\t");
}
System.out.println(); // 換行
}
}
}
程序執行結果：
1 2 3
4 5 6
7 8 9


#### 數組與方法參數的傳遞
既然數組內容可以進行引用傳遞，那麽就可以把數組給方法之中的參數，而如果一個方法要想接收參數，則對應的參數類型必須是數組。

##### 一個數組傳遞的程序

public class ArrayDemo {
public static void main(String args[]) {
int data[] = new int[] { 1, 2, 3 }; // 開辟數組
change(data); // 引用傳遞，等價於：int temp [] = data ;
for (int x = 0; x < data.length; x++) {
System.out.print(data[x] + "、");
}
}
/**
* 此方法的主要功能是進行數組數據的改變操作，在本方法中會將數組中的每個元素內容乘2
* @param temp 要進行改變內容的數組引用
/
public static void change(int temp[]) { // 此方法定義在主類中，並且由主方法直接調用
for (int x = 0; x < temp.length; x++) {
temp[x] = 2; // 將數組的內容乘2保存
}
}
}
程序執行結果： 2、4、6、


##### 數組與方法間的引用傳遞

![](http://images2017.cnblogs.com/blog/720033/201801/720033-20180124123841225-981153310.png)


##### 數組排序

public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {2,1,9,0,5,3,7,6,8} ;
sort(data) ; // 實現排序
print(data) ;
}
public static void sort(int arr[]) { // 這個方法專門負責排序
for (int x = 0 ; x < arr.length ; x ++) {// 外層控制排序總體的次數
for (int y = 0 ; y < arr.length - 1 ; y ++) { // 內層控制每次的排序控制
if (arr[y] > arr[y + 1]) { // 判斷需要交換
int t = arr[y] ;
arr[y] = arr[y + 1] ;
arr[y + 1] = t ;
}
}
}
}
public static void print(int temp[]) {// 專門定義一個輸出的功能的方法
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}


##### 實現數組的轉置（首尾交換） —— 實現思路（元素長度為偶數）

![](http://images2017.cnblogs.com/blog/720033/201801/720033-20180124123911350-1546702225.png)


##### 實現數組的轉置（首尾交換） —— 實現思路（元素長度為奇數）

![](http://images2017.cnblogs.com/blog/720033/201801/720033-20180124123933209-644460415.png)

public class ArrayDemo {
public static void main(String args[]) {
int data [] = new int [] {1,2,3,4,5,6,7} ;
reverse(data) ;// 實現轉置
print(data) ; // 輸出數組內容
}
public static void reverse(int arr[]) { // 此方法專門實現數組的轉置操作
int len = arr.length / 2 ;// 轉置的次數
int head = 0 ; // 頭部索引
int tail = arr.length - 1 ; // 尾部索引
for (int x = 0 ; x < len ; x ++) { // 循環次數為數組長度÷2
int temp = arr[head] ;// 數據交換
arr[head] = arr[tail] ;// 數據交換
arr[tail] = temp ;// 數據交換
head ++ ;// 頭部索引增加
tail -- ;// 尾部索引減少
}
}
public static void print(int temp[]) { // 數組輸出
for (int x = 0 ; x < temp.length ; x ++) {
System.out.print(temp[x] + "、") ;
}
System.out.println() ;
}
}
程序結果：
7、6、5、4、3、2、1、


#### 數組操作方法


**數組拷貝**：可以將一個數組的部分內容拷貝到另外一個數組之中；

System.arraycopy(源數組名稱，源數組拷貝開始索引，目標數組名稱，目標數組拷貝開始索引，長度)
數組排序：可以按照由小到大的順序對基本數據類型的數組（例如：int數組、double數組都為基本類型數組）進行排序。

**java.util.Arrays.sort(數組名稱)**；


##### 實現數組拷貝

public class ArrayDemo {
public static void main(String args[]) {
int dataA[] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }; // 定義數組
int dataB[] = new int[] { 11, 22, 33, 44, 55, 66, 77, 88 };// 定義數組
System.arraycopy(dataA, 4, dataB, 2, 3); // 數組拷貝
print(dataB);
}
public static void print(int temp[]) { // 打印數組內容
for (int x = 0; x < temp.length; x++) {
System.out.print(temp[x] + "、");
}
System.out.println();
}
}

程序執行結果： 11、22、5、6、7、66、77、88、


##### 實現排序

public class ArrayDemo {
public static void main(String args[]) {
int data[] = new int[] { 3, 6, 1, 2, 8, 0 };
java.util.Arrays.sort(data); // 數組排序
print(data);
}
public static void print(int temp[]) {// 數組輸出
for (int x = 0; x < temp.length; x++) {
System.out.print(temp[x] + "、");
}
System.out.println();
}
}
程序執行結果： 0、1、2、3、6、8、


#### 對象數組

數組是引用類型，而類也同樣是引用類型，所以如果是對象數組的話表示一個引用類型裏面嵌套其它的引用類型。
在之前使用的數組都屬於基本數據類型的數組，但是所有的引用數據類型也同樣可以定義數組，這樣的數組稱為對象數組。如果要想定義對象數組（以類為例），可以采用如下的形式完成：

- **對象數組的動態初始化**：

類名稱 對象數組名稱 = new 類名稱 [長度] ;

- **對象數組的靜態初始化**：

類名稱 對象數組名稱 = new 類名稱 [] {實例化對象,實例化對象,...} ;


#####對象數組的動態初始化

class Book {
private String title ;
private double price ;
public Book(String t,double p) {
title = t ;
price = p ;
}
// setter、getter、無參構造略
public String getInfo() {
return "書名：" + title + "，價格：" + price ;
}
}
public class ArrayDemo {
public static void main(String args[]) {
Book books [] = new Book[3] ; // 開辟了一個3個長度的對象數組，內容為null
books[0] = new Book("Java",79.8) ; // 對象數組中的每個數據都需要分別實例化
books[1] = new Book("JSP",69.8) ; // 對象數組中的每個數據都需要分別實例化
books[2] = new Book("Android",89.8) ; // 對象數組中的每個數據都需要分別實例化
for (int x = 0 ; x < books.length ; x ++) { // 循環對象數組
System.out.println(books[x].getInfo()) ;
}
}
}

程序執行結果：
書名：Java，價格：79.8
書名：JSP，價格：69.8
書名：Android，價格：89.8



##### 對象數組的靜態初始化

public class ArrayDemo {
public static void main(String args[]) {
Book books[] = new Book[] {
new Book("Java", 79.8),
new Book("JSP", 69.8),
new Book("Android", 89.8) }; // 開辟了一個三個長度的對象數組
for (int x = 0; x < books.length; x++) { // 循環輸出對象數組內容
System.out.println(books[x].getInfo());
}
}
}
程序執行結果：
書名：Java，價格：79.8
書名：JSP，價格：69.8
書名：Android，價格：89.8

```

對象數組內存關系

對象數組的最大好處是將多個對象統一進行了管理，並且除了數據類型改變之外，和之前的數組也沒有任何的區別，而且數組本身就屬於引用數據類型，那麽對象數組就是在一個引用數據類型之中嵌入了其他的引用數據類型，如果非要用內存圖表示的話，可以簡單理解為圖所示的結構。

Java基礎_0306：數組的定義與使用

相關推薦

Java基礎_0306：數組的定義與使用

ima 數組長度 基本類型 對象數組 books 改變 image for循環 基本數據 數組 數組指的就是一組相關變量的集合。例如：如果說現在要想定義100個整型變量，按照傳統的思路，可能這樣定義： int i1,i2 ,... i100，一共寫100個變量。 以上的形式

數據庫基礎(1)：數據定義

rop 數據庫基礎 class red 教師 clas 教師表 屬性 sna 1．實驗內容 1) 用Management Studio創建數據庫University_Mis 2) 使用SQL語句創建關系數據庫基本表： 學生表Students(Sno,Snam

Python開發基礎 day5 函數的定義與使用

foo asdfasd 文件 可變 ron 賦值 group max python #coding:utf-8： # x=‘你‘ # u‘hello‘ # print(x.encode(‘gbk‘)) # print(b‘\xc4\xe3‘) # y=b‘\xc4\

Java基礎6：代碼塊與代碼加載順序

+= keyword 釋放空間 避免 contain clas 接下來 一次 自動 Java基礎6：代碼塊與代碼加載順序 代碼塊：用{}包圍的代碼 java中的代碼塊按其位置劃分為四種： 局部代碼塊 位置：局部位置（方法內部） 作用：限定變量的生命周期，盡早釋放，節約

前端C#基礎：數組與集合

聲明 末尾 固定 相關 號稱 讀取數組 gif 不變 組類型 學習web前端是一個帶有一點小樂趣的過程。它是與理科思維比較相關聯的，所以學習好他就必須掌握牢固的基礎，對基礎知識的細節要了解。下面我就總結兩個我們經常用到，但又因為他們定義與用法都比較相近，而經常搞

Java數組(1)：數組與多維數組

soft arr ring 基本 int div 標識 apple 矩陣 我們對數組的基本看法是，你可以創建它們，通過使用整型索引值訪問它們的元素，並且他們的尺寸不能改變。 但是有時候我們需要評估，到底是使用數組還是更加靈活的工具。數組是一個簡單的線性序列，這使得元素訪問非

java基礎知識之循環結構與數組

建議 多行 con 導致 ++ java基礎知識 集合 情況 變化 1.for循環：for(循環變量的初始化1；循環的條件2；循環變量的變化3）{循環體4； }執行順序為：1,2,4,3,2,4,3,2,4,3,2,4,3.。。。。當2為false時結束

Java基礎2：基本數據類型與常量池

cache model ria 比較 是否 類型 misc pri pan Java基礎2：基本數據類型與常量池 基本數據類型的大小 int 32位 4字節 short 16位float 32位double 64位long 64位char 16位byte 8位boolea

oracle sql 基礎（五）：數據定義語言（創建和管理序列、索引、同義詞）

aps span 最小值 into 全表掃描 條件 creat 返回 ext 許多應用程序要求使用唯一的數字作為主鍵的值，你即可以在應用程序中構建代碼來處理這種需求，也可以用一個序列來產生唯一的數字。如果你想要增進某些查詢的性能，你應該考慮創建一個索引，你也可

C語言事實上不簡單：數組與指針

本質 而不是 getchar() alt 由於 == sizeof 不同 來看 之前在寫C的時候，沒怎麽留意數組。就這麽定義一個。然後顛來倒去的使用即可了。只是後來碰到了點問題。解決後決定寫這麽一篇博客，數組離不開指針。索性就放一起好了。 如今我定義了一個數組：i

《Java從入門到放棄》JavaSE篇：數組

java 數組 數組，就是一組數！！！之前我們學習的變量只能保存一個數據，如果一個部門有50個員工的姓名要保存，怎麽辦？如果定義50個變量··················String name1;String name2;............String name49;String name5

題目一：使用Java實現二維數組中的查找

ray class 如果 strong www. 循環 順序 選擇 com 考點：數組 題目：二維數組中的查找 描述：在一個二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，

曉蓮說-何不原創：java 實現二維數組冒泡排序

java println 變量 冒泡排序 cnblogs 交換 public 自己 代碼 新手從業路-為自己回顧知識的同時，也希望和大家分享經驗： 話不多說，上代碼 public class 冒泡排序 { /** * @param admin

二、Numpy基礎：數組修改

none pad 屬性 border lex gpo 定義 ndarray 尺寸 h2 { font-size: 24px; height: 35px; line-height: 35px !important; width: 95%; background-color:

java算法面試題：有數組a[n]，用java代碼將數組元素順序顛倒

mage post alt 數組a array [] ima log 算法 package com.swift; import java.util.ArrayList; import java.util.Collections; import java.util.Lis

java二維數組定義初始化-楊輝三角

args pan string 數組定義 static highlight pri 位數 -- public class Array2Demo2_3 { public static void main(String[] args) {

Java基礎09 類數據與類方法

綜合 基本 基礎 gis value stat col 聲明 private 作者：Vamei 出處：http://www.cnblogs.com/vamei 歡迎轉載，也請保留這段聲明。謝謝！ 我們一直是為了產生對象而定義類(class)的。對象是具有功能的實體

Java入門（六）：數組

屬性 array 初始 圖片 nbsp 遍歷 屬性。 語法 規則 數組是一種數據結構，用於存儲同一類型值的集合，也可以看做是數據類型一致的一組數據。 一、語法和聲明數組 1、語法：數據類型[ ] array = new 數據類型[長度]； 註意： 使用長度創建數組的時候，每

Java中數組定義的三種方式

++ pan stat div 方式 clas 空間 inf bsp 方法一： 　　1.先聲明　　 2.分配空間　　3.賦值 　　　 public class arr{ public static void main(String[] args){

Java基礎教程：HashTable與HashMap比較

唯一性 trac 並發 con 元素 散列表 個數 AR 底層 Java基礎教程：HashTable與HashMap比較 1. 關於HashMap的一些說法： a) HashMap實際上是一個“鏈表散列”的數據結構，即數組和鏈表的結合體。HashMap的底層結構是一個數