Arrays类的讲解（冒泡排序，稀疏数组转换）

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量157 收藏
点赞数
分类专栏： 学习笔记 文章标签： 排序算法 java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoshutong/article/details/124827798
版权

Arrays类的讲解

  • 数组的工具类Java.util.Arrays
  • 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
  • 查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）
  • 具有以下常用功能：
    • 给数组赋值：通过fill方法
    • 对数组排序：通过sort方法，按升序
    • 比较数组：通过equals方法比较数组中元素值是否相等
    • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作
  • 打印数组元素
public class Demo6 {
    public static void main(String[] args) {

        int[] a = {12,2,33,45,35,66,77,86,19,140};
        System.out.println(a);//[I@16b98e56
        //打印数组元素Arrays.toString
	   //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] + ",");
            }
        }
    }
}
  • 输出
[I@16b98e56
[12,2,33,45,35,66,77,86,19,140]

注意点：可以自己创建方法，打印数组元素，也可以使用工具类，但尽量使用工具类，避免做无用的功。（本意上工具类可以不用过度依赖）

  • 数组元素排序
public class Demo6 {
    public static void main(String[] args) {
        int[] a = {12,2,33,45,35,66,77,86,19,140};
        //数组进行排序
        Arrays.sort(a);//升序
        System.out.println(Arrays.toString(a));
    }
}
  • 输出
[2, 12, 19, 33, 35, 45, 66, 77, 86, 140]
  • 数值赋值
public class Demo6 {
    public static void main(String[] args) {
        int[] a = {12,2,33,45,35,66,77,86,19,140};
        Arrays.fill(a,6);、
         System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,7);//二到四之间填充7
        System.out.println(Arrays.toString(a));
    }
}
  • 输出
[6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
[6, 6, 7, 7, 6, 6, 6, 6, 6, 6]

fill:将指定的字节值分配给指定字节数组的每个元素

a—要填充的数组 val—要存储在数组的所有元素中的值

冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序算法
  • 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层次依次比较，江湖中人尽皆知
  • 嵌套循环，应该立马就可以得出这个算法的时间复杂度为O（n^2）

冒泡排序（升序，降序）

public class Demo7 {
    public static void main(String[] args) {
        int[]   a ={333,45,656,778,312,34,556,22};
        int[] sort= sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(a));
        int[] sort1 = sort1(a);
        System.out.println(Arrays.toString(a));
    }
    //冒泡排序
    //1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换位置
    //2.每一次比较，都会产生一个最大，或者最小的数
    //3.下一轮则，可以少一次排序！
    //升序
    public static int[] sort(int[] array){
        int temp = 0;
        //外层循环，判断循环多少次
        for (int i = 0; i < array.length-1; i++) {
          //通过flag标识位减少没有意义的比较
            boolean flag =false ;
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0; j < array.length-1; j++) {
                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;
    }
    //降序
    public static int[] sort1(int[] array){
        int temp = 0;
        //外层循环，判断循环多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0; j < array.length-1; j++) {
                if (array[j+1]>array[j]){
                    temp = array[j] ;
                    array[j] = array[j+1] ;
                    array[j+1] =temp ;
                }
            }
        }
        return array;
    }
}
  • 输出
[22, 34, 45, 312, 333, 556, 656, 778]
[778, 656, 556, 333, 312, 45, 34, 22]

稀疏数组

  • 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，稀疏数组的处理方法是：
    • 记录数组一共有几行几列，有多少个不同的值
    • 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

如下图：左边是原始数组，右边是稀疏数组

在这里插入图片描述

其中，第一行记录的信息是原始二维数组的行、列信息以及有效数据的个数，后面一次存储的是有效数据的行、列信息以及所代表的数值。

  • 二维数组转稀疏数组的思路

    • 遍历原始的二维数组，得到有效数据的个数sum
    • 根据sum就可以创建稀疏数组sparseArr int【sum+1】【3】
    • 将二维数组的有效数据存入稀疏数组

  • 稀疏数组转原始的二维数组的思路

    • 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
    • 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可

  • 实例（二维数组转稀疏数组，稀疏数组转二维数组）

package com.BasicGrammar.Array;

public class Demo8 {
    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循环遍历数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            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];
        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.print(array2[i][0]+"\t");
            System.out.print(array2[i][1]+"\t");
            System.out.println(array2[i][2]+"\t");
        }
        //稀疏数组转二维数组
        System.out.println("还原");
        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //给其中的元素还原它的值
        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();
        }
    }
}
  • 运行结果
