Java笔记五(数组)

news2024/12/24 19:06:49

目录

数组

数组声明创建

数组初始化的三种初始化类型:

静态初始化

动态初始化

数组的默认初始化

数组的四个基本特点

数组边界

数组的使用

示例一:计算所有的元素和以及查找最大元素

示例二:For-Each循环

示例三:数组作方法入参

示例四:数组作返回值:数组的翻转

多维数组

多维数组的使用

Arrays类

示例:

冒泡排序

示例:

优化代码:

稀疏数组

存下棋盘:

压缩成稀疏数组:

稀疏数组的还原:


数组

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成

其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。

数组声明创建

 

首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法

dataType[] arrayRefVar;//首选的方法

dataType arrayRefVar[];//效果相同但不是首选方法,是为了帮助早期的c与c++程序员能快速入手Java

java语言使用new操作符来创建数组,语法如下:

dataType[] arrayRefVar=new dataType[arraySize];

数组的元素是通过索引访问的,数组索引从0开始。

获取数组长度:arrays.length

public class weekend01 {
    //变量的类型  变量的名字=变量的值;
    //数组类型
    public static void main(String[] args) {
        int[] nums;//声明一个数组
        nums=new int[10];//创建一个数组
        //给数组元素中赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        System.out.println(nums[9]);
        //计算所有元素的和
        int sum=0;
        //获取数组长度:arrays.length
        for (int i=0;i<nums.length;i++){
            sum=sum+nums[i];
        }
        System.out.println("总和为:"+sum);
    }
}

数组初始化的三种初始化类型:

静态初始化

int[] a={1,2,3};

Man[] mans={new Man(1,1),new Man(2,2)};

动态初始化

int[] a=new int[2];

a[0]=1;

a[1]=2;

数组的默认初始化

数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。

 

 

public class Weekend02 {
    public static void main(String[] args) {
        //静态初始化:创建+赋值
        int[] a={1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
        //动态初始化:包含默认初始化
        int[] b=new int[10];
        b[0]=10;
        b[1]=10;
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
    }
}

 

数组的四个基本特点

◆其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。

◆其元素必须是相同类型,不允许出现混合类型。

◆数组中的元素可以是任何数据类型,包括基本类型和引用类型。

数组本身就是对象,Java中对象是在堆中的因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组边界

◆下标的合法区间; [0, length-1],如果越界就会报错;

◆ArrayIndexOutOfBoundsException :数组下标越界异常!

◆小结:

◆数组是相同数据类型(数据类型可以为任意类型)的有序集合

◆数组也是对象。数组元素相当于对象的成员变量

◆数组长度是确定的,不可变的。如果越界,则报: ArrayIndexOutofBounds

数组的使用

示例一:计算所有的元素和以及查找最大元素

public class Weekend03 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        //打印全部的数组元素
        for (int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
        System.out.println("=============");
        //计算所有元素的和
        int sum=0;
        for (int i=0;i<arrays.length;i++){
            sum=sum+arrays[i];
        }
        System.out.println("sum="+sum);
        //查找最大元素
        int max=arrays[0];
        for (int i=1;i<arrays.length;i++){
           if (arrays[i]>max){
               max=arrays[i];
           }
        }
        System.out.println("max="+max);
    }
}

 

示例二:For-Each循环

 

public class Weekend04 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        for (int array : arrays) {
            System.out.println(array);//增强for循环
        }
    }

 

示例三:数组作方法入参

public class Weekend04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        printArray(arrays);
        }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

 

示例四:数组作返回值:数组的翻转

