Java教程

3_数组(Java学习笔记)

本文主要是介绍3_数组(Java学习笔记),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1. 数组的概述

 * 1.数组的理解:数组(Array),是多个相同类型数据一定顺序排列的集合,并使用一个名字命名,
 * 并通过编号的方式对这些数据进行统一管理。
 * 2.数组相关的概念:
 * >数组名
 * >元素
 * >角标、下标、索引
 * >数组的长度:元素的个数
 * 3.数组的特点:
 * ①数组是序排列的
 * ②数组属于引用数据类型的变量。数组的元素,既可以是基本数据类型,也可以是引用数据类型
 * ③创建数组对象会在内存中开辟一整块连续的空间
 * ④数组的长度一旦确定,就不能修改。
 * 4. 数组的分类:
 *   ① 按照维数:一维数组、二维数组、。。。
 *   ② 按照数组元素的类型:基本数据类型元素的数组、引用数据类型元素的数组

2. 一维数组

package com.atguigu.java;

/*
一维数组的使用
 * ①一维数组的声明和初始化
 * ②如何调用数组的指定位置的元素
 * ③如何获取数组的长度
 * ④如何遍历数组
 * ⑤数组元素的默认初始化值
 * ⑥数组的内存解析
 *
 */

public class ArrayTest {
    public static void main(String[] args) {
        //①一维数组的声明和初始化
        int[] ids;//声明
        //1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001, 1002, 1003, 1004};
        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];

        //②如何调用数组的指定位置的元素:通过角标的方式调用
        names[0] = "王明";
        names[1] = "张学良";
        names[2] = "王皓";
        names[3] = "李名";
        names[4] = "王小二";

        //③如何获取数组的长度
        //属性:length
        System.out.println(names.length);
        System.out.println(ids.length);

        //④如何遍历数组
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }

        //⑤数组元素的默认初始化值
        /*
         * 数组元素是整型:0
         * 数组元素是浮点型:0.0
         * 数组元素是char型:0或'\u0000',而非'0'
         * 数组元素是boolean型:false
         * 数组元素是引用数据类型时:null
         */
        int[] arr = new int[4];
        System.out.println(arr);//[I@15db9742
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        String[] arr1 = new String[5];
        System.out.println(arr1[0]);//null

        //⑥数组的内存解析(要记住在内存中的结构图见下)
    }
}

在这里插入图片描述

3. 二维数组

package com.atguigu.java;

/*
 * 二维数组的使用:
 * 1.理解:
 * 其实就是数组的数组;从数组底层的运行机制来看,其实没多维数组。
 *
 * 2.二维数组的使用:
 * ①一维数组的声明和初始化
 * ②如何调用数组的指定位置的元素
 * ③如何获取数组的长度
 * ④如何遍历数组
 * ⑤数组元素的默认初始化值
 * ⑥数组的内存解析
 */
public class ArrayTest1 {
    public static void main(String[] args) {

        //①一维数组的声明和初始化
        int[] arr = new int[]{1, 2, 3};//一维数组
        //静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //动态初始化
        String[][] arr2 = new String[3][2];
        String[][] arr3 = new String[3][];
        //错误的情况
//		String[][] arr4 = new String[][3];
        //正确的情况
        int arr7[][] = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int[] arr5[] = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int[] arr6[] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};

        //②如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);//2
        System.out.println(arr2[1][1]);//null
//		System.out.println(arr3[1][0]);//报错
        arr3[1] = new String[4];
        System.out.println(arr3[1][0]);//null

        //③如何获取数组的长度
        System.out.println(arr5.length);//3
        System.out.println(arr5[1].length);//2

        //④如何遍历数组
        for (int i = 0; i < arr5.length; i++) {
            for (int j = 0; j < arr5[i].length; j++) {
                System.out.print(arr5[i][j] + "  ");
            }
            System.out.println();
        }

