Day 06-JAVA数组

已于 2023-03-10 15:14:42 修改
阅读量48 收藏
点赞数 1
分类专栏： JAVASE 文章标签： java 数据结构 算法
于 2023-03-07 17:11:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47360433/article/details/129386141
版权

1、数组概述

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

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

  • 每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问他们。

2、数组声明创建

  • 首先必须声明数组变量，才能在程序里使用数组

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

或

dataType arrayRefVar[]; //效果相同，但非首选

  • Java语言使用new操作符来创建数组

dataType[] arrayRefVar = new dataType[arraySize];

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

  • 获取数组长度： array.length

package com.wmj.array;
​
public class ArrayDemo01 {
    //变量的类型  变量的名字   =变量的值；
    //数组类型
    public static void main(String[] args) {
        int[] nums;   //1.声明了一个数组
//        int nums2[];
​
        nums=new int[10];   //2.创建一个数组，可存放10个int类型的数字
​
        //3.给数组元素中赋值
        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[5]);
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum=sum+nums[i];
        }
        System.out.println("总和为"+sum);
​
    }
}

若输出的是nums[10]，则会出现异常ArrayIndexOutOfBoundsException。

内存分析

JAVA内存：

  • 堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用

  • 栈：存放基本变量类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）

  • 方法区：可以被所有线程共享；包含了所有的class和static变量

.......

数组的三种初始化

  • 静态初始化

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;

  • 数组的默认初始化

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

package com.wmj.array;
​
public class ArrayDemo02 {
    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;
​
        System.out.println(b[0]);
        System.out.println(b[2]);
    }
}

数组的四个基本特点

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

  • 其元素必须是相同类型，不允许出现混合类型；

  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型；

  • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的。因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界

  • 下标的合法区间：[0,length-1]，如果越界就会报错；

  • ArrayIndexOutOfBondsExceptiion:数组下标越界异常；

  • 小结：

    • 数组是相同数据类型（数据类型可以为任意类型）的有序集合；

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

    • 数组长度是确认的、不可变的。如果越界，则报ArrayIndexOutOfBondsExceptiion

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化,创建+赋值
        int[] a={1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
​
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

3、数组使用

  • 普通的For循环

  • For-Each循环

  • 数组作方法入参

  • 数组作返回值

package com.wmj.array;
​
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
​
        //arrays.for+回车，自动生成
        //JDK1.5,没有下标，适用于打印数组
//        for (int array:arrays) {
//            System.out.println(array);
//        }
//        printArray(arrays);
        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]+" ");
        }
    }
​
}

4、多维数组

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

  • 二维数组

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

  • 解析：以上二维数组a可以看成一个两行五列的数组。

  • 思考：多维数组的使用？

package com.wmj.array;
​
public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
            1,2  array[0]
            2,3  array[1]
            3,4  array[2]
            4,5  array[3]
         */
        int[][] array={{1,2},{2,3},{3,4},{4,5}};
​
        printArray(array[0]);
        System.out.println(array[0][0]);
//        System.out.println(array.length);
//        System.out.println(array[0].length);
​
        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]+" ");
        }
    }
}

5、Arrays类

  • 数组的工具类java.util.Arrays

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

  • 查看JDK帮助文档

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

  • 具有以下常用功能：

    • 给数组赋值：通过fill方法

      public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)

      将指定的布尔值来指定数组的每个元素的布尔值指定的范围。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果fromIndex==toIndex，范围是满是空的。）

    • 对数组排序：通过sort方法，按升序

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

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

​

import java.util.Arrays;
​
public class ArrayDemo06 {
    public static void main(String[] args) {
​
        int[] a={1,33,44,666757,66,88,99};
​
        System.out.println(a);   //[I@1b6d3586
        //打印数组元素
        System.out.println(Arrays.toString(a));
        printArray(a);
    }
​
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }
        }
    }
}

