Java基础学习笔记：第三章数组

最新推荐文章于 2021-03-18 14:08:19 发布

猛肝自然强

最新推荐文章于 2021-03-18 14:08:19 发布

阅读量222

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/LastYHM/article/details/107077554

版权

java基础专栏收录该内容

20 篇文章 1 订阅

订阅专栏

知识点1：数组的理解

 * 1. 数组，可以看做是多个相同数据类型类型的变量按照一定顺序依次紧密排列起来的集合。
 *
 * 2.数组的相关概念：
 * 数组名
 * 数组元素
 * 数组的长度
 * 数组的角标、下标、下角标、索引、index
 *
 * 3. 回顾：变量按照数据类型来分：基本数据类型、引用数据类型（数组、类、接口）
 *
 *  >数组，属于引用数据类型；数组的元素，既可以是基本数据类型，也可以是引用数据类型。
 *  >数组，一旦初始化完成，其长度就是确定的。且长度不可变

在这里插入图片描述

知识点2：一维数组的使用

一维数组的声明和初始化

 4.1 一维数组的声明和初始化
        //变量的定义： 数据类型  变量名 = 变量值
        int num;//声明
        num = 10;//初始化
        String info = "尚硅谷";

        //数组的声明和初始化
        //静态初始化：数组变量的赋值与数组元素的赋值同时进行
        int[] scores = new int[]{56,54,87,98,77,68};
        int ages[] = {56,54,87,98,77,68};//使用了类型推断
        String[] names = {"马龙飞","石磊","陈自强"};

        //动态初始化：数组变量的赋值与数组元素的赋值分开进行
        String[] foods = new String[5];

如何访问数组的元素

//4.2 如何访问数组的元素:通过角标的方式
        //角标是从0开始的，到数组的长度-1为止
        foods[0] = "宫保鸡丁";//给第一个元素赋值
        foods[4] = "水煮鱼";//给最后一个元素赋值

        System.out.println(foods[0]);
        System.out.println(scores[2]);

数组的长度

 //4.3 数组的长度:使用length属性

        System.out.println(names.length);//3
        System.out.println(scores.length);//6

数组的遍历

//4.4 数组的遍历
//        System.out.println(scores[0]);
//        System.out.println(scores[1]);
//        System.out.println(scores[2]);
//        System.out.println(scores[3]);
//        System.out.println(scores[4]);
//        System.out.println(scores[5]);

        for(int i = 0;i < scores.length;i++){
            System.out.println(scores[i]);
        }

        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }

数组元素的默认初始化值见《ArrayTest1.java》

数组元素的默认初始化值 (以动态初始化为例说明)
 *
 *      ① 如果数组元素是整型(byte\short\int\long)，则默认值为：0
 *      ② 如果数组元素是浮点型(float \ double)，则默认值为：0.0
 *      ③ 如果数组元素是boolean型，则默认值为：false
 *      ④ 如果数组元素是char型，则默认值为：0 或 '\u0000'
 *
 *      ⑤ 如果数组元素是引用数据类型，则默认值为：null

数组的内存解析

在这里插入图片描述

知识点3：二维数组的使用

 * 1. 数组的分类：
 * ① 按照数组元素的类型：基本数据类型元素的数组  vs  引用数据类型元素的数组
 * ② 按照数组的维数： 一维数组 、 二维数组 、 三维数组 、 。。。。
 *
 * 2.数组，属于引用数据类型；数组的元素，既可以是基本数据类型，也可以是引用数据类型。
 *   如果一维数组的元素，又是一维数组，则构成了二维数组。

基本使用

//一维数组的定义
        int[] scores = new int[]{56,54,87,98,77,68};
        //3.1 二维数组静态初始化
        String[][] names = new String[][]{{"闫宏浩","杨超宇"},{"付子","周斌","孟腾博"},{"王延彬","翟旭亮"}};

        //3.1 二维数组动态初始化
        int[][] ages = new int[4][3];
        int[] nums[] = new int[4][];
        nums[0] = new int[5];
        nums[1] = new int[6];

        //错误的：
