投稿
  1. 簡單一點首頁
  2. 投稿

java自動類型轉換例子「一維數組的定義方式說明」

投稿專員 • • 投稿

1.一維數組

概念：一組數據的容器（數組可以存放多個數據）

​ 注意：

​ 1.數組是引用數據類型

​ 2.數組中的數據又叫做元素

​ 3.每個元素都有編號叫做下標/索引

​ 4.下標從0開始

​ 5.數組初始化後，會在內存中開闢一連串連續的空間

​ 6.數組一旦初始化後長度不可以改變（數組沒有擴容和刪除）

​ 7.數組的操作：添加、修改、查詢​

​ 數組的聲明：數據類型[] 數組名;​

數組的初始化：

​ 靜態初始化：數據由程序員指定，長度由系統分配

public static void main(String[] args){
        //靜態初始化1
        //String[] names = new String[]{"小明","小紅","鐵蛋","二狗","大傻子"};
        //靜態初始化2
        //String[] names;
        //names = new String[]{"小明","小紅","鐵蛋","二狗","大傻子"};
        //靜態初始化3
        String[] names = {"小明","小紅","鐵蛋","二狗","大傻子"};
        //設置指定下標上的元素
        names[3] = "大狗";
        //獲取指定下標上的元素
        String n = names[3];
        System.out.println("獲取指定下標上的元素：" + n);//林成
        //ArrayIndexOutOfBoundsException - 數組下標越界異常
        //System.out.println(names[100]);
        //獲取元素個數
        int len = names.length;
        System.out.println("獲取元素個數：" + len);//5
        System.out.println("-----------");
        //遍歷 - for循環
        for(int i = 0;i<names.length;i++){
            System.out.println(names[i]);
        }
        System.out.println("-----------");
        //遍歷 - foreach(增強for循環)
        for(String str:names){//遍曆數組，依次把元素賦值給str
            System.out.println(str);
        }
        /**
            遍歷時要使用到下標，就用for循環遍歷
            遍歷時要不使用到下標，就用foreach遍歷  
        */
    }

動態初始化：長度由程序員指定，數據由系統分配(默認值)

​ 整數類型：0

​ 浮點類型：0.0

​ 字符類型：’ ‘

​ 布爾類型：false

​ 引用類型：null(空)