package com.wmj.array;
​
import java.util.Arrays;
​
public class ArrayDemo07 {
    public static void main(String[] args) {
​
        int[] a = {1, 33, 44, 666757, 66, 88, 99};
​
        Arrays.sort(a);   //数组进行排序:升序
        System.out.println(Arrays.toString(a));
​
        Arrays.fill(a,2,4,0);  //数组填充
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

（两层循环，外层冒泡轮数，里层依次比较，时间复杂度为O（n2））

​

import java.util.Arrays;
​
public class ArrayDemo08 {
    public static void main(String[] args) {
        int [] a={2,44,1,55,66,44,88,29};
        int[] sort=sort(a);//调用完我们自己写的排序方法后，返回一个排序后的数组
​
        System.out.println(Arrays.toString(a));
    }
    
    
    //冒泡排序
    //1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，交换两数位置
    //2、每一次比较，都会产生一个最大或者最小的数字
    //3、下一轮则可以少一次排序！
    //4、依次循环，直到结束！
    public static int[] sort(int[] arrays){
        //临时变量
        int temp=0;
​
        //外层循环，判断需要比较多少次
        for (int i = 0; i < arrays.length-1; i++) {
            //内层循环,比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < arrays.length-1-i; j++) {
                //减去i是因为，第i次比较后，已经产生了i个最大或最小的数，不需要进行下一轮比较
                if(arrays[j+1]>arrays[i]){
                    temp=arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=temp;
                }
            }
        }
        return arrays;
    } 
}

优化：

​

import java.util.Arrays;
​
public class ArrayDemo08 {
    public static void main(String[] args) {
        int [] a={2,44,1,55,66,44,88,29};
        int[] sort=sort(a);//调用完我们自己写的排序方法后，返回一个排序后的数组
​
        System.out.println(Arrays.toString(a));
    }
    
    
    //冒泡排序
    //1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，交换两数位置
    //2、每一次比较，都会产生一个最大或者最小的数字
    //3、下一轮则可以少一次排序！
    //4、依次循环，直到结束！
    public static int[] sort(int[] arrays){
        //临时变量
        int temp=0;
​
        //外层循环，判断需要比较多少次
        for (int i = 0; i < arrays.length-1; i++) {
            
            boolean flag=false;   //通过flag标识符减少没有意义的比较
​
            //内层循环,比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < arrays.length-1-i; j++) {
                //减去i是因为，第i次比较后，已经产生了i个最大或最小的数，不需要进行下一轮比较
                if(arrays[j+1]>arrays[i]){
                    temp=arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=temp;
                }
            }
            if(flag==false){
                break;
            }
        }
        return arrays;
    } 
}

6、稀疏数组

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

  • 稀疏数组的处理方式是：

    • 记录数组一共有几行几列，有多少个不同值

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

​

public class ArrayDemo09 {
    public static void main(String[] args) {
        //1、创建一个二维数组  11*11   0：没有棋子  1：黑棋  2：白棋
​
        int[][] array1=new int[11][11];  //生成二维数组的默认值全为0
        array1[1][2]=1;
        array1[2][3]=1;
        //输出原始的数组
        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);
​
        //2、创建一个稀疏数组的数组
        int[][] array2=new int[sum+1][3];
​
        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];
        }
​
        //3、打印
        System.out.println("输出还原的数组");
​
        for (int[] ints: array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
​
    }
}