//        int[][] arr = new int[][4];

        //3.2 如何访问数组的元素
        //通过角标的方式访问
        System.out.println(names[1]);//地址值  [Ljava.lang.String;@1540e19d
        System.out.println(names[1][1]);//"周斌"

        ages[1][2] = 12;

        //3.3 数组的长度
        System.out.println(names.length);//3
        System.out.println(names[0].length);//2

        //3.4 数组的遍历
        for(int i = 0;i < names.length;i++){//{{"闫宏浩","杨超宇"},{"付子","周斌","孟腾博"},{"王延彬","翟旭亮"}}
            for(int j = 0;j < names[i].length;j++){
                System.out.print(names[i][j] + "  ");
            }
            System.out.println();
        }

二维数组元素的默认初始化值

形式1，比如：int[][] ages = new int[4][3];
 *       外层元素：存储的是地址值
 *       内层元素：
 *             ① 如果数组元素是整型(byte\short\int\long)，则默认值为：0
 *             ② 如果数组元素是浮点型(float \ double)，则默认值为：0.0
 *             ③ 如果数组元素是boolean型，则默认值为：false
 *             ④ 如果数组元素是char型，则默认值为：0 或 '\u0000'
 *
 *             ⑤ 如果数组元素是引用数据类型，则默认值为：null
 *
 *
 *     形式2，比如：int[][] nums = new int[4][];
 *       外层元素：默认值null
 *       内层元素：不存在，输出的话，会报异常：NullPointerException

public class ArrayTest1 {
    public static void main(String[] args) {
        int[][] ages = new int[4][3];

        System.out.println(ages[0]);//外层元素：null  [I@1540e19d
        System.out.println(ages[0][0]);//内层元素：0

        String[][] arr = new String[4][2];
        System.out.println(arr[0][0]);//null

        System.out.println("####################");
        int[] nums[] = new int[4][];
        System.out.println(nums[0]);//null
        System.out.println(nums[0][0]);//报错:NullPointerException

    }
}

内存解析

在这里插入图片描述

知识点4：数组中的常见算法

1. 数组元素的赋值

比如：杨辉三角、回形数、随机生成彩票

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

package com.atguigu.homework;

/**
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，
 * 平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 * <p>
 * 提示：如何获取指定范围的随机数[10,99]
 * (int)(Math.random() * 90 + 10)
 *
 * @author shkstart
 * @create 2020-06-30 9:00
 */
public class Exer02 {
    public static void main(String[] args) {
        //1. 创建数组，并按照要求给数组元素赋值
        int[] arr = new int[10];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 90) + 10;

        }
        System.out.print("获得的随机数为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        //2. 计算数组中的特征值
        int sum = 0;
        int max = 0;
        int mix = 100;
        double ave;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];//计算总和
        }

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max)  //判断最大值
                max = arr[i];
        }

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < mix)  //判断最小值
                mix = arr[i];
        }

        ave = (double)sum / arr.length;

        System.out.println("最大值" + max);
        System.out.println("最小值" + mix);
        System.out.println("所有数的和" + sum);
        System.out.println("平均值" + ave);

    }
}

3.数组的复制、反转、查找(线性查找、二分法查找)

public class ArrayTest {
    public static void main(String[] args) {
        int[] array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
        //数组的复制
        int[] array2 = new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }

        //数组的反转
        //方式一：
//        for(int i = 0;i < array1.length / 2;i++){ // i   array1.length - 1 - i
//            int temp = array1[i];
//            array1[i] = array1[array1.length - 1 - i];
//            array1[array1.length - 1 - i] = temp;
//        }
        //方式二：
        for(int x = 0,y = array1.length - 1;x < y;x++,y--){
            int temp = array1[x];
            array1[x] = array1[y];
            array1[y] = temp;
        }

        //数组的遍历
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + " ");
        }

        //线性查找
        int[] array3 = new int[]{2, 3, 5, 7, -11, 13, 0, 17, 19,0};
        int value = 0;//查找的目标数据
        boolean flag = true;//定义一个是否找到了指定数据的标识
        for(int i = 10;i < array3.length;i++){
            if(value == array3[i]){
                System.out.println("在索引为" + i + "的位置上找到了指定的元素");
                flag = false;
                break;
            }
        }
        if(flag){
            System.out.println("未找到指定的元素");
        }

        //二分法查找：要求此数组必须是有序的。
        int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
        boolean isFlag = true;
        int number = 256;
        number = 25;
        int head = 0;//首索引位置
        int end = arr3.length - 1;//尾索引位置
        while(head <= end){
            int middle = (head + end) / 2;
            if(arr3[middle] == number){
                System.out.println("找到指定的元素，索引为：" + middle);
                isFlag = false;
                break;
            }else if(arr3[middle] > number){
                end = middle - 1;
            }else{//arr3[middle] < number
                head = middle + 1;
            }
        }

        if(isFlag){
            System.out.println("未找打指定的元素");
        }

    }
}