public class Weekend04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        int[] reverse=reverse(arrays);
        printArray(reverse);
        }
        //反转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--){
            result[j]=arrays[i];
        }
            return result;
    }

        //打印数组元素
    public static void printArray(int[] arrays){
        for (int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

 

多维数组

多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一位数组

二维数组

int a[][]=new int[2][5];

以上二维数组a可以看成一个两行五列的数组

 

多维数组的使用
public class Weekend05 {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
        System.out.println(array[1][0]);
        System.out.println(array[2][1]);
        System.out.println("=============");
        System.out.println(array.length);//外层数组长度
        System.out.println(array[0].length);//内层数组长度
        System.out.println("=============");
        for (int i=0;i<array.length;i++){//循环输出二维数组所有元素
            for (int j=0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }
    }

    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

 

Arrays类

由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作

需要习惯使用JDK帮助文档

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而“不用”使用对象来调用

常用功能:

给数组赋值:通过fill方法

对数组排序:通过sort方法,按升序

比较数组:通过equals方法比较数组中元素值是否相等

查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作

示例:

public class Weekend06 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,9090,3123,423,23,6};
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        System.out.println("===========================");
        Arrays.sort(a);//数组进行排序:升序
        System.out.println(Arrays.toString(a));
        System.out.println("============================");
        Arrays.fill(a,1);//数组填充
        System.out.println(Arrays.toString(a));
    }
}

 

 

 

冒泡排序

冒泡排序是最为出名的排序算法之一,共有八大排序

这个算法的时间复杂度为O(n^2)

冒泡排序:

1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置

2.每一次比较,都会产生出一个最大,或者最小的数字;

3.下一轮则可以少一次排序

4.依次循环直到结束

示例:

import java.util.Arrays;

public class Weekend07 {
    public static void main(String[] args) {
        int[] a={1,5,4,6,45,61,49,88,13,9};
        int[] sort=sort(a);//调用完我们自己写的排序方法以后,返回一个排序后的数组
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array) {
        int temp = 0;
        //外层循环,判断这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环,比较判断两个数,如果第一个数比第二个数大则交换位置
            for (int j = 0; j < array.length - 1-i ; j++) {//减去i的原因是前面的循环以及排序好的数后面的循环可以直接省去不用再次比较排序
                if (array[j + 1] < array[j]) {
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;//两个数的交换操作
                }
            }
        }
        return array;
    }
}

 

优化代码:

import java.util.Arrays;

//冒泡排序:
//1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
//2.每一次比较,都会产生出一个最大,或者最小的数字;
//3.下一轮则可以少一次排序
//4.依次循环直到结束
public class Weekend07 {
    public static void main(String[] args) {
        int[] a={1,5,4,6,45,61,49,88,13,9};
        int[] sort=sort(a);//调用完我们自己写的排序方法以后,返回一个排序后的数组
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array) {
        int temp = 0;
        //外层循环,判断这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag=false;
            //内层循环,比较判断两个数,如果第一个数比第二个数大则交换位置
            for (int j = 0; j < array.length - 1-i ; j++) {//减去i的原因是前面的循环以及排序好的数后面的循环可以直接省去不用再次比较排序
                if (array[j + 1] < array[j]) {
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;//两个数的交换操作
                    flag=true;
                }
            }
            if (flag==false){
                break;//优化了多余的无作用的排序
            }
        }
        return array;
    }
}

 通过判断两个数是否无需排序从而减去循环优化了多余的无作用的排序

 

稀疏数组

 

需求:编写五子棋游戏中,有存盘退出和续上盘的功能

假设白棋为1,黑棋为2,棋盘上空位都为0

分析问题:以为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据

解决;稀疏数组

当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组

稀疏数组的处理方式:

1.记录数组一共有几行几列,有多少个不同值

2.把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

 

 左边为原始二维数组,右边为稀疏数组

 

 

存下棋盘:

 

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11(保存棋盘)
        //0:没有棋子 1:黑棋 2:白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");

            }
            System.out.println();
            
        }
    }
}

 

 

压缩成稀疏数组:

 

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11(保存棋盘)
        //0:没有棋子 1:黑棋 2:白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");

            }
            System.out.println();
            
        }
        System.out.println("=====================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
                
            }
            
        }
        System.out.println("有效值的个数:"+sum);
        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];//有效值的个数+1是行数,列是固定三列
        array2[0][0]=11;//存的行数
        array2[0][1]=11;//存的列数
        array2[0][2]=sum;//存的有效值的个数
        //遍历二维数组,讲非零的值存放与稀疏数组中
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;//起到计数的作用
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
            
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
            
        }
    }
}

 

 