王疯疯233
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
day04-Java数组.md
03-30
day04-Java数组.md
Java-day-4:1.方法2. 3-D数组3.扩展为语句4.参数
05-02
在"Java-day-4"的学习中，我们将深入探讨四个关键概念：方法、3-D数组、扩展为语句以及参数。这些知识点对于理解和掌握Java编程至关重要。 首先，让我们来谈谈“方法”。在计算机科学中，方法是一种封装特定功能的...
day07-基础语法-数组
12-12
Java 基础语法 - 数组 数组是 Java 语言中的一种基本数据结构，它可以存储多个变量（元素），这些变量的数据类型必须一致。数组既可以存储基本数据类型，也可以存储引用数据类型。 一、数组的定义和初始化 在 ...
day01-Java入门
12-12
2. **基础语法**：包括变量、数据类型、运算符、控制流程（如if条件语句、for和while循环）、数组等。 3. **类和对象**：理解面向对象编程的核心概念，如封装、继承和多态。 4. **异常处理**：学习如何捕获和处理...
JAVA进阶补充
2301_80150315的博客
08-15 571
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 884
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 522
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 258
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 603
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 945
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 709
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 272
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 1067
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
【LeetCode：1702】修改后的最大二进制字符串（Java）
dawn191228的博客
08-15 488
如果二进制字符串 x 对应的十进制数字大于二进制字符串 y 对应的十进制数字，那么我们称二进制字符串 x 大于二进制字符串 y。操作 1 ：如果二进制串包含子字符串 “00” ，你可以用 “10” 将其替换。操作 2 ：如果二进制串包含子字符串 “10” ，你可以用 “01” 将其替换。比方说， “00010” -> “10010”比方说， “00010” -> “00001”输入：binary = “000110”解释：“01” 没办法进行任何转换。输入：binary = “01”
总结常见报错信息
m0_68903702的博客
08-16 117
在@Controller注解中，返回的是字符串或者是字符串匹配的模板名称，即直接渲染视图，与html页面配合使用的，java后端的代码要结合html的情况进行渲染,使用model对象（或者modelandview）的数据将填充user视图中的相关属性，然后展示到浏览器；而在@RestController中，返回的应该是一个对象，即return一个user对象，这时，在没有页面的情况下，也能看到返回的是一个user对象对应的json字符串。情形一：若前端传入Json格式，后端使用。
基于vue框架的爱看电影网站v4o92（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-15 821
项目功能：用户,电影分类,电影信息,电影评分基于Vue框架的爱看电影网站项目功能丰富多样，旨在为用户提供一个集电影浏览、信息查询、观影体验、互动交流于一体的综合性平台。
【Kotlin】Kotlin中的JVM兼容性注解
天天向上 Up Up Up (*^▽^*)
08-13 428
Kotlin和Java可以混合使用，而且Kotlin对Java的兼容性几乎达到了100%但是Kotlin和Java毕竟是两个语言，不可能完全实现无缝转换JVM兼容性注解，就是为了解决编译时的语言差异问题。
HVV护网面经速记速记
weixin_65633498的博客
08-13 391
2.利用T3协议配合RMP或ND接口反向发送反序列化数据(CVE2017-3248、CVE2018-2628、CVE2018-2893、CVE2018-3245、CVE-2018-3191、CVE-2020-14644、CVE-2020-14645)还有利用IIOP协议的CVE-2020-2551。1.直接通过T3协议发送恶意反序列化对象(CVE-2015-4582、CVE-2016-0638、CVE-2016-3510、CVE-2020-2555、CVE-2020-2883)而5.0以下的版本不存。
java 判断日期连续_java - Java-检查数组是否包含3个连续的日期 - 堆栈内存溢出
06-01
可以通过以下步骤判断一个数组中是否包含三个连续的日期： 1. 将数组中的日期按照从早到晚的顺序排序。 2. 遍历数组，从第一个日期开始，判断后续两个日期是否依次为前一个日期的后一天，如果是，则说明找到了三个连续的日期。 3. 如果遍历完整个数组仍未找到三个连续的日期，则说明数组中不存在三个连续的日期。 以下是一个示例代码实现： ``` public static boolean hasConsecutiveDates(Date[] dates) { Arrays.sort(dates); for (int i = 0; i < dates.length - 2; i++) { if (isConsecutive(dates[i], dates[i+1], dates[i+2])) { return true; } } return false; } private static boolean isConsecutive(Date d1, Date d2, Date d3) { Calendar c1 = Calendar.getInstance(); c1.setTime(d1); Calendar c2 = Calendar.getInstance(); c2.setTime(d2); Calendar c3 = Calendar.getInstance(); c3.setTime(d3); return (c2.get(Calendar.DAY_OF_YEAR) == c1.get(Calendar.DAY_OF_YEAR) + 1 && c3.get(Calendar.DAY_OF_YEAR) == c2.get(Calendar.DAY_OF_YEAR) + 1 && c2.get(Calendar.YEAR) == c1.get(Calendar.YEAR) && c3.get(Calendar.YEAR) == c2.get(Calendar.YEAR)); } ``` 注意，以上代码仅演示了判断日期连续的方法，实际使用时还需要根据具体情况进行适当的修改和完善。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王疯疯233

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值