Java基礎（06）— 數組

時間  2020-08-08
標籤 java 基礎 數組 欄目 Java 简体版
原文   原文鏈接

數組

數組的概述

  • 數組是相同類型數據的有序集合
  • 數組描述的是相同類型的若干個數據，按照必定的前後次序排列組合而成
  • 其中，每個數據稱做一個數組元素，每一個數組元素能夠經過一個下標來訪問它們

數組聲明建立

  • 首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法:java

    dataType[] arrayRefVar; // 首選的方法
dataType arrayRefVar[]; // 效果相同，但不是首選方法

  • Java語言使用new操做符來建立數組，語法以下:算法

    dataType[] arrayRefVar = new dataType[arraySize] ;

  • 數組的元素是經過索引訪問的,數組索引從0開始。小程序

  • 獲取數組長度：arrays . length數組

    public static void main(String[] args) {
    /*
      變量類型  變量名字  =  變量的值
      數組類型  數組名字  =  數組的值
     */
    int[] nums;//1.聲明一個數組
    nums = new int[10]; //2.建立數組，分配空間
    //3.給數組元素中賦值
    nums[0] = 1;
    nums[1] = 2;
    nums[2] = 3;
    nums[3] = 4;
    nums[4] = 5;
    nums[5] = 6;
    nums[6] = 7;
    nums[7] = 8;
    nums[8] = 9;
//  nums[9] = 10; //若nums[9]不賦值，那它會有個默認值0
//  nums[10] = 11; //java.lang.ArrayIndexOutOfBoundsException
    //取值
    System.out.println(nums[7]);
    //計算全部元素的和
    int sum = 0;
    //獲取數組長度：arrays.length
    for (int i = 0; i < nums.length; i++) {
        sum = sum + nums[i];
    }
    System.out.println(「總和爲：」+sum);
}

  • 內存分析工具

  • 代碼分析內存優化

  • 數組的三種初始化spa

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

    //動態初始化，包含默認初始化
    int[] b = new int[10];
    b[0] = 10;
    System.out.println(b[0]);
    System.out.println(b[1]); //默認初始化值0
    System.out.println(b[2]); //默認初始化值0
    /*
     默認初始化：
     	數組是引用類型，它的元素至關於類的實例變量，所以數組一經分配空間，其中的每一個元素也被按照實例變量一樣的方式被隱式初始化
     */
}

  • 數組的四個基本特色3d

    1. 其長度是肯定的。數組一旦被建立，它的大小是不能夠改變的
    2. 其元素必須是相同類型,不容許出現混合類型
    3. 數組中的元素能夠是任何數據類型，包括基本類型和引用類型。
    4. 數組變量屬引用類型，數組也能夠當作是對象，數組中的每一個元素至關於該對象的成員變量。數組自己就是對象，Java中對象是在堆中的，所以數組不管保存原始類型仍是其餘對象類型，數組對象自己是在堆中的

  • 小結code

    • 數組是相同數據類型（數據類型能夠爲任意類型）的有序集合
    • 組也是對象。數組元素至關於對象的成員變量
    • 數組長度的肯定的，不可變的。若是越界，則報: java.lang.ArrayIndexOutOfBoundsException

數組使用

  • 普通的For循環對象

    public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5};
    //打印所有數組元素
    for (int i = 0; i < arrays.length; i++) {
        System.out.println(arrays[i]);
    }
    System.out.println("==========");
    //計算全部元素的和
    int sum = 0;
    for (int i = 0; i < arrays.length; i++) {
        sum += arrays[i];
    }
    System.out.println(sum);
    System.out.println("==========");
    //查找最大元素
    int max = arrays[0];
    for (int i = 1; i < arrays.length; i++) {
        if(arrays[i] > max){
            max = arrays[i];
        }
    }
    System.out.println(max);
}

  • For-Each循環

    public static void main(String[] args) {
	int[] arrays = {1,2,3,4,5};
	//JDK1.5，沒有下標
	for (int array : arrays) {
		System.out.println(array);
	}
}

  • 數組做方法入參

    public static void main(String[] args) {
	int[] arrays = {1,2,3,4,5};
	printArray(arrays);
}
//打印數組元素
public static void printArray(int[] arrays){
    for (int i = 0; i < arrays.length; i++) {
        System.out.println(arrays[i]+"");
    }
}

  • 數組做返回值

    ![arrays003](images/arrays003.png)public static void main(String[] args) {
	int[] arrays = {1,2,3,4,5};
	printArray(arrays);
}
//反轉數組
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];
    //反轉操做(拓展)
    for (int i = 0,j = result.length - 1; i < result.length; i++,j--) {
        result[j] = arrays[i];
    }
    return result;
}

多維數組

  • 多維數組能夠當作是數組的數組，多維數組就是一個特殊的數組，其每一個元素都是一個一維數組。

  • 二維數組

    public static void main(String[] args) {
    /*
        [4][2]
            1，2  array[0]
            2，3  array[1]
            3，4  array[2]
            4，5  array[3]
         */
    int[][] array = {{1,2},{2,3},{3,4},{4,5}};

    System.out.println(array.length);
    System.out.println(array[0].length);

    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }
}

