首页 > > 程序设计 > Java技术 >

7.数组

2020-03-28 16:03:05来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

7.数组

一、数组的概述

1.定义

　　多个相同数据类型的数据按照一定的顺序排列的集合，使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.特点

　　①数组是有序排列的；

　　②数组本身是引用数据类型，数组中的元素既可以是基本数据类型，也可以是引用数据类型；

　　③创建数组会在内存中开辟一整块连续的空间，而数组通过数组名引用的是这块连续空间的首地址；

　　④数组一旦初始化完成，其长度就确定了；数组的长度一旦确定，就不能修改；

　　⑤通过索引来访问数组中的元素，速度很快

3.分类

按照维数：一维数组、二维数组、多维数组

按照数组中元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

二、一维数组

1.一维数组的声明和初始化

public class test {
    public static void main(String[] args) {
        //数组的声明
        int[] arr1;
        String arr2[];
        //数组的静态初始化
        arr1 = new int[]{1, 2, 3};
        //数组的动态初始化
        arr2 = new String[4];
        //声明+初始化
        int[] arr3 = new int[3];
        //类型推断
        String[] arr4 = {"str1", "str2", "str3"};
    }
}

2.访问一维数组中的元素

public class test {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //访问数组中的元素：索引访问
        System.out.println(arr[2]);//3
    }
}

3.一维数组的长度

public class test {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //数组的长度：调用数组对象的length属性
        System.out.println(arr.length);//5
    }
}

4.一维数组的遍历

public class test {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //数组的遍历：循环
        for (int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

5.一维数组的默认初始化值

public class test {
    public static void main(String[] args) {
        //一维数组的默认初始化值
        //整形
        byte[] arr1 = new byte[3];
        short[] arr2 = new short[3];
        int[] arr3 = new int[3];
        long[] arr4 = new long[3];
        System.out.println(arr1[1]);//0
        System.out.println(arr2[1]);//0
        System.out.println(arr3[1]);//0
        System.out.println(arr4[1]);//0

        //浮点型
        float[] arr5 = new float[3];
        double[] arr6 = new double[3];
        System.out.println(arr5[2]);//0.0
        System.out.println(arr6[2]);//0.0

        //字符型
        char[] arr7 = new char[3];
        if (arr7[0] == '\u0000'){
            System.out.println("hello！");//hello!
        }

        //boolean型
        boolean[] arr8 = new boolean[3];
        System.out.println(arr8[1]);//false

        //引用数据类型
        String[] arr9 = new String[3];
        System.out.println(arr9[0]);//null
    }
}

6.一维数组的内存解析

 

 三、二维数组

1.二维数组的声明和初始化

public class test {
    public static void main(String[] args) {
        //静态初始化
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        //动态初始化1
        int[][] arr2 = new int[3][2];
        //动态初始化2
        int[][] arr3 = new int[3][];
        //类型推断
        int[][] arr4 = {{1, 2}, {1, 2, 5}};
    }
}

2.访问二维数组中的元素

public class test {
    public static void main(String[] args) {
        //访问二维数组的元素
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        int[][] arr2 = new int[3][2];
        int[][] arr3 = new int[3][];
        System.out.println(arr1[0][1]);//李四
        System.out.println(arr2[2][1]);//0
        System.out.println(arr3[1]);//null
//        System.out.println(arr3[0][1]);//报异常：NullPointerException
    }
}

3.二维数组的长度

public class test {
    public static void main(String[] args) {
        //二维数组的长度
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        System.out.println(arr1.length);//2
        System.out.println(arr1[1].length);//3
    }
}

4.遍历二维数组

public class test {
    public static void main(String[] args) {
        //二维数组的遍历
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.println(arr1[i][j]);
            }
        }
    }
}

5.二维数组的默认初始化值

public class test {
    public static void main(String[] args) {
        //二维数组的默认初始化值
        //方式一：
        int[][] arr1 = new int[3][2];
        /*
        外层元素：地址值
        内层元素：跟一维数组的初始化情况相同
         */
        System.out.println(arr1[0]);//[I@4e50df2e
        System.out.println(arr1[0][1]);//0

        //方式二：
        int[][] arr2 = new int[3][];
        /*
        外层元素：null
        内层元素：不存在，无从谈起；强行调用，报错
         */
        System.out.println(arr2[1]);//null
//        System.out.println(arr2[1][0]);//NullPointerException
    }
}

