JavaSE基礎:數組

時間  2019-11-17
標籤 javase 基礎 數組 欄目 Java 简体版
原文   原文鏈接

數組與方法

數組按照使用能夠分爲一維數組/二維數組/多維數組.java

1.數組的概述

  • 數組是相同數據類型的有序集合數組

    數組描述的是相同類型的若干個數據,按照必定的前後次序排列組合而成.其中,每一個數據稱做一個數組的元素,每一個數組元素能夠經過一個索引(或者下標)來訪問它們.spa

  • 數組的三個特色:.net

    • 數組的長度是肯定的. 數組當被建立時,它的大小就是不能夠改變的.
    • 數組元素必須是相同類型,不容許出現混合類型
    • 數組中的元素能夠是任何數據類型,包括基本數據類型和引用數據類型

2.一維數組

(1) 聲明方式

  • 方式一code

    數據類型 數組名[] = null ;   //聲明一維數組
數組名 = new 數組類型[長度]; // 分配內存給數組
複製代碼

  • 方式二cdn

    數據類型[] 數組名 = null ;   //聲明一維數組
數組名 = new 數組類型[長度]; // 分配內存給數組
複製代碼

  • 簡寫方式對象

    數據類型 數組名[] = new 數據類型[個數]; //聲明數組的同時分配內存
複製代碼

(2) 數組中元素的表示方法

  • 數組的聲明以及簡單輸出blog

    package com.shxt.demo01;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] score = null; //聲明數組,可是爲開闢內存空間
        score = new int[3]; //爲數組開闢"堆內存"空間

        System.out.println("score[0]="+score[0]); //分別輸出數組的每一個元素
        System.out.println("score[1]="+score[1]); //分別輸出數組的每一個元素
        System.out.println("score[2]="+score[2]); //分別輸出數組的每一個元素

        // 使用循環依次輸出數組中的所有內容
        for (int i = 0; i < 3; i++) {
            System.out.println("score["+i+"]="+score[i]);
        }
    }
}
複製代碼

    對於數組的訪問採用"數組名稱[索引或者下標]"的方式,索引從0開始計數,假設程序中取出的內容超過了這個下標範圍,例如:score[3]程序運行會存在如下的異常錯誤提示信息:排序

    java.lang.ArrayIndexOutOfBoundsException:3
複製代碼

    提示的內容爲數組索引超出綁定的異常(常常說的數組越界異常),這個是將來大家初學者常常出現的問題,請引發重視.此外,咱們發現以上的程序運行的結果的內容都是"0",這是由於聲明的數組是整型數組.索引

    默認初始化數據:數組元素至關於對象的成員變量,默認值跟成員的規則是同樣的,重點記憶!

    系統將按照以下規則分配初識值:

    • 數組元素的類型是基本類型中的整數類型(byte,short,int和long),則數組元素的值爲0
    • 數組元素的類型是基本類型中的浮點類型(float,double),則數組元素的值爲0.0
    • 數組元素的類型是基本類型中的字符類型(char),則數組元素的值爲'\u0000'(空格)
    • 數組元素的類型是基本類型中的布爾類型(boolean),則數組元素的值爲false
    • 數組元素的類型是引用數據類型(類,接口和數組),則數組元素的值爲null

  • 爲數組中的元素賦值並進行輸出

    聲明整型數組,長度爲5,經過for循環賦值1,3,5,7,9的數據

    package com.shxt.demo01;

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] score = null; //聲明數組,可是爲開闢內存空間
        score = new int[5]; //爲數組開闢"堆內存"空間

        for (int i = 0; i < 5; i++) {
            score[i] = i*2+1;
        }

        for (int i = 0; i < 5; i++) {
            System.out.println("score["+i+"]="+score[i]);
        }

    }
}
複製代碼

  • 數組長度的取得

    數組名稱.length  --> 返回一個int型的數據
複製代碼
    package com.shxt.demo01;

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] score =  new int[5];
        System.out.println("數組長度爲:"+score.length);
    }
}
複製代碼

    ​

(3) 數組的初始化方式

  • 動態初始化

    以前練習的就是使用的動態初始化方式

    package com.shxt.demo01;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] score = null; //聲明數組,可是爲開闢內存空間
        score = new int[3]; //爲數組開闢"堆內存"空間
		
      	score[0] = 100;
        score[1] = 200;
        score[2] = 300;
    }
}
複製代碼

  • 靜態初始化

    數據類型[] 數組名={初始值0,初始值1,...,初始值N}
或者
數據類型[] 數組名 = new 數據類型[]{初始值0,初始值1,...,初始值N}
複製代碼
    package com.shxt.demo01;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] score =  {10,20,30,40,50};
        for (int i = 0; i < score.length; i++) {
            System.out.println("score["+i+"]="+score[i]);
        }
    }
}
複製代碼

(4) 課堂練習

  • 已知一個字符數組char[] letterArray = new char[26],請動態初始化數據爲A~Z

    package com.shxt.demo01;