        //⑤数组元素的默认初始化值
        /*
         * 针对于初始化方式一:int[][] arr8 = new int[4][3];
         * 			外层元素的初始化值为:地址值
         * 			内层元素的初始化值为:与一维数组初始化情况相同
         * 针对于初始化方式二:double[][] arr9 = new double[4][];
         * 			外层元素的初始化值为:null
         * 			内层元素的初始化值为:报错
         */
        int[][] arr8 = new int[4][3];
        System.out.println(arr8[0]);//[I@15db9742
        System.out.println(arr8[0][0]);//0
        System.out.println(arr8);//[[I@6d06d69c
        double[][] arr9 = new double[4][];
        System.out.println(arr9[1]);//null 之所以是null,因为数组的元素是引用类型的话,默认值为null,arr9[1]仍然是一个一维数组
//		System.out.println(arr9[1][0]);//报错

        //⑥数组的内存解析(要记住在内存中的结构图)见下
    }
}

在这里插入图片描述

4. 数组的常见算法

package com.atguigu.java;

/*
数组中常见的算法:
1.数组元素的赋值(杨辉角、回形数等)
2.求数值型数组中元素的最大值、最小值、平均数、总和等
3.数组的复制、反转、查找(线性查找、二分法查找)
4.数组元素的排序算法
 */
public class ArrayTest2 {
    public static void main(String[] args) {

        //1.数组元素的赋值(杨辉角、回形数等
        //杨辉角
        //①声明并初始化二维数组
        int[][] yangHui = new int[10][];

        //②给数组的元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i + 1];
            //给首末元素赋值
            yangHui[i][0] = 1;
            yangHui[i][i] = 1;
            //给每行的非首末元素赋值
            if (i > 1) {
                for (int j = 1; j < yangHui[i].length - 1; j++) {
                    yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
                }
            }

        }

        //③遍历二维数组
        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.求数值型数组中元素的最大值、最小值、平均数、总和等
		/*
		 * 定义一个int型的一维数组,包含10个元素,分别赋一些随机整数,
	    然后求出所元素的最大值,最小值,和值,平均值,并输出出来。
	    要求:所随机数都是两位数。
	    [10,99]公式:Math.random()*(99 - 10 + 1) + 10
		 */
        int[] arr = new int[10];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * (99 - 10 + 1) + 10);
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
        System.out.println();
        //最大值
        int maxValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (maxValue < arr[i]) {
                maxValue = arr[i];
            }
        }
        System.out.println("最大值为:" + maxValue);
        //最小值
        int minValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (minValue > arr[i]) {
                minValue = arr[i];
            }
        }
        System.out.println("最小值为:" + minValue);
        //总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和为:" + sum);
        //平均值
        int avgValue = sum / arr.length;
        System.out.println("平均值为:" + avgValue);


        //3.数组的复制、反转、查找(线性查找、二分法查找
        /*
         * 数组的复制
         */
        int[] array1, array2;

        array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
        //赋值array2变量等于array1
        //array2  = array1;//array1和array2地址值相同,都指向了堆空间的唯一的一个数组实体。这是赋值,并非复制
        //数组的复制
        array2 = new int[array1.length];
        for (int i = 0; i < array2.length; i++) {
            array2[i] = array1[i];
        }

        //数组的反转
        //方法一:
        for (int i = 0; i < array1.length / 2; i++) {
            int temp = array1[i];
            array1[i] = array1[array1.length - i - 1];
            array1[array1.length - i - 1] = temp;
        }
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        System.out.println();
        //方法二:
        for (int i = 0, j = array1.length - 1; i < j; i++, j--) {
            int temp = array1[i];
            array1[i] = array1[j];
            array1[j] = temp;
        }

        //数组的查找(线性查找、二分法查找
        //线性查找:
        String[] arr1 = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
        String desc = "BB";
        boolean isFlag = true;
        for (int i = 0; i < arr.length; i++) {

            if (desc.equals(arr1[i])) {
                System.out.println("找到了指定的元素,位置为:" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾,没找到哦!");
        }
        //二分法查找:前提必须是序的
        int[] arr2 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int desc1 = -34;
        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean isFlag1 = true;
        while (head <= end) {
            int middle = (head + end) / 2;
            if (desc1 == arr2[middle]) {
                System.out.println("找到了指定的元素,位置为:" + middle);
                isFlag1 = false;
                break;
            } else if (arr2[middle] > desc1) {
                end = middle - 1;
            } else {
                head = middle + 1;
            }
        }
        if (isFlag1) {
            System.out.println("很遗憾,没找到哦!");
        }

        //4.数组元素的排序算法
		/*排序算法分类:内部排序和外部排序。
        十大排序算法:
         择排序
         		直接择排序、堆排序
         交换排序
         		冒泡排序、快速排序
         插入排序
         		直接插入排序、折半插入排序、Shell排序
         归并排序
         桶式排序
         基数排序

		 */
        //冒泡排序
        //思路:一次冒泡排序出来最大值,二次冒泡排序出来第二大值...
        int[] arr3 = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};
        for (int i = 0; i <= arr3.length - 1; i++) {
            for (int j = 0; j < arr3.length - i - 1; j++) {
                if (arr3[j] > arr3[j + 1]) {
                    int temp = arr3[j];
                    arr3[j] = arr3[j + 1];
                    arr3[j + 1] = temp;
                }
            }
        }
        //快速排序
        //思路:low、hight指针,例如arr3,一趟排序结束后,左边的都小于43,右边的都大于43,然后左右分而治之
        //。。。(后续再补充)
    }
}