Arrays類

  • 數組的工具類java.util.Arrays

  • 因爲數組對象自己並無什麼方法能夠供咱們調用，但API中提供了一個工具類Arrays供咱們使用，從而能夠對數據對象進行一些基本的操做

  • 查看JDK幫助文檔

  • Arrays類中的方法都是static修飾的靜態方法,在使用的時候能夠直接使用類名進行調用,而"不用"使用對象來調用(注意:是"不用"而不是"不能")

  • 具備如下經常使用功能：

    • 給數組賦值：經過 fill 方法。
    • 對數組排序：經過 sort 方法,按升序排序
    • 比較數組：經過 equals 方法比較數組中元素值是否相等。
    • 查找數組元素： 經過 binarySearch 方法能對排序好的數組進行二分查找法操做。
    public static void main(String[] args) {
    int[] a = {1, 2, 3, 4, 9090, 31231, 543, 21, 3, 23};
    System.out.println(a);  //[I@1b6d3586 數組對象的hashcode
    //打印數組元素
    System.out.println(Arrays.toString(a));
    //排序
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));
    //填充
//  Arrays.fill(a,0); //所有填充
    Arrays.fill(a,2,4,9);//按下標填充
    System.out.println(Arrays.toString(a));
}

冒泡排序

  • 冒泡排序無疑是最爲出名的排序算法之一， 總共有八大排序!

  • 冒泡的代碼仍是至關簡單的，兩層循環，外層冒泡輪數，裏層依次比較，江湖中人人盡皆知。

  • 咱們看到嵌套循環，應該立馬就能夠得出這個算法的時間複雜度爲0(n2)

  • 思考：如何優化

    public static void main(String[] args) {
    /*
     	  1.比較數組中，兩個相鄰的元素，若是第一個比第二個數大，咱們就交換位置
        2.每次比較，都會出現一個最大或最小的數
        3.下一輪則能夠少一次
        4.依次循環，知道結束
     */
    int[] a = {1,2,43,12,34,22,56,343,213,91};
    sort(a);
    System.out.println(Arrays.toString(a));

}
public static int[] sort(int[] array){
    //臨時變量
    int temp = 0;
    //外層循環，判斷咱們須要走多少次
    for (int i = 0; i < array.length - 1; i++) {
        Boolean flag = false;//減小沒有意義的比較
        //內層循環，比較兩個數，第一個數大於第二個交換位置
        for (int j = 0; j < array.length -1 - i; j++) {
            if(array[j+1] < array[j]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if(flag == false){
            break;
        }

    }
    return array;
}

稀鬆數組

  • 當一個數組中大部分元素爲0，或者爲同一-值的數組時，能夠使用稀疏數組來保存該數組

  • 稀疏數組的處理方式（壓縮）

    • 記錄數組一共有幾行幾列，有多少個不一樣值
    • 把具備不一樣值的元素和行列及值記錄在一個小規模的數組中，從而縮小程序的規模

    /*
    五子棋遊戲中，有存盤推出和續上盤得功能
  */
public static void main(String[] args) {
    /*
        1.建立一個二維數組
            11 * 11
            0：沒有棋子
            1：黑棋
            2：白棋
         */
    int[][] array1 = new int[11][11];
    array1[1][2] = 1;
    array1[2][3] = 2;
    //輸出原始得數組
    System.out.println("出輸出原始得數組：");
    for (int[] ints : array1) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
    //轉換爲稀疏數組保存
    //獲取有效值得個數
    int sum = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if(array1[i][j] != 0){
                sum++;
            }
        }
    }
    System.out.println("有效值的個數："+sum);

    //2.建立一個稀疏數組
    int[][] sparseArr = new int[sum+1][3];
    sparseArr[0][0] = 11;
    sparseArr[0][1] = 11;
    sparseArr[0][2] = sum;
    //3.遍歷二維數組，將非零的值，存放稀疏數組中
    int count = 0;
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1.length; j++) {
            if(array1[i][j] != 0){
                count ++;
                sparseArr[count][0] = i; //橫座標
                sparseArr[count][1] = j; //縱座標
                sparseArr[count][2] = array1[i][j]; //值
            }
        }
    }
    //4.輸出稀疏數組
    System.out.println("稀疏數組：");
    for (int i = 0; i < sparseArr.length; i++) {
        System.out.println(sparseArr[i][0] + "\t" +
                           sparseArr[i][1] + "\t" +
                           sparseArr[i][2] + "\t"
                          );
    }

    System.out.println("還原：");
    //1.讀取稀疏數組的值
    int[][] array2 = new int[sparseArr[0][0]][sparseArr[0][1]];
    //2.給其中的元素還原
    for (int i = 1; i < sparseArr.length; i++) {
        array2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
    }
    //3.打印
    for (int[] ints : array2) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程