稀疏数组的还原:

 

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11(保存棋盘)
        //0:没有棋子 1:黑棋 2:白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");

            }
            System.out.println();
            
        }
        System.out.println("=====================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
                
            }
            
        }
        System.out.println("有效值的个数:"+sum);
        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];//有效值的个数+1是行数,列是固定三列
        array2[0][0]=11;//存的行数
        array2[0][1]=11;//存的列数
        array2[0][2]=sum;//存的有效值的个数
        //遍历二维数组,讲非零的值存放与稀疏数组中
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;//起到计数的作用
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
            
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
            
        }
        System.out.println("=================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];//由稀疏数组得出二维数组的行列数
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];//将有效数字赋值

        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");

            }
            System.out.println();

        }
    }
}

所有学习资源来自哔哩哔哩——up主遇见狂神说——狂神说Java

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1054235.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

[NOIP2011 提高组] 选择客栈

[NOIP2011 提高组] 选择客栈 题目描述 丽江河边有 n n n 家很有特色的客栈&#xff0c;客栈按照其位置顺序从 1 1 1 到 n n n 编号。每家客栈都按照某一种色调进行装饰&#xff08;总共 k k k 种&#xff0c;用整数 0 ∼ k − 1 0 \sim k-1 0∼k−1 表示&#xff09;&am…

【论文笔记】SVDM: Single-View Diffusion Model for Pseudo-Stereo 3D Object Detection

原文链接&#xff1a;https://arxiv.org/abs/2307.02270 1. 引言 目前的从单目相机生成伪传感器表达的方法依赖预训练的深度估计网络。这些方法需要深度标签来训练深度估计网络&#xff0c;且伪立体方法通过图像正向变形合成立体图像&#xff0c;会导致遮挡区域的像素伪影、扭…

初识Java 12-1 流

目录 Java 8对流的支持 流的创建 随机数流 int类型的区间范围 generate() iterate() 流生成器 Arrays 正则表达式 本笔记参考自&#xff1a; 《On Java 中文版》 ||| 流的概念&#xff1a;流是一个与任何特定的存储机制都没有关系的元素序列。 流与对象的成批处理有关…

CSP-J第二轮试题-2021年-3题

文章目录 参考&#xff1a;总结 [CSP-J 2021] 网络连接题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1 样例 #2样例输入 #2样例输出 #2 样例 #3样例输入 #3样例输出 #3 样例 #4样例输入 #4样例输出 #4 提示答案1答案2 现场真题注意事项 参考&#xff1a; https://www…

使用 MyBatis 进行批量插入操作

使用 MyBatis 进行批量插入操作 批量插入是在数据库中同时插入多条记录的操作&#xff0c;通常用于提高数据插入的效率&#xff0c;特别是在需要大量数据导入或初始化时。MyBatis是一款流行的Java持久层框架&#xff0c;它提供了简单而强大的方式来执行批量插入操作。本文将介…

【数据结构】树的概念理解和性质推导(保姆级详解,小白必看系列)

目录 一、前言 &#x1f34e; 为什么要学习非线性结构 ---- 树&#xff08;Tree&#xff09; &#x1f4a6; 线性结构的优缺点 &#x1f4a6; 优化方案 ----- 树&#xff08;Tree&#xff09; &#x1f4a6; 树的讲解流程 二、树的概念及结构 &#x1f350; 树的概念 &…

vue + openlayer 按路径移动

示例 创建一个方形的规矩&#xff0c;并让点按轨迹移动。效果如下: 源代码 <template><div><div id"map" class"map"></div><button id"start-animation" ref"startButton">Start Animation</bu…

【Python】基于OpenCV人脸追踪、手势识别控制的求实之路FPS游戏操作

【Python】基于OpenCV人脸追踪、手势识别控制的求实之路FPS游戏操作 文章目录 手势识别人脸追踪键盘控制整体代码附录&#xff1a;列表的赋值类型和py打包列表赋值BUG复现代码改进优化总结 py打包 视频&#xff1a; 基于OpenCV人脸追踪、手势识别控制的求实之路FPS游戏操作 手…

Cursor不要太好用,看图见真相

看图见真相: Cursor安装地址: https://www.cursor.so/

02_静态链接和简单宕机分享