public static void main(String[] args){
        //動態初始化1
        String[] names = new String[5];//5->5個長度
        //設置指定下標上的元素
        names[0] = "小明";
        names[1] = "鐵蛋";
        names[2] = "二狗";
        //獲取指定下標上的元素
        String n = names[2];
        System.out.println("獲取指定下標上的元素：" + n);//二狗
        //ArrayIndexOutOfBoundsException - 數組下標越界異常
        //System.out.println(names[100]);
        //獲取元素個數
        int len = names.length;
        System.out.println("獲取元素個數：" + len);//5
        System.out.println("-----------");
        //遍歷 - for循環
        for(int i = 0;i<names.length;i++){
            System.out.println(names[i]);
        }
        System.out.println("-----------");
        //遍歷 - foreach(增強for循環)
        for(String str:names){//遍曆數組，依次把元素賦值給str
            System.out.println(str);
        }
        /**
            遍歷時要使用到下標，就用for循環遍歷
            遍歷時要不使用到下標，就用foreach遍歷  
        */

2.數組的擴容

前面講到數組一旦初始化後長度不可以改變（數組沒有擴容和刪除），那我們如何在原來的數組上添加數據。數組沒有擴容，但是可以將數組中的數據從小的容器放到大的容器里。

public static void main(String[] args){
        //源數組
        String[] names = {"小明","小紅","鐵蛋","二狗"};
        //新數組
        //(names.length>>1在此次可以理解為(names.length/2)
        int capacity = names.length + (names.length>>1);//新容量：是源數組長度的1.5倍
        String[] newNames = new String[capacity];
        //把源數組所有的數據遷移到新數組中
        for(int i = 0;i<names.length;i++){
            newNames[i] = names[i];
        }
        //將新數組的地址賦值給源數組
        names = newNames;
        //遍歷源數組
        for(String name:names){
            System.out.println(name);
        }
    }

小明小紅鐵蛋二狗 null null

Java簡單實現數組的增刪改查方法

3.數組的複製

1.直接將數組賦值給新數組

String[] names = {「小明」,「小紅」,「鐵蛋」,「二狗」};

String[] newNames = names;

這樣做會有一個小缺陷，修改源數組，新數組的數據也隨之改變.這是因為賦值號所給到的不是原數組的數據，而是原數組的地址。

public class Test111 {
    public static void main(String[] args){
        //源數組
        String[] names = {"小明","小紅","鐵蛋","二狗"};
        //新數組
        String[] newNames = names;
        //遍歷新數組
        System.out.print("修改原數據前：");
        for(String name : newNames){
            System.out.print(name+"t");
        }
        System.out.println();
        //修改源數組
        names[0] = "大傻子";
        //遍歷新數組
        System.out.print("修改原數據後：");
        for(String name : newNames){
            System.out.print(name+"t");
        }
        System.out.println();
    }
}

修改原數據前：小明 小紅 鐵蛋 二狗 修改原數據後：大傻子 小紅 鐵蛋 二狗

2.創建一個新的數組，再將原數組的數據逐個賦值

public static void main(String[] args){
        //源數組
        String[] names = {"小明","小紅","鐵蛋","二狗"};
        //新數組
        String[] newNames = new String[names.length];
        //將源數組中數據依次賦值給新數組
        for(int i = 0;i<names.length;i++){
            newNames[i] = names[i];
        }
        //修改源數組
        names[0] = "大聰明";
        //遍歷新數組
        for(String name : newNames){
            System.out.println(name);
        }
    }

小明 小紅 鐵蛋 二狗

4.數組的刪除

1.新建一個小容量的數組，然後將不刪除的數據導入。排除了需要刪除的數據

缺點：數組原本是存放數據的，刪除元素後，數組長度變短

public static void main(String[] args){
        //源數組
        String[] names = {"小明","小紅","鐵蛋","二狗"};
        //新數組
        String[] newNames = new String[names.length-1];
        //將源數組的數據遷移到新數組中，要刪除的元素(深田詠美)除外
        int index = 0;//新數組的下標
        for(String name:names){
            if(!name.equals("小紅")){
                newNames[index] = name;
                index++;
            }
        }
        //將新數組的地址賦值給源數組
        names = newNames;
        //遍歷源數組
        for(String name:names){
            System.out.println(name);
        }
    }

小明 鐵蛋 二狗

2.將需要刪除的數據後面的數據整體向前移，覆蓋掉刪除的數據，這樣就可以留出空間了

public static void main(String[] args){
        //源數組
        String[] names = {"小明","小紅","鐵蛋","二狗"};
        //數據的遷移
        for(int i = 1;i<names.length-1;i++){
            names[i] = names[i+1];
        }
        names[names.length-1] = null;
        //遍歷源數組
        for(String name:names){
            System.out.println(name);
        }
    }

小明鐵蛋二狗 null

5.數組的排序

數組的排序方法有很多種，今天就分享比較簡單的冒泡排序

​ 口訣：

​ N個數字來排序

​ 兩兩相比小靠前

​ 外層循環N-1

​ 內層循環N-1-i

public static void main(String[] args){
        int[] is = {39,77,27,20,45,62};
        for(int i = 0;i<is.length-1;i++){
            for(int j = 0;j<is.length-1-i;j++){
                if(is[j] > is[j+1]){
                    int temp = is[j];
                    is[j] = is[j+1];
                    is[j+1] = temp;
                }
            }
        }
        for(int num : is){
            System.out.println(num);
        }
    }

這裡分享一個Arrays工具類，導入Arrays包後可直接調用裏面的排序方法sort

public static void main(String[] args){
    import java.util.Arrays;
    int[] a={1,5,8,6};
    for(int num : a){
        System.out.println(num);
    }
}

1 5 6 8

6.數組的查找

1.順序查找：從頭到尾遍歷(簡單除暴，效率相對較低)

for(int i = 0;i<is.length;i++){
            if(is[i] == num){
                System.out.println("查找到了");
            }
        }

2.二分法查找

​ 前提：先排序(效率高於順序查找)

​ 排序時就可以使用Arrays.sort(is);

二分法查找適用於數據量較大時，但是數據需要先排好順序。

public static void main(String[] args){
        int[] is = {39,77,27,20,45,62};
        int num = 77;
        //排序
        Arrays.sort(is);
        int start = 0;
        int end = is.length-1;
        while(start <= end){
            int mid = (start+end)/2;
            if(num >is[mid]){
                start = mid+1;
            }else if(num < is[mid]){
                end = mid-1;
            }else{
                System.out.println("查找到了");
                break;
            }
        }
    }

原創文章，作者：投稿專員，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/273689.html

贊 (0)
打賞 微信掃一掃 微信掃一掃 支付寶掃一掃 支付寶掃一掃
投稿專員的頭像投稿專員
0 0
上一篇 2024-12-17 14:07
下一篇 2024-12-17 14:07

相關推薦

發表回復

登錄後才能評論