4.1 数组的赋值与复制:
int[] array1,array2;
array1 = new int[]{1,2,3,4};
4.1.1 赋值:
array2 = array1;
如何理解:将array1保存的数组的地址值赋给了array2,使得array1和array2共同指向堆空间中的同一个数组实体。
在这里插入图片描述
4.1.2 复制:
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
在这里插入图片描述
如何理解:我们通过new的方式,给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

4.2 数组的排序算法
在这里插入图片描述
理解:
1)衡量排序算法的优劣:
时间复杂度、空间复杂度、稳定性
2)排序的分类:内部排序 与 外部排序(需要借助于磁盘)
3)不同排序算法的时间复杂度
在这里插入图片描述

5. Arrays工具类的使用

package com.atguigu.java;

import java.util.Arrays;

/*
 * java.util.Arrays:操作数组的工具类,里面定义了很多操作数组的方法
 *
 */
public class ArraysTest {
    public static void main(String[] args) {
        //1.boolean   equals(int[] a,int[] b):判断两个数组是否相等
        int[] arr1 = new int[]{1,2,3,4};
        int[] arr2 = new int[]{1,3,2,4};
        boolean isEqueals = Arrays.equals(arr1, arr2);
        System.out.println(isEqueals);

        //2.String  toString(int[] a):输出数组信息
        System.out.println(Arrays.toString(arr1));

        //3.void  fill(int[] a,int val):将指定值填充到数组中
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));

        //4.void sort(int[] a):对数组进行排序
         Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr1));

        //5.int binarySearch(int[] a,int key):查找
         int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int index = Arrays.binarySearch(arr3, 210);
        if(index >= 0){
   		System.out.println(index);
		}else{
    			System.out.println("未找到");
		}
    }
}

6. 数组常见的异常

package com.atguigu.java;
/*
 * 数组中的常见异常:
 * 1.数组角标越界ArrayIndexOutOfBoundsExcetion
 *
 * 2.空指针异常NullPointerException
 *
 */
public class ArrayException {
    public static void main(String[] args) {
        //1.角标越界
        int[] arr = new int[]{1,2,3,4,5};
        System.out.println(arr[-2]);

        //2.空指针异常
        //情况一:
        int[] arr1 = new int[]{1,2,3};
        arr1 = null;
        System.out.println(arr1[0]);
        //情况二:
        int[][] arr2 = new int[4][];
        System.out.println(arr2[0][0]);
        //情况:
        String[] arr3 = new String[]{"AA","BB","CC"};
        arr3[0] = null;
        System.out.println(arr3[0].toString());
    }
}
小知识:一旦程序出现异常,未处理时,就终止执行。
这篇关于3_数组(Java学习笔记)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!