ARM64寄存器 Arm64提供31个64bit通用寄存器 汇编用x表示64位宽 w32位宽 X0~X7: 用于传递子程序参数和结果&#xff0c;使用时不需要保存&#xff0c;多余参数采用堆栈传递&#xff0c;64位返回结果采用x0表示&#xff0c;128位 返回结果采用X1:X0 表示。 X24到x28 看得出来子…

C++容器之unordered_map、unordered_set的底层剖析

文中源码以上传至Gitee 目录 序列式容器和关联式容器unordered_set和unordered_map 哈希表概念 哈希函数与哈希冲突常用的哈希函数直接定址法除留余数法 哈希冲突处理方案开放定址法链地址法开放定地址法和链地址法对比 开放定址法实现链地址法实现unordered_map和unordered_s…

什么是SQL注入(SQL Injection)?如何预防它

什么是 SQL 注入&#xff08;SQL Injection&#xff09;&#xff1f;如何预防它&#xff1f; SQL注入&#xff08;SQL Injection&#xff09;是一种常见的网络安全漏洞&#xff0c;攻击者通过在应用程序的输入中插入恶意SQL代码来执行未经授权的数据库操作。SQL注入攻击可能导…

CSP-J第二轮试题-2020年-4题

文章目录 参考&#xff1a;总结 [CSP-J2020] 方格取数题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1 样例 #2样例输入 #2样例输出 #2 提示样例 1 解释 样例 2 解释 数据规模与约定 答案1 现场真题注意事项 参考&#xff1a; P7074 [CSP-J2020] 方格取数 总结 本系…

Docker 自动化部署(实践)

常用命令 docker search jenkins查看需要的jenkins镜像源 docker pull jenkins/jenkins 拉取jenkins镜像 docker images查看下载的镜像源 docker ps 查看包含启动以及未启动的容器 docker ps -a查看启动的容器 docker rm 容器id/容器名称 删除容器 docker rm -f 容器id/容器名…

算法基础课第一部分

算法基础课 第一讲 基础算法快速排序归并排序二分整数二分模板AcWing 789. 数的范围(整数二分法)AcWing 1236.递增三元组AcWing 730. 机器人跳跃问题AcWing 1227. 分巧克力AcWing 1221. 四平方和(二分法/哈希)蓝桥杯-扫地机器人 (二分贪心)AcWing 790. 数的三次方根(浮点二分法…

NSSCTF做题(6)

[HCTF 2018]Warmup 查看源代码得到 开始代码审计 <?php highlight_file(__FILE__); class emmm { public static function checkFile(&$page) { $whitelist ["source">"source.php","hint"…

Java-API简析_java.util.Objects类(基于 Latest JDK)(浅析源码)

【版权声明】未经博主同意&#xff0c;谢绝转载&#xff01;&#xff08;请尊重原创&#xff0c;博主保留追究权&#xff09; https://blog.csdn.net/m0_69908381/article/details/133463511 出自【进步*于辰的博客】 因为我发现目前&#xff0c;我对Java-API的学习意识比较薄弱…

人工智能的学习算法

1956年&#xff0c;几个计算机科学家相聚在达特茅斯会议&#xff0c;提出了 “人工智能” 的概念&#xff0c;梦想着用当时刚刚出现的计算机来构造复杂的、拥有与人类智慧同样本质特性的机器。其后&#xff0c;人工智能就一直萦绕于人们的脑海之中&#xff0c;并在科研实验室中…

K折交叉验证——cross_val_score函数使用说明

在机器学习中&#xff0c;许多算法中多个超参数&#xff0c;超参数的取值不同会导致结果差异很大&#xff0c;如何确定最优的超参数&#xff1f;此时就需要进行交叉验证的方法&#xff0c;sklearn给我们提供了相应的cross_val_score函数&#xff0c;可对数据集进行交叉验证划分…

小程序是一种伪需求技术吗?

点击下方“JavaEdge”&#xff0c;选择“设为星标” 第一时间关注技术干货&#xff01; 免责声明~ 任何文章不要过度深思&#xff01; 万事万物都经不起审视&#xff0c;因为世上没有同样的成长环境&#xff0c;也没有同样的认知水平&#xff0c;更「没有适用于所有人的解决方案…