public class ArrayDemo05 {
    public static void main(String[] args) {
        char[] letterArray = new char[26];

        for (int i = 0; i < letterArray.length; i++) {
            letterArray[i] = (char)('A'+i);
        }

        for (int i = 0; i < letterArray.length; i++) {
            System.out.print(letterArray[i]+"\t");
        }
    }
}
複製代碼

  • 請求數組中最大和最小值

    package com.shxt.demo01;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int array[]={74,12,48,888,30,5,17,62,777,666};
        int max = array[0];
        int min = array[0];

        for (int i = 0; i < array.length; i++) {
            if(array[i]>max){
                max=array[i];
            }
            if(array[i]<min){
                min=array[i];
            }
        }

        System.out.println("最高成績:"+max);
        System.out.println("最低成績:"+min);
    }
}
複製代碼

  • 對整數數組按照由小到大的順序進行排序

    public class ArrayDemo07 {
    public static void main(String[] args) {
        int arr[] = {13,34,57,78,99,66,43,45,87,100};

        for (int i = 0 ; i < arr.length; i++) {
            for (int j = 0; j < arr.length-1; j++) {
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.print("第"+i+"次排序的結果:\t");
            for (int k = 0; k < arr.length; k++) {
                System.out.print(arr[k]+"\t");
            }
            System.out.println();
        }
        System.out.print("最終的排序結果:\t");
        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k]+"\t");
        }
    }
}

複製代碼

    排序自學參考資料: http://geek.csdn.net/news/detail/113928

(5) 數組的問題

  • 數組必定要初始化嗎?

    在以前咱們說在使用Java數組以前必需要先初始化數組(即在使用數組以前,必須先建立數組).實際上,若是真正掌握了Java數組中的分配機制,那麼能夠徹底換一個方式來初始化數組.

    始終記住:Java的數組變量只是引用類型的變量,它並非數組對象自己,只是讓數組變量指向有效的數組對象,程序中便可使用該數組變量

    package com.shxt.demo01;

public class ArrayDemo08 {
    public static void main(String[] args) {
        // 靜態初始化:定義而且初始化nums數組
        int nums[] = {13,34,57,100};
        // 定義一個scores數組變量
        int[] scores;
        //讓scores數組執行nums所引用的數組
        scores = nums ;
        // 對scores進行變量
        System.out.print("scores數組數據:");
        for (int i = 0; i < scores.length; i++) {
            System.out.print(scores[i]+"\t");
        }
        // 將scores數組中第3個元素賦值爲200
        scores[2] = 200;
        // 訪問 nums 數組的第3個元素,將看到輸出值爲200
        System.out.println("\nnums 數組的第3個元素,將看到輸出值爲:"+nums[2]);

    }
}
複製代碼

    既然數組內容能夠進行引用傳遞,那麼就能夠把數組做爲方法中的參數,而若是一個方法想接收參數,則對應的參數類型必須是數組

  • 使用方法接收數組

    package com.shxt.demo01;

public class ArrayDemo09 {
    public static void main(String[] args) {
        // 靜態初始化:定義而且初始化nums數組
        int nums[] = {13,34,57,100};
        // 引用傳遞, int[] temp = nums
        print(nums);
    }

    public static void print(int[] temp){
        for (int i = 0; i < temp.length; i++) {
            System.out.print(temp[i]+"\t");
        }
    }
}	
複製代碼

  • 使用方法修改數組的內容

    package com.shxt.demo01;

public class ArrayDemo10 {
    public static void main(String[] args) {
        // 靜態初始化:定義而且初始化nums數組
        int nums[] = {1,2,3,4,5};
        // 引用傳遞, int[] temp = nums
        inc(nums);  //擴容操做
        print(nums); //打印內容
    }

    public static void inc(int[] temp){
        for (int i = 0; i < temp.length; i++) {
            temp[i]*=2;
        }
    }

    public static void print(int[] temp){
        for (int i = 0; i < temp.length; i++) {
            System.out.print(temp[i]+"\t");
        }
    }
}
複製代碼

3.二維數組

以前定義的數組只有一個"[]",表示一維數組,若是有兩個"[]"就是二維數組,其實本質上不存在多維數組的概念,其實就是一維數組中有嵌套了數組而已

  • 一維數組表格表示

    索引 0 1 2 3 4 5
    數據 10 20 30 40 50 60

    ​

  • 二維數組表格表示int[3][6]

    索引 0 1 2 3 4 5
    0 3 4 5 6 7 8
    1 10 20 30 50 40 60
    2 111 222 333 444 555 666

  • 二維數組的定義

    • 動態初始化

      數據類型[][]  數組名 = new 數據類型[行數][列數];
