天天看點

Java中Arrays列印二維數組、Arrays數組的常用操作

Java中Arrays.toString ()列印二維數組及Array數組的常用操作

關鍵詞:java 數組 數組常用操作 空數組 空串 Arrays Arrays.toString () Arrays.deepToString() HashSet

文章目錄

    • Java中Arrays.toString ()列印二維數組及Array數組的常用操作
    • 1.Java建立數組的幾種方式
    • 2.Java中Arrays.toString ()
    • 3. Java中對Array數組的常用操作

1.Java建立數組的幾種方式

以一維數組為例,講解Java建立數組的三種方式。

(1)先聲明再初始化
String []a = new String[length];
a[0]=?......;//再指派
(2)聲明的同時初始化
String []a = new String[]{a,b,...};
(3)不用new直接初始化
String []a = {?,?....}
           

對于二維、三維甚至更高次元的數組,可以看做是元素是數組的數組,第一維可以不寫,其他次元都要寫,數組初始化預設元素為0。

(4)Java 定義長度為 0 的數組 / 空數組

int[] array = new int[0];     // 定義一個長度為 0 的數組 / 空數組
Sring[] arr = new String[0];  // 定義一個長度為 0 的數組 / 空數組
           

長度為 0 的數組 / 空數組 并不是 null

有時數組裡可能隻有一個空字元串 “”,這時數組長度是 1。這種情況也要注意判斷。

if ( arr.length == 1 && arr[ 0 ].equals( "" ) ) {
    System.out.println( "輸入的數組不能隻包含一個空字元串" );
    return;
}
           

2.Java中Arrays.toString ()

已知列印一維數組的API為

System.out.println ( Arrays.toString (arr0))

;,其參數為數組名或數組指針,其支援的資料類型有很多,如:

int[]、char[]、byte[]

等。

import java.util.Arrays;

public class ArrayPrint {
    public static void main(String[] args) {
        //第一種方式:
        int a[][] = {{0,9,8},{1,2,3}};
        System.out.println("列印a的位址"+a);
        int b[][] = {{0,9,8},{1,2,3}};
        System.out.println("嵌套列印b的位址"+ Arrays.toString(b));
        int c[][] = {{0,9,8},{1,2,3}};
        System.out.println("嵌套列印c"+Arrays.deepToString(c));

        //第二種方式;
//        int[][] ints = new int[2][2];
//        ints[i][j] = __; //分别指派

        //第三種方式:第二維的長度可以動态申請
        int[][] arr3 = new int[5][];
        for (int i = 0; i < arr3.length; i++) {
            arr3[i]= new int[i+1];
            for (int j = 0; j < arr3[i].length; j++) {
                arr3[i][j]= i+j;
                System.out.println("arr3[i][j]:"+arr3[i][j]);
            }
            System.out.println("arr3[i][j]:"+Arrays.toString(arr3[i]));
        }
    }
}
           

列印結果:

