[JavaSE]第三章数组

最新推荐文章于 2022-11-14 15:45:34 发布

Aunean

最新推荐文章于 2022-11-14 15:45:34 发布

阅读量245

点赞数

分类专栏： JavaSE 文章标签： java 数据结构

本文链接：https://blog.csdn.net/qq_47168123/article/details/121993553

版权

JavaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

3.1 数组

3.1.1 数组的概述

数组（Array）：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理
常见概念
- 数组名
- 下标/索引/角标
- 元素
- 数组的长度（元素的个数）
特点
- 数组是有序排列的
- 数组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型
- 创建数据对象会在内存中开辟一整块连续的空间
- 数组的长度一旦确定，就不能修改
数组元素的默认初始化值
- 数组元素是整型：0
- 数组元素是浮点型：0.0
- 数组元素是 char 型：0 或 ‘\u0000’，而非 ‘0’
- 数组元素是 boolean 型：false
- 数组元素是引用数据类型：null

3.1.2 一维数组的使用

声明

int[] ids; //声明
//1.1 静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{100, 101, 102};
//2.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];

调用

//2.如何调用数组的指定位置的元素：通过索引的方式调用
//数组的索引从 0 开始，到数组的 长度-1 结束
names[0] = "李四1";
names[1] = "李四2";
names[2] = "李四3";
names[3] = "李四4";
names[4] = "李四5";

遍历

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

3.1.3 多维数组的使用

对于二维数组的理解，我们可以看成是一维数组 array1 又作为另一个一维数组 array2 的元素而存在，实际上从数组底层的运行机制来看，其实没有多维数组

声明

//动态初始化
//方式一：
//外层元素的初始化值为：地址值
//内层元素的初始化值为：与数组初始化情况相同
int[][] arr = new int[3][2];
System.out.println(arr[0]);//[I@4554617c
System.out.println(arr[0][0]);//0
System.out.println(arr);//[[I@74a14482

//方式二：
//外层元素的初始化值为：null
//内层元素的初始化值为：不能调用，否则报错
int[][] arr2 = new int[3][];


//静态初始化
int[][] arr3 = new int[][]{{1,2,3},{4,3,2},{2,1}}

//特殊写法：
int[] x, y[];//x是一维数组，y是二维数组

调用数组的指定位置的元素
```
System.out.println(arr3[0][2]);//3
```

遍历二维数组

for (int[] ints : arr3) {
    for (int anInt : ints) {
    	System.out.println(anInt);
    }
}

3.1.4 数组中常见算法

杨辉三角

package com.ws.exer;
/*
使用二维数组打印一个10行杨辉三角。
【提示】
1．第一行有 1个元素，第 n 行有 n 个元素
2．每一行的第一个元素和最后一个元素都是 1
3．从第三行开始,对于非第一个元素和最后一个元素的元素。即:
yanghui[i][j] = yanghui[i-1][j-1] + xanghui[i-1][j];

 */
public class YangHuiTest {
    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];//给每列赋值为 0

            //2.1 给首末元素赋值
            yangHui[i][0] = 1;//每行第一个元素值为 1
            yangHui[i][i] = 1;//每行最后一个元素值为 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] + "\t");
            }
            System.out.println();
        }
    }
}

数组的复制、反转、查找（线性查找、二分法查找）

package com.ws.exer;

import java.util.Arrays;

/*
算法的考查:数组的复制、反转、查找(线性查找、二分法查找)

 */
public class ArrayExercise6 {
    public static void main(String[] args) {

        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};

        //数组的复制
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
        }
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));


        //数组的反转 [JJ, DD, MM, BB, GG, AA]
        //方法一
        for (int i = 0; i < arr1.length / 2; i++) {
            String temp = arr1[i];
            arr1[i] = arr1[arr1.length - i - 1];
            arr1[arr1.length - i - 1] = temp;
        }
        System.out.println(Arrays.toString(arr1));

        //方法二
        for (int i = 0, j = arr1.length - 1; i < j; i++, j--) {
            String emp = arr1[i];
            arr1[i] = arr1[j];
            arr1[j] = emp;
        }
        System.out.println(Arrays.toString(arr1));


        //查找（或搜索）
        //线性查找
        boolean isFlag = true;
        String dest = "CC";
        for (int i = 0; i  < arr.length; i++) {
            if (arr[i].equals(dest)) {
                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 dest1 = -34;
        int head = 0; //初始的首索引
        int end = arr2.length - 1; //初始的末索引 9
        boolean isFlag2 = true;
        int i = 0;//查询次数
        while (head <= end) {
            i++;
            int middle = (head + end) / 2;
            if (dest1 == arr2[middle]) {
                System.out.println("找到了指定的元素，位置为：" + middle);
                isFlag2 = false;
                break;
            } else if (arr2[middle] > dest1) {//查找到的值大于要查找的
                end = middle - 1; //往前找
            } else {
                head = middle + 1; //往后找
            }

        }
        System.out.println("查找了：" + i);
        if (isFlag2) {
            System.out.println("没有找到该元素");
        }
    }
}

排序算法（冒泡排序）

package com.ws.exer;

import java.util.Arrays;

/*
数组的冒泡排序的实现
 */
public class BubbleSortTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 7, 2, 7, 8, 9, -23, 34, 68, 12, 2, 3, 7};

        //冒泡排序（两两对比，比出最大的那个元素，然后把最大的元素放到最后，再进行第二轮比较，第二轮比较比第一轮比较少比一次）
        for (int i = 0; i < arr.length - 1; i++) {//比几轮

            for (int j = 0; j < arr.length - 1 - i; j++) {//第j个和每一个去比

                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        /*
        int i = 0; i < 13;
            int j = 0; j < 14 - 1 - 0; arr[0] > arr[1]
            j++; j =2 < 14 - 1; arr[1] > arr[2]
            j++; j = 3 < 14 - 1; arr[2] > [3]; temp = arr[2]=7; arr[2] = arr[3]=2; arr[3] = 7;
         */

        System.out.println(Arrays.toString(arr));
    }
}

3.1.5 Arrays 工具类的使用

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

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 ifEquals = Arrays.equals(arr1, arr2);
        System.out.println(ifEquals);

        //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(arr2));

        //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, 34);
        if (index > 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到");
        }

    }
}

3.1.6 数组常见异常

NullPointerException：空指针异常（没有引用地址值）
ArrayIndexOutOfBoundsException：数组的索引越界异常

333};
int index = Arrays.binarySearch(arr3, 34);
if (index > 0) {
System.out.println(index);
} else {
System.out.println(“未找到”);
}

}


### 3.1.6 数组常见异常

- **NullPointerException**：空指针异常（没有引用地址值）

- **ArrayIndexOutOfBoundsException**：数组的索引越界异常

Aunean

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[JavaSE]第三章数组

3.1 数组3.1.1 数组的概述数组（Array）：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理常见概念数组名下标/索引/角标元素数组的长度（元素的个数）特点数组是有序排列的数组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型创建数据对象会在内存中开辟一整块连续的空间数组的长度一旦确定，就不能修改数组元素的默认初始化值数组元素是整型：0数组元素是浮点型：0.0数组元素
复制链接

扫一扫