输出原始数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
有效数据有：2
稀疏数组
11	11	2	
1	2	1	
2	3	2	
还原
还原数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-22 1279
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递归/分治/动态规划/贪心算法)总结 目录 相关文章 数据结构的最强学习路线之问题为导向的十大类刷题算法总结 一、学习相关的讲解与刷题平台 二、刷题集合 三、常见的十大类考试题型 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组
Java基础数组详解2
createcoder的博客
04-14 1053
数组目录八：数组的使用练习普通for循环练习：重点练习（数组作为方法入参 数组作为返回值 增强for循环）：内容讲解： 重点理解代码内容 增强for循环 JDK1.5 增强for循环没有下标 array 表明数组下标值的命名 arrays 表明数组 所有对于打印数组哪个下标的值 增强for循环就不适合（增强for循环适合打印数组的结果）数组作为返回值可以通过反转数组方法（reverse方法）来描述 重点：数组的长度arrays.length 永远比数组最后一个的arrays[max]中的max大于
Arrays类讲解
qq_59572766的博客
08-29 124
Arrays类 数组的工具类java.tuil.Arrays （自己写数组，不需要后面输出） 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据进行一些基本操作 查看JDK帮助文档 Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用（注意不是不能） package com.zhong.array; import java.tuil.Arrays; public class D
java array 方法_Java的Arrays方法分析
weixin_31759829的博客
02-16 270
文章结构概览本文将按一下顺序，逐一介绍。Arrays类介绍Arrays方法分类排序相关查找相关比较相关打印相关计算hashCode拷贝相关赋值相关转化为集合List1. Arrays类介绍This class contains various methods for manipulating arrays (such assorting and searching). This class als...
Java入门基础知识第八课（数组）——冒泡排序、Arrays工具类
weixin_63511098的博客
04-09 1238
前面二白讲了关于数组的概念、语法以及简单的输入输出，实际上关于数组的知识还有很多，接下来咱们讲一下冒泡排序以及一些常用的Arrays工具类，需要记忆的知识很多，而且容易混淆。
Java进阶（第六期）： Arrays类（数组工具）、冒泡排序、选择排序、二分查找、【正则表达式】、Java正则爬取信息
Forever_Hopeful的博客
12-24 1065
Java进阶（第六期）： Arrays类（数组工具）、冒泡排序、选择排序、二分查找、【正则表达式】、Java正则爬取信息
数组（全部）
m0_57724479的博客
08-24 96
数组全部
【狂神说Java笔记】Java数组
qq_41047516的博客
09-13 279
【狂神说Java笔记】Java数组
java快速学习（数组，OOP）
prague6695的博客
06-29 150
系列文章目录 一个类里面只能有一个public ， 可以有多个class 文章目录系列文章目录Java数组01 什么是数组02 数组的声明和创建03 三种初始化及内存分析04 下标越界及小节05 数组的使用06 二维数组07 Arrays类讲解08 冒泡排序09 稀疏数组面向对象编程00 什么是面向对象01 回顾方法的定义02 回顾方法的调用静态方法 和 非静态方法形参和实参值传递和引用传递03 类和对象的创建04 构造器详解05 创建对象内存分析06 简单小节类和对象07 封装详解08 什么是继承09 S
Java 冒泡排序 并与 Arrays.sort(arr) 比较
胡萧徒的博客
11-30 5202
前段时间收到一个猎头电话面试,问了关于冒泡排序的.我居然一时间想不起来... 只是回答了,大概俩个for循环什么的... 今天想起来,复习下:        jdk 1.8.0_181 package review; import java.util.Arrays; public class Jacktu{ public static void bubble_sort(int[] a...
冒泡排序及Arrays类的概述和常用方法
wangkexiang21的博客
04-12 171
Arrays类包含用于操作数组的各种方法，最常用的有： public static String toString(int [] arr) 返回指定数组的内容的字符串表示形式 public static void sort(int [] arr) 按照数字顺序排列指定的数组 用法：Arrays.toString(arr); Arrays.sort(arr); 工具类的设计思想： 构造方法用private修饰，使其不能创建对象 成员用 pub...
Class -- 02 -- Arrays类常用方法解析
热门推荐
Gene Xu
07-13 2万+
这次主要整理下Java中Arrays类的常用方法 一、Arrays类的定义
java中Arrays类的讲解
bugcat的博客
03-29 1108
java中Arrays类的讲解 介绍 在java.util中有一个Arrays类，此类包含用于操纵数组的各种方法，例如：二分查找（binarySearch）、拷贝操作（copyOf）、比较(equals)、填充(fill)、排序（sort）等，功能十分强大。 相关函数讲解 1.binarySearch 代码： public static void main(String[] args) { ...
Java中的Arrays类使用详解
04-27 2万+
首先先创建一个打印数组的方法，方便后面直接使用public static void output(int []a) { for(int i=0;i<a.length;i++) { System.out.printf(a[i]+" "); } System.out.println(); }1、填充数组：filleg1.int []
数据结构-归并排序笔记
2302_80490510的博客
11-06 485
归并排序(MERGE-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。时间复杂度：O(N*logN)空间复杂度：O(N)稳定性：稳定。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 242
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 360
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
JAVA-01-变量
LJH_laura_li的博客
11-08 488
在方法、构造函数或块内部定义的变量。
Java数组之Arrays类操作数组之数组排序
10-17
`java.util.Arrays`是一个内置的工具类，它提供了一系列方便的方法用于处理数组，包括对数组进行排序。如果你想对数组之数组（二维数组或嵌套数组）进行排序，你可以通过以下步骤： 1. 获取`Arrays`类的对象实例。 2. 使用`sort()`方法，如果数组是一维的，直接传入需要排序的数组即可。例如： ```java int[] oneDimensionalArray = {5, 2, 9, 1}; Arrays.sort(oneDimensionalArray); ``` 3. 对于二维数组，你需要先获取内部数组的引用，然后传递给`sort()`方法。假设有一个`int[][]`类型的二维数组： ```java int[][] twoDimensionalArray = {{4, 3}, {6, 1}, {2, 5}}; for (int[] innerArray : twoDimensionalArray) { Arrays.sort(innerArray); } ``` 4. 如果你想按照特定列进行排序（比如按第一个元素），可以创建一个新的数组，只包含那一列的值，再进行排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值