6.二维数组的内存解析

 

 四、数组中的常见算法

1.数组元素的赋值

打印10行的“杨辉三角”：

public class test {
    public static void main(String[] args) {
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];
        //2.给数组的元素赋值
        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];
            //2.1 给首末元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //2.2 给每行的非首末元素赋值
            for(int j = 1;j < yangHui[i].length - 1;j++){
                yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
            }
        }
        //3.遍历二维数组
        for(int i = 0;i < yangHui.length;i++){
            for(int j = 0;j < yangHui[i].length;j++){
                System.out.print(yangHui[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

2.数值型的数组求最大值、最小值、总和、平均值

public class test {
    public static void main(String[] args) {
        //定义一个整形数组，数组中有10个元素，且每一个元素都是随机的两位数
        int[] arr = new int[10];
        int num;
        for (int i = 0; i < arr.length; i++) {
            num = (int)(Math.random() * (99 - 10 + 1) + 10);
            arr[i] = num;
        }
        //遍历数组中的元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //求最大值
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);//最大值为：93

        //求最小值
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最小值为：" + min);//最小值为：10

        //求总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和为：" + sum);//总和为：597

        //求平均值
        int avg = sum / arr.length;
        System.out.println("平均值为：" + avg);//平均值为：49
    }
}

3.数组的赋值和复制

数组的赋值：

　　将数组1的地址值赋给数组2，使得数组1和数组2同时指向了堆空间中的同一个对象实体。

数组的复制：

　　完全copy一份，相当于堆空间中创建一个新的对象实体。

public class test {
    public static void main(String[] args) {
        //数组的复制
        int[] arr1 = new int[]{1, 2, 5, 6};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
            System.out.println(arr2[i]);
        }
    }
}

 

 4.数组的反转

public class test {
    public static void main(String[] args) {
        //数组的反转
        int[] arr = new int[]{2, 5, 8, 3};
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5.二分法查找

public class test {
    public static void main(String[] args) {
        //二分法查找
        int[] arr = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int dest = 79;
        int start = 0;
        int end = arr.length - 1;
        boolean isFlag = true;
        while (start <= end){
            int middle = (start + end) / 2;
            if (dest == arr[middle]){
                System.out.println("找到了数组中的元素, 其索引为：" + middle);
                isFlag = false;
                break;
            }else if (dest < arr[middle]){
                end = middle - 1;
            }else {
                start = middle + 1;
            }
        }
        if (isFlag){
            System.out.println("很遗憾，没有找到指定元素");
        }
    }
}

6.十大排序算符

 

 手写冒泡排序：

public class test {
    public static void main(String[] args) {
        //手写冒泡排序
        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");//-98    -21    0    32    32    33    43    64    76    99
        }
    }
}

五、Arrays工具类的使用

1.理解：

①属于java.util包下的工具类；

②里面定义了许多操作数组的方法；

 

 2.使用

public class test {
    public static void main(String[] args) {
        //Arrays工具类的使用
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 2, 3, 4};

        //equals:判断两个数组是否相等
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);//true

        //toString:输出数组信息
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]

        //fill:将指定值填充到数组中
        Arrays.fill(arr2, 10);
        System.out.println(Arrays.toString(arr2));//[10, 10, 10, 10]

        //sort:对数组进行排序
        int[] arr = new int[]{2, 5, 8, 1, 28, 23};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[1, 2, 5, 8, 23, 28]

        //binarySearch:查找数组中的元素，并返回索引
        int dest = 28;
        int index = Arrays.binarySearch(arr, dest);
        if (index >= 0) {
            System.out.println(index);//5
        }else {
            System.out.println("未找到");
        }
    }
}

六、数组中的常见异常

1.数组角标越界：ArrayIndexOutOfBoundsException

public class test {
    public static void main(String[] args) {
        int[] arr = new int[3];
//        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
    }
}

2.空指针异常：NullPointerException

public class test {
    public static void main(String[] args) {
        int[] arr = new int[3];
//        //情况一：
//        arr = null;
//        System.out.println(arr[0]);//NullPointerException

        //情况二：
        int[][] arr1 = new int[3][];
        System.out.println(arr1[1][0]);//NullPointerException
    }
}

 

 

 

作者：Java之美

日期：2020-03-28


原文链接:https://www.cnblogs.com/897463196-a/p/12587695.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Spring03——有关于 Spring AOP 的总结

下一篇：12.面向对象-----类的成员之构造器（constructor）

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签