4.数组元素的排序算法

十大排序算法

选择排序
	直接选择排序、堆排序
交换排序
	冒泡排序、快速排序
插入排序
	直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序

在这里插入图片描述

冒泡排序

public class BubbleSortTest {
    public static void main(String[] args) {

        int[] arr = new int[]{34,76,-8,0,56,-45,6,21};

        for(int i = 0;i < arr.length - 1;i++){

            for(int j = 0;j < arr.length - 1 - i;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] + "  ");

        }
    }
}

快排的实现原理

在这里插入图片描述

知识点5：Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

package com.atguigu.java;

import java.util.Arrays;

/**
 *
 * Arrays工具类的使用测试
 * @author shkstart
 * @create 2020-06-30 11:14
 */
public class ArraysTest {
    public static void main(String[] args) {

        int[] arr1 = new int[]{1,2,3,4,5};
        int[] arr2 = new int[]{1,2,3,4,5};
        // == : 比较两个数组的地址值是否相同。即：比较两个引用是否指向堆空间中的同一个数组
        System.out.println(arr1 == arr2);//false
        //equals():比较两个数组的内容是否相等。
        System.out.println(Arrays.equals(arr1,arr2));//true

        //toString():输出数组的元素信息
        System.out.println(Arrays.toString(arr1));

        //fill()：将指定的值填充到数组中的所有位置上
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));

        int[] arr3 = new int[]{34,76,-8,0,56,-45,6,21};
        System.out.println(Arrays.toString(arr3));
        //sort():排序
//        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //binarySearch():对排序后的数组进行二分法检索指定的值。
        //如果找到了，返回找到的元素所对应索引位置。
        //如果没找到，返回负数。
        int index = Arrays.binarySearch(arr3, 76);
        if(index >= 0){
            System.out.println("找到了指定元素。位置为：" + index);
        }else{
            System.out.println("没找到指定元素");
        }
    }
}

知识点6：数组中的常见异常

package com.atguigu.java;

/**
 *  数组中的常见异常：
 *  1. ArrayIndexOutOfBoundsException:数组角标越界异常
 *  2. NullPointerException:空指针异常
 *
 *
 * @author shkstart
 * @create 2020-06-30 11:26
 */
public class ArrayExceptionTest {

    public static void main(String[] args) {
        //1. ArrayIndexOutOfBoundsException:数组角标越界异常
        int[] arr = new int[10];//角标范围：0,1,2，。。。,9
//        System.out.println(arr[10]);//报错

//        System.out.println(arr[-1]);//报错

        //2. NullPointerException:空指针异常
        //情况一：
        String[][] arr2 = new String[5][];
//        System.out.println(arr2[0][0]);

        //情况二：
        int[] arr3 = new int[10];
//        arr3 = null;
        System.out.println(arr3[0]);

        //情况三：通过对象调用内部的方法时，如果此对象是null,则空指针异常
        String[] arr4 = new String[10];
        System.out.println(arr4[0].toString());

    }
}

猛肝自然强

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础学习笔记：第三章数组

知识点1：数组的理解 * 1. 数组，可以看做是多个相同数据类型类型的变量按照一定顺序依次紧密排列起来的集合。 * * 2.数组的相关概念： * 数组名 * 数组元素 * 数组的长度 * 数组的角标、下标、下角标、索引、index * * 3. 回顾：变量按照数据类型来分：基本数据类型、引用数据类型（数组、类、接口） * * >数组，属于引用数据类型；数组的元素，既可以是基本数据类型，也可以是引用数据类型。 * >数组，一旦初始化完成，其长度就是确定的。且长度不可变
复制链接

扫一扫