3_数组（Java学习笔记）

最新推荐文章于 2024-05-21 17:18:32 发布
最新推荐文章于 2024-05-21 17:18:32 发布
阅读量115 收藏 1
点赞数
分类专栏： 软件开发 文章标签： 算法 二分法 数据结构 java
原文链接：https://www.bilibili.com/video/BV1Kb411W75N?from=search&seid=10388185317086324785
版权

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());
    }
}
小知识：一旦程序出现异常，未处理时，就终止执行。
DZSpace
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java关于数组（学习笔记）
12-21
关于数组Array（学习笔记） 简介： 数组就是一个容器，可以同时容纳多个元素。意思是“一组数据”。 Java语言中的数组是一种引用数据类型。不属于基本数据类型，父类同样是Object类。因为是引用数据类型，所以数组的对象存储在堆内存中。如果存储的是Java对象的话，实际存储是对象的引用（内存地址），数组中不能直接存储Java对象。 数组在内存方面存储的时候，数组的内存地址是连续的（存储的每个数据都是按顺序排列的）。数组的第一个小方框的内存地址作为这个数组对象的内存地址。 数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。java中要求数组中元素的类型要统一。比如int
方法与数组
qq_44386947的博客
11-14 206
梵蒂冈的
DAY 6 数组
qq_46031627的博客
07-26 112
1.数组 1.1数组的理解： 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名， 并通过编号的方式对这些数据进行统一管理。 1.2数组相关的概念： * 数组名 * 元素 * 角标、下标、索引 * 数组的长度：元素的个数 1.3.数组的特点： * 1数组是序排列的 * 2数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 * 3创建数组对象会在内存中开辟一整块连续的空间 * 4数组的长度一旦确定，就不能修改。 1.4. 数组的分类： *
蓝桥杯JAVA-2.数组操作
墨水记忆
12-10 8744
目录 个人博客 www.tothefor.com 1.数组 1.1 声明创建数组 int[] a=new int[10]; //首选 int aa[]=new int[10]; //C/C++形式，效果相同，但不是最好的选择 int[] b={2,5,14,5,3}; //创建并初始化 1.2 多维数组 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。 1.2.1 固定空间 int[][] b=new int[5][2]; 1.2.2 动态分配 可以为每一
python 函数中的列表赋值
Devil的博客
03-24 4020
在python中，将列表传递给函数，在函数中对列表进行任何修改都是永久性的。 但是如果在函数中对传递来的列表进行赋值操作，则不会影响列表的数据。 这样一段代码 def Merge_sort(arr): arr = [4,6] arr = [6,4,8,1,4,2,7,6] Merge_sort(arr) print(arr) 其输出结果，依然是[6,4,8,1,4,2...
2022年C语言程序设计题库习集带答案（史上最全版）
热门推荐
m0_63394128的博客
05-03 6万+
《C语言程序设计》试题一 一、填空题 1、C语言中基本的数据类型有： 、 、 。 2、C语言中普通整型变量的类型说明符为 ，在内存中占 字节，有符号普通整型的数据范围是 。 3、整数-35在机内的补码表示为 。 4、执行下列语句int a=8; a+=a-=a*a; 后，a的值是 。 5、有如下语句：char A[ ]={”I...
javascript ES5中 foreach()遍历方法
weixin_44638167的博客
09-28 5721
forcach() array.forEach(function(currentValue, index, arr)) currentValue：数组当前项的值 index：数组当前项的索引 (可选) arr：数组对象本身 filter() 方法创建一个新的数组， 新数组中的元素是通过检查指定数组中符合条件的所有元素,主要用于筛选数组 注意它直接返回一个新数组 代码: <script> var arr=[50,86,12,10,0,38]; var newa
元素赋值、增加元素和删除元素
weixin_34309543的博客
10-18 277
1、元素赋值 1 #我们前面学习过赋值语句，赋值语句是最简单地改变列表的方式，如 a=2 就是一种改变列表的方式。这里我们将通过编号标记某个特定位置的元素，并对该位置的元素重新赋值，如a[1]=10.例： 2 >>> a=[1,2,3,2,1] 3 >>> a[1]=10 4 >>> a 5 [1, 10, 3, 2, ...
二维数据的定义、初始化和赋值
weixin_43313697的博客
06-29 1849
数组可以看作是一行连续的数据，只有一个下标，称为一维数组。在实际问题中有很多数据是二维的或多维的，因此C语言允许构造多维数组。多维数组元素有多个下标，以确定它在数组中的位置。本节只介绍二维数组，多维数组可由二维数组类推而得到。 二维数组的定义 二维数组定义的一般形式是： dataType arrayName[length1][length2]; 其中，dataType 为数据类型，arrayNam...
JAVA基础数组题目
weixin_44990342的博客
09-14 387
int[] arr1 = {1,2,3,4,5,6,7,8,9}; int[] arr2= arr1; arr2[0] = 100; System.out.println(arr1[0] ); 这个输入的结果是100，因为从头到尾只有一个数组，它只开辟了一个空间，没有再次new一个int[] arr2= arr1;可以理解为把arr1的地址传给了arr2两个是公用一个数组在，所以改变arr2数组0...
Java数组-学习笔记.docx
07-05
JAVA学习笔记 Java知识点总结
java学习笔记
12-22
匿名对象4.Random类5.ArrayList集合5.String类6.static关键字7.Arrays数组工具类8.Math数学工具类继承与多态1.继承2.抽象类3.接口4.多态5.final关键字6.权限修饰符7.内部类常用API第二部分1.Date类2.Calender类3.Sys
010403_【第4章：数组与方法】_数组的引用传递笔记.pdf
08-19
java课程学习资料 若有侵权，请联系本人进行移除。
java学习笔记（排序，数组）
03-03
内容为本人学习Java编程基础数组、排序部分整理笔记，内部含有两个文件，格式不同内容相同，方便大家参考使用
JAVA学习四：数组
u011504151的专栏
07-25 509
数组的定义：         数组即为同一种类型的数据的集合，其实数组就是一个容器； 数组的好处：         可以自动给数组中的元素从0开始编号，方便操作这些元素，（即为数组中存放的每一个元素赋以了自然顺序相对应的角标）。 数组定义时的第一种格式：          元素类型[] 数组名 = new 元素类型[数组中需要存放的元素个数]；          示例：int[] a
java数组
Mikon_0703
05-22 148
1. 数组的定义 数组元素是相同数据类型的变量 在堆内存中开辟连续的空间 数组元素的总个数就是数组的长度 数组名.length 数组下标从0开始 数组名[下标] 2. 数组声明 数据类型 [] 数组名称 = new 数据类型[长度]; 动态初始化 一维数组：int [ ] arr =new int[10] 二维数组：int[] [] arr = new int [2][3] 静态初始化 一维数组 int [] arr = {1,2,3,4.....} 二维数组int [][] arr
System.out.println()打印数组，打印字符串,打印char类型的数组
weixin_45489487的博客
04-15 3981
数组放在内存的堆里面，引用在栈里面。输出引用是输出的引用的地址，不是数组的地址 文章目录java中char类型数组用数组名打印结果不是地址值而是数组内容Arrays.toString() java中char类型数组用数组名打印结果不是地址值而是数组内容 String s1 = "HElloworld1234"; chs = s1.toCharArray(); System.out.println(chs); System.out.println("前边加上字符输出的是地址："+chs
[每日一题]169：找出最大的可达成数字
最新发布
AngelDg的博客
05-21 214
题目要求得一个最大的整数 x，使其在不超过 t 次操作内变成与 num 相等的数字。每次操作可以选择将 x 增加或减少 1，同时可以选择将 num 增加或减少 1。返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。给你两个整数 num 和 t。
java ml介绍_Java学习笔记一：数据类型I
06-09
Java的引用数据类型包括：类、接口、数组和枚举。这些数据类型是由程序员定义的，它们的实例在内存中是以引用的形式存储的。 在机器学习中，Java通常被用于开发和部署机器学习模型，尤其是在企业级应用中。Java的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值