複製代碼

    • 靜態初始化

      數據類型[][]  數組名 = new 數據類型[[]{{值1,值2},{值1,值2,值3...},{值1...}};
複製代碼

  • 遍歷二維數組

    package com.shxt.demo01;

public class ArrayDemo11 {
    public static void main(String[] args) {
        int[][] data = new int[][]{{1,2,3},{10},{100,200}};

        for (int i = 0; i < data.length; i++) { //循環行數
            for (int j = 0; j < data[i].length; j++) { //循環列數
                System.out.print(data[i][j]+"\t");
            }
            System.out.println();
        }
    }
}
複製代碼

    ​

4.Java新特性對數組的支持

(1) 可變參數

在調用一個方式,必須根據方法的定義傳遞指定的參數,可是在JDK1.5以後產生了新的概念--可變參數(即方法中能夠接收的參數再也不是固定的,而是隨着須要傳遞的)

a.可變參數的定義格式

返回值類型 方法名稱(數據類型... 參數名稱)
複製代碼

方法中傳遞可變參數以後, 實際上參數是以 數組 的形式保存下來的,關鍵點

b.使用可變參數定義的方法

package com.shxt.demo02;

public class TestVarArgus {

    public static void main(String[] args) {
        System.out.println("不傳遞參數 fun():");
        fun(); //不傳遞參數

        System.out.println("傳遞1個參數 fun(100) :");
        fun(100); //傳遞一個參數

        System.out.println("\n傳遞2個參數 fun(10,20,30,40,50) :");
        fun(10,20,30,40,50); //傳遞5個參數
    }

    public static void fun(int... params){ //可變參數能夠接收任意多個參數
        for (int i = 0; i < params.length; i++) {
            System.out.print(params[i]+"\t"); // 實際上參數是以 數組 的形式保存下來的
        }
    }
}
複製代碼

代碼分析:

經過main方法裏的調用，能夠看出來這個可變參數既能夠是沒有參數（空參數），也能夠是不定長的。看到這裏估計都能明白，這個不定長的參數其實和數組參數挺像的。事實上，也確實是這麼回事兒。編譯器會在悄悄地把這最後一個形參轉化爲一個數組形參，並在編譯出的class文件裏做上一個記號，代表這是個實參個數可變的方法。請看代碼：

fun();//fun(int[] intArray{}); 
fun(100);//fun(int[] intArray{100}); 
fun(10,20,30,40,50);//fun(int[] intArray{10,20,30,40,50}); 
複製代碼

c.發現問題

問題1:看看是否是這個可變參數就是數組類參數？
問題2:可變參數可否接收數組呢?
package com.shxt.demo02;

public class TestVarArgus {
    public static void main(String[] args) {
        int[] intArray = { 1, 2, 3 };
        fun(intArray); //傳遞數組,編譯經過,正常運行
    }

    public static void fun(int... params){ //可變參數能夠接收任意多個參數
        for (int i = 0; i < params.length; i++) {
            System.out.print(params[i]+"\t");
        }
    }

}
複製代碼

錯誤的示例代碼

代碼分析:

經過這兩端代碼能夠看出來,[重點知識]可變參數是兼容數組類參數的，可是數組類參數卻沒法兼容可變參數!

問題3:可變參數能夠放置在形參中的任意位置嗎?

代碼分析:

可變參數類型必須做爲參數列表的最後一項，而不能放在定長參數的前面。

問題4:重載方法的優先級問題?
package com.shxt.demo02;

public class TestVarArgus {
    public static void fun(int... intArray) {
        System.out.println("11111");
    }

    public static void fun(int num1 , int num2) {
        System.out.println("22222");
    }
    public static void main(String args[]) {
        fun(100,200);
    }
}
複製代碼

代碼分析:

控制檯的數據結果爲: 22222

這裏須要記住：能匹配定長的方法，那麼優先匹配該方法。含有不定參數的那個重載方法是最後被選中的。

留在最後的一句話: main方法的參數就是一個數組類型的，那麼它其實也是能夠改爲不定參數類型

複製代碼

d.可變參數的總結

  • 只能出如今參數列表的最後；
  • ... 位於變量類型和變量名之間，先後有無空格均可以;
  • 調用可變參數的方法時，編譯器爲該可變參數隱含建立一個數組，在方法體中以數組的形式訪問可變參數。
  • 若是一個是兩個方法是重載，一個是可變參數，一個是固定參數，而後咱們調用方法若是故常長度的能知足，那麼有優先調用固定長度的，

###(2) foreach輸出

數組的輸出一遍都會使用for循環,可是在JDK1.5後爲了方便數組的輸出,提供了foreach的語法,格式以下

for(數據類型 變量名稱 : 數組名稱){
  //代碼主體
}
複製代碼

簡單示例代碼

package com.shxt.demo02;

public class TestVarArgus {

    public static void main(String[] args) {
        System.out.println("不傳遞參數 fun():");
        fun(); //不傳遞參數

        System.out.println("傳遞1個參數 fun(100) :");
        fun(100); //傳遞一個參數

        System.out.println("\n傳遞2個參數 fun(10,20,30,40,50) :");
        fun(10,20,30,40,50); //傳遞5個參數
    }

    public static void fun(int... params){ //可變參數能夠接收任意多個參數
        for (int num : params) {
            System.out.print(num+"\t");
        }
    }

}
複製代碼

擴展說明:

能夠反編譯class文件,咱們會看到加強(增強)for循環的語法結構爲:

public static void fun(int... params) {
  int[] var1 = params;
  int var2 = params.length;

  for(int var3 = 0; var3 < var2; ++var3) {
    int num = var1[var3];
    System.out.print(num + "\t");
  }

}
複製代碼
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程