列印a的位址[[I@b2558153
嵌套列印b的位址[[I@5d1a7b26, [I@fe9889fa]
嵌套列印c[[0, 9, 8], [1, 2, 3]]
arr3[i][j]:0
arr3[i][j]:[0]
arr3[i][j]:1
arr3[i][j]:2
arr3[i][j]:[1, 2]
arr3[i][j]:2
arr3[i][j]:3
arr3[i][j]:4
arr3[i][j]:[2, 3, 4]
arr3[i][j]:3
arr3[i][j]:4
arr3[i][j]:5
arr3[i][j]:6
arr3[i][j]:[3, 4, 5, 6]
arr3[i][j]:4
arr3[i][j]:5
arr3[i][j]:6
arr3[i][j]:7
arr3[i][j]:8
arr3[i][j]:[4, 5, 6, 7, 8]

Process finished with exit code 0



           

[[[email protected], [[email protected]]

這種輸出結果是因為:

因為b是一個二維數組。相當于一個長度為2的數組,但是這個數組的元素是數組。

當執行Arrays.toString的時候相當于周遊數組,并且輸出數組的元素,但是這個數組的元素是數組,是以這裡輸出的是數組元素的位址。

3. Java中對Array數組的常用操作

import java.util.*;

public class ArraysPrint {

    public static void main(String[] args) {
        //聲明數組
        // String [] arr;
        int arr[];
        //初始化數組
        int arr2[]=new int[]{9,8,7,6,5,4};
        String[] array1={"馬超","馬雲","關羽","劉備","張飛"};
        String[] array2=new String[]{"黃渤","張藝興","孫紅雷","小豬","牙哥","黃磊"};
        String[] array=new String[5];
        //檢視數組的長度
        System.out.println("length:  "+array1.length);
        System.out.println("length:  "+array2.length);
        System.out.println("length:  "+array.length);

        //輸出數組
        System.out.println(array1);     //結果:[Ljava.lang.String;@32f22097
        System.out.println("arr2:  "+ Arrays.toString(arr2));

        //周遊數組
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }

        //int數組轉成string數組
        int[]  array3={1,2,3,4,5,6,7,8,9,0};
        String arrStrings = Arrays.toString(array3);
        System.out.println("arrStrings:"+arrStrings);

        //從array中建立arraylist
        ArrayList<String> arrayList = new ArrayList<>(Arrays.asList(array1));
        System.out.println("arrayList:"+arrayList);
        System.out.println("arrayList長度:"+arrayList.size());

        //數組轉為清單,檢視數組中是否包含某一個值
        String a="馬超";
        if (Arrays.asList(array1).contains(a)){
            System.out.println("馬超在這裡");
        }

        //将數組轉成set集合
        Set<String> set = new HashSet<String>(Arrays.asList(array2));
        System.out.println("set:"+set);

        //數組轉為list集合
        List<String> list_1 = new ArrayList<String>();
        for (int i = 0; i < array2.length; i++) {
            list_1.add(array2[i]);
        }
        System.out.println("list_1:"+list_1);

        //Arrays.fill() 填充數組
        int[] arr3 = new int[5];
        Arrays.fill(arr3,10);
        System.out.println("arr3:"+arr3);
//        for (int i = 0; i < arr3.length; i++) {
//            System.out.println("arr3[3]"+ arr3[i]);
//        }

        //數組排序
        int[] arr4 = {2,3,4,5,6,8};
        Arrays.sort(arr4);
        System.out.println(Arrays.toString(arr4));
        System.out.println("arr4:"+ arr4);
//        for (int i = 0; i < arr4.length; i++) {
//            System.out.println("arr4[i]" + arr4[i]);
//        }

        //複制數組
        int[] arr6 = {2,3,4,5};
        int[] arr7 = Arrays.copyOf(arr6,10); //指定新數組的長度
        int[] arr8 = Arrays.copyOfRange(arr6,1,3);//隻複制從索引[1]到索引[3]之間的元素(不包括索引[3]的元素)

        System.out.println(Arrays.toString(arr7));
        System.out.println(Arrays.toString(arr8));

        int[] arr9 = {1,2,3,4,5,6,7,8};
        boolean arr10 = Arrays.equals(arr6,arr9);
        System.out.println(arr10);

        //去重複
        //利用set的特性

        int[] arr11 = {1,2,2,6,3,3,4,7,5,5,6,9,6,4,7,8,8,9,5,9};
        Set<Integer> set2 = new HashSet<Integer>();
        for (int i = 0; i < arr11.length; i++) {
            set2.add(arr11[i]);
        }
        System.out.println(set2);

        //重新周遊
        int[] arr12 = new int[set2.size()];
        int j = 0;
        for (Integer integer:set2
             ) {
            arr12[j++] = integer;
        }
        System.out.println(Arrays.toString(arr12));

    }
}


           

輸出結果:

length:  5
length:  6
length:  5
[Ljava.lang.String;@9e77591c
arr2:  [9, 8, 7, 6, 5, 4]
馬超
馬雲
關羽
劉備
張飛
arrStrings:[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
arrayList:[馬超, 馬雲, 關羽, 劉備, 張飛]
arrayList長度:5
馬超在這裡
set:[小豬, 牙哥, 黃渤, 黃磊, 孫紅雷, 張藝興]
list_1:[黃渤, 張藝興, 孫紅雷, 小豬, 牙哥, 黃磊]
arr3:[I@383479e
[2, 3, 4, 5, 6, 8]
arr4:[I@b9f0595f
[2, 3, 4, 5, 0, 0, 0, 0, 0, 0]
[3, 4]
false
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]