數組_array

時間  2019-11-12
標籤 數組 array 简体版
原文   原文鏈接

數組:存儲同一種數據類型的多個元素的容器。java

定義格式：
　　A:數據類型[] 數組名;
　　B:數據類型 數組名[];

舉例：
　　A:int[] a; 定義一個int類型的數組a變量
　　B:int a[]; 定義一個int類型的a數組變量

注意：效果能夠認爲是同樣的，都是定義一個int數組，可是念法上有些小區別。數組

　　　推薦使用第一種。安全


如何對數組進行初始化呢?
　　A:何謂初始化呢? 就是爲數組開闢內存空間，併爲每一個數組元素賦予值
　　B:有幾種方式呢?
　　a:動態初始化 只指定長度，由系統給出初始化值
　　b:靜態初始化 給出初始化值，由系統決定長度

動態初始化的格式：
　　數據類型[] 數組名 = new 數據類型[數組長度];

舉例：
　　int[] arr = new int[3];

如何獲取數組中的元素呢?
經過:
　　數組名[索引]
　　索引其實就是每一個元素的編號，從0開始，最大索引是數組的長度-1。加密

class ArrayDemo1 {
    public static void main(String[] args) {
        //定義一個數組
        //int[] a;
        //可能還沒有初始化變量a
        //System.out.println(a);
        
        int[] arr = new int[3];
        /*
            左邊：
                int:說明數組中的元素的數據類型是int類型
                []:說明這是一個數組
                arr:是數組的名稱
                
            右邊：
                new:爲數組分配內存空間。
                int:說明數組中的元素的數據類型是int類型
                []:說明這是一個數組
                3:數組長度，其實也就是數組中元素的個數
        */
        
        System.out.println(arr); //[I@1db9742 地址值。
        //我要地址值沒有意義啊，我就要數據值，怎麼辦呢?
        //其實數組中的每一個元素都是有編號的，而且是從0開始。最大編號是數組的長度-1。
        //用數組名和編號的配合就能夠獲取數組中的指定編號的元素。這個編號的專業叫法：索引
        //經過數組名訪問數據的格式是：數組名[索引];
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

 

數組的靜態初始化：
　　格式：數據類型[] 數組名 = new 數據類型[]{元素1,元素2,…};
　　簡化格式：
　　　　數據類型[] 數組名 = {元素1,元素2,…};

　　舉例：
　　　　int[] arr = new int[]{1,2,3};

　　簡化後：
　　　　int[] arr = {1,2,3};

注意事項：
　　不要同時動態和靜態進行。
　　以下格式：
　　　　int[] arr = new int[3]{1,2,3}; //錯誤spa

class ArrayDemo2 {
    public static void main(String[] args) {
        //定義數組
        int[] arr = {1,2,3};
        
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

 

數組操做的兩個常見小問題：
　　ArrayIndexOutOfBoundsException:數組索引越界異常
　　緣由：你訪問了不存在的索引。

　　NullPointerException:空指針異常
　　緣由：數組已經不在指向堆內存了。而你還用數組名去訪問元素。指針

class ArrayDemo3 {
    public static void main(String[] args) {
        //定義數組
        int[] arr = {1,2,3};
        
        //System.out.println(arr[3]);
    
        //引用類型的常量：空常量 null
        arr = null;
        System.out.println(arr[0]);
    }
}

 

數組遍歷：就是依次輸出數組中的每個元素。code

注意：數組提供了一個屬性length，用於獲取數組的長度。
格式：數組名.length對象

class ArrayDemo4 {
    public static void main(String[] args) {
        //定義數組
        int[] arr = {1,2,3,4,5};
        
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
        System.out.println("--------------------");

        //調用遍歷方法
        printArray(arr);
　　　　 System.out.println("---------------------");
        printArray2(arr);
    }
    
    /*
        遍歷數組的方法
        
        兩個明確：
            返回值類型：void
            參數列表：int[] arr
    */
    public static void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
    
    //改進版本
    public static void printArray2(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) { //這是最後一個元素
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

 

數組獲取最值方法(獲取數組中的最大值最小值)

分析：
　　A:定義一個數組，並對數組的元素進行靜態初始化。
　　B:從數組中任意的找一個元素做爲參照物(通常取第一個),默認它就是最大值。
　　C:而後遍歷其餘的元素，依次獲取和參照物進行比較，若是大就留下來，若是小，就離開。
　　D:最後參照物裏面保存的就是最大值。blog

class ArrayDemo5 {
    public static void main(String[] args) {
        //定義一個數組
        int[] arr = {10,50,80,123,115,198};
        
        //請獲取數組中的最大值
        /*
        //從數組中任意的找一個元素做爲參照物
        int max = arr[0];
        //而後遍歷其餘的元素
        for(int x=1; x<arr.length; x++) {
            //依次獲取和參照物進行比較，若是大就留下來，若是小，就離開。
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        //最後參照物裏面保存的就是最大值。
        System.out.println("max:"+max);
        */
    
        //把這個代碼用方法改進
        //調用方法
        int max = getMax(arr);
        System.out.println("max:"+max);
            
        //請獲取數組中的最小值
        int min = getMin(arr);
        System.out.println("min:"+min);
    }
    
    /*
        需求：獲取數組中的最大值
        兩個明確：
            返回值類型：int
            參數列表：int[] arr
    */
    public static int getMax(int[] arr) {
        //從數組中任意的找一個元素做爲參照物
        int max = arr[0];
        //而後遍歷其餘的元素
        for(int x=1; x<arr.length; x++) {
            //依次獲取和參照物進行比較，若是大就留下來，若是小，就離開。
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        //最後參照物裏面保存的就是最大值。
        return max;
    }
    
    public static int getMin(int[] arr) {
        //從數組中任意的找一個元素做爲參照物
        int min = arr[0];
        //而後遍歷其餘的元素
        for(int x=1; x<arr.length; x++) {
            //依次獲取和參照物進行比較，若是小就留下來，若是大，就離開。
            if(arr[x] < min) {
                min = arr[x];
            }
        }
        //最後參照物裏面保存的就是最小值。
        return min;
    }
}

 

數組元素逆序方法 (把元素對調)索引

分析：
　　A:定義一個數組，並進行靜態初始化。
　　B:思路
　　　　把0索引和arr.length-1的數據交換
　　　　把1索引和arr.length-2的數據交換
　　　　...
　　　　只要作到arr.length/2的時候便可。

class ArrayDemo6 {
    public static void main(String[] args) {
        //定義一個數組，並進行靜態初始化。
        int[] arr = {89,10,32,56,45};
        
        //逆序前
        System.out.println("逆序前：");
        printArray(arr);
        
        //逆序後
        System.out.println("逆序後：");
        //reverse(arr);//方法1
        reverse2(arr);//方法2
        printArray(arr);//遍歷方法
    }
    
    /*
        需求：數組逆序
        兩個明確：
            返回值類型：void (不必返回逆序後的數組，由於這兩個數組實際上是同一個數組)
            參數列表：int[] arr
    */
    public static void reverse(int[] arr) {
        /*
        //第一次交換
        int temp = arr[0];
        arr[0] = arr[arr.length-1-0];
        arr[arr.length-1-0] = temp;
        
        //第二次交換
        int temp = arr[1];
        arr[1] = arr[arr.length-1-1];
        arr[arr.length-1-1] = temp;
        
        //第三次交換
        int temp = arr[2];
        arr[2] = arr[arr.length-1-2];
        arr[arr.length-1-2] = temp;
        */
        //用循環改進
        for(int x=0; x<arr.length/2; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length-1-x];
            arr[arr.length-1-x] = temp;
        }
    }
    
    public static void reverse2(int[] arr) {
        for(int start=0,end=arr.length-1; start<=end; start++,end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }
    
    //遍歷數組
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) { //這是最後一個元素
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

 

數組查表法(根據鍵盤錄入索引,查找對應日期)
舉例：String[] strArray = {"星期一","星期二",...};

import java.util.Scanner;

class ArrayDemo7 {
    public static void main(String[] args) {
        //定義一個字符串數組
        String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
        
        //建立鍵盤錄入對象
        Scanner sc = new Scanner(System.in);
        
        System.out.println("請輸入一個數據(0-6)：");
        int index = sc.nextInt();
        
        System.out.println("你要查找的日期是："+strArray[index]);
    }
}

 

數組元素查找(查找指定元素第一次在數組中出現的索引)

分析：
　　A:定義一個數組，並靜態初始化。
　　B:寫一個功能實現
　　遍歷數組，依次獲取數組中的每個元素，和已知的數據進行比較
　　若是相等，就返回當前的索引值。

class ArrayDemo8 {
    public static void main(String[] args) {
        //定義一個數組，並靜態初始化
        int[] arr = {200,250,38,888,444};
        
        //需求：我要查找250在這個數組中第一次出現的索引
        int index = getIndex(arr,250);
        System.out.println("250在數組中第一次出現的索引是："+index);
        
        int index2 = getIndex2(arr,250);
        System.out.println("250在數組中第一次出現的索引是："+index2);
        
        int index3 = getIndex2(arr,2500);
        System.out.println("2500在數組中第一次出現的索引是："+index3);
    }
    
    /*
        需求：查找指定數據在數組中第一次出現的索引
        兩個明確：
            返回值類型：int
            參數列表：int[] arr,int value
    */
    public static int getIndex(int[] arr,int value) {
        //遍歷數組，依次獲取數組中的每個元素，和已知的數據進行比較
        for(int x=0; x<arr.length; x++) {
            if(arr[x] == value) {
                //若是相等，就返回當前的索引值。
                return x;
            }
        }
        
        //目前的代碼有一個小問題
        //就是假如我要查找的數據在數組中不存在，那就找不到，找不到，你就對應的返回嗎?
        //因此報錯。
        
        //只要是判斷，就多是false，因此你們要細心。
        
        
        //若是找不到數據，咱們通常返回一個負數便可，並且是返回-1
        return -1;
    }
    
    public static int getIndex2(int[] arr,int value) {
        //定義一個索引
        int index = -1;
        
        //有就修改索引值
        for(int x=0; x<arr.length; x++) {
            if(arr[x] == value) {
                index = x;
                break;
            }
        }
        
        //返回index
        return index;
    }
}

 

數組加密應用

運用知識點：

 　　　　變量　　　　

　　　　數據類型

　　　　運算符
　　　　鍵盤錄入
　　　　語句
　　　　方法
　　　　數組

需求：

　　某個公司採用公用電話傳遞數據信息，數據是小於8位的整數，爲了確保安全，
　　在傳遞過程當中須要加密，加密規則以下：
　　首先將數據倒序，而後將每位數字都加上5，再用和除以10的餘數代替該數字，
　　最後將第一位和最後一位數字交換。 請任意給定一個小於8位的整數，
　　而後，把加密後的結果在控制檯打印出來。

需求解析：
　　A:數據是小於8位的整數
　　　　定義一個int類型的數據
　　　　int number = 123456;
　　B:加密規則
　　　　a:首先將數據倒序
　　　　　　結果 654321
　　　　b:而後將每位數字都加上5，再用和除以10的餘數代替該數字
　　　　　　結果 109876
　　　　c:最後將第一位和最後一位數字交換
　　　　　　結果 609871
　　　　C:把加密後的結果輸出在控制檯
　　　　D:把以上步驟作成通用的模型

經過簡單的分析，咱們知道若是咱們有辦法把這個數據變成數組就行了。
但不是直接寫成這個樣子的：
　　int[] arr = {1,2,3,4,5,6};

如何把數據轉成數組呢?
　　A:定義一個數據
　　　　int number = 123456;
　　B:定義一個數組,這個時候問題就來了，數組的長度是多少呢?
　　　　int[] arr = new int[8]; //不可能超過8
　　在賦值的時候，我用一個變量記錄索引的變化。
　　定義一個索引值是0
　　　　int index = 0;
　　C:獲取每個數據
　　　　int ge = number%10
　　　　int shi = number/10%10
　　　　int bai = number/10/10%10

　　　　arr[index] = ge;
　　　　index++;
　　　　arr[index] = shi;
　　　　index++;
　　　　arr[index] = bai;
　　　　...

//如下是思路解析
class JiaMiDemo1 {
    public static void main(String[] args) {
        //定義一個數據
        int number = 123456;
        
        //定義一個數組
        int[] arr = new int[8];
        
        //把數據中每一位上的數據獲取到後存儲到數組中
        /*
        int index = 0;
        arr[index] = number%10; //arr[0]=6;
        index++;
        arr[index] = number/10%10; //arr[1]=5;
        index++;
        arr[index] = mumber/10/10%10; //arr[2]=4;
        */
        
        //經過觀察這個代碼，咱們發現應該是能夠經過循環改進的
        int index = 0;
        
        //循環過程
        while(number > 0) { //(1start)number=123456,(5)number=12345,(9)number=1234,(13)number=123,(17)number=12,(21)number=1,(25end)number=0
            arr[index] = number%10; //(2)arr[0]=6,(6)arr[1]=5,(10)arr[2]=4,(14)arr[3]=3,(18)arr[4]=2,(22)arr[5]=1
            index++;//(3)index=1,(7)index=2,(11)index=3,(15)index=4,(19)index=5,(23)index=6
            number/=10;//(4)number=12345,(8)number=1234,(12)number=123,(16)number=12,(20)number=1,(24)number=0
        }
        
        //而後將每位數字都加上5，再用和除以10的餘數代替該數字
        for(int x=0; x<index; x++) {
            arr[x] += 5;
            arr[x] %= 10;
        }
        
        //最後將第一位和最後一位數字交換
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;
        
        //輸出數據
        for(int x=0; x<index; x++) {
            System.out.print(arr[x]);
        }
        System.out.println();
    }
}

 

把以上代碼改爲方法：
　　A:把數據改進爲鍵盤錄入
　　B:把代碼改進爲方法實現

import java.util.Scanner;

class JiaMiDemo2 {
    public static void main(String[] args) {
        //建立鍵盤錄入對象
        Scanner sc = new Scanner(System.in);
        
        //請輸入一個數據
        System.out.println("請輸入一個數據(小於8位)：");
        int number = sc.nextInt();
        
        //寫功能實現把number進行加密
        //調用
        String result = jiaMi(number);
        System.out.println("加密後的結果是："+result);
    }
    
    /*
        需求：寫一個功能，把數據number實現加密。
        兩個明確：
            返回值類型：String 作一個字符串的拼接。
            參數列表：int number
    */
    public static String jiaMi(int number) {
        //定義數組
        int[] arr = new int[8];
        
        //定義索引
        int index = 0;
        
        //把number中的數據想辦法放到數組中
        while(number > 0) {
            arr[index] = number%10;
            index++;
            number /= 10;
        }
        
        //把每一個數據加5，而後對10取得餘數
        for(int x=0; x<index; x++) {
            arr[x] += 5;
            arr[x] %= 10;
        }
        
        //把第一位和最後一位交換
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;
        
        //把數組的元素拼接成一個字符串返回
        //定義一個空內容字符串
        String s = "";
        
        for(int x=0; x<index; x++) {
            s += arr[x];
        }
        
        return s;
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程