数组与排序

最新推荐文章于 2024-05-11 15:07:54 发布
最新推荐文章于 2024-05-11 15:07:54 发布
阅读量62 收藏
点赞数
分类专栏： Java笔记 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33254911/article/details/132110649
版权

文章目录

一维数组

什么是数组

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致
总结，存放数据，长度和类型是固定的

数组的定义格式

格式一

数据类型[] 数组名;

int[] arr;        
double[] arr;      
char[] arr;

格式二

数据类型 数组名[];

int arr[];
double arr[];
char arr[];

数组初始化

数组动态初始化

什么是动态初始化

动态数组初始化就是只给定数组的长度，由系统给出默认初始化值

动态初始化格式
数据类型[] 数组名 = new 数据类型[长度];

int[] arr = new int[3];

System.out.println(arr);//[I@1540e19d

//访问数组元素格式
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
动态初始化格式详解

  • 等号左边

    • int:数组的数据类型

    • []:代表这是一个数组

    • arr:代表数组的名称

  • 等号右边

    • new:为数组开辟内存空间

    • int:数组的数据类型

    • []:代表这是一个数组

    • 3:代表数组的长度

数组静态初始化

什么是静态初始化

在创建数组时，直接将元素确定，由系统计算出数组的长度

静态初始化格式

  • 完整版格式

    数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

  • 简化版格式

    数据类型[] 数组名 = {元素1,元素2,...};

数组元素访问

什么是索引

每一个存储到数组的元素都会自动拥有一个编号，从0开始。
这个自动编号称为数组索引，可以通过数组索引访问到数组中的元素

访问数组元素格式

数组名[索引];

内存分配

内存分配时计算机中的重要原件，临时存储区域，作用是运行程序
我们编写的程序时存放在硬盘中的，在硬盘中的程序是不会运行的
必须放在内存中才能运行，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理

Java中的内存分配

栈内存和堆内存

区域名称作用
寄存器给CPU使用，和我们开发无关。
本地方法栈JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区存储可以运行的class文件。
堆内存存储对象或者数组，new来创建的，都存储在堆内存。
栈内存方法运行时使用的内存，比如main方法运行，进入方法栈中执行，局部变量都在栈内存中。

数组内存图

  • 单个数组内存图
    在这里插入图片描述

  • 多个数组内存图
    在这里插入图片描述

  • 多个数组指向相同内存图
    在这里插入图片描述

数组操作的俩个常见小问题

索引越界异常

  • 出现原因

    public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

    数组长度为3，索引范围时0~2，访问的3索引不存在
    程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常

  • 解决方案

    将错误的索引修改为正确的索引即可

空指针异常

  • 出现原因

    public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

    arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。

  • 解决方案

    给数组一个真正的堆内存空间引用即可！

二维数组

什么是二维数组

二维数组其实就是这个二维数组中有多个一位数组，每个一维数组有自己的元素

二维数组格式

格式一

数据类型[][] 变量名 = new 数据类型[m][n];
  • 格式解释
    • m表示这个二维数组有多少个一维数组
    • n表示每一个一维数组的元素个数

格式二

数据类型[][] 变量名 = new 数据类型[m][];
  • 格式解释
    • m表示这个二维数组有多少个一维数组
    • 这一次没有直接给出一维数组的元素个数，可以动态的给出

格式三

标准版：
	数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版：
	数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

二维数组遍历

public class ArrayCase {
    public static void main(String[] args) {
       
        // 定义二维数组
        int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}};

        //遍历第一个一维数组
        for(int x =0; x<arr[0].length; x++){
            System.out.println(arr[0][x]);
        }
        System.out.println("=====================");

        //遍历第二个一维数组
        for(int x =0; x<arr[1].length; x++){
            System.out.println(arr[1][x]);
        }
        System.out.println("=====================");

        //遍历第三个一维数组
        for(int x =0; x<arr[2].length; x++){
            System.out.println(arr[2][x]);
        }
        System.out.println("=====================");

        //用户循环改进y
        for (int y = 0; y <arr.length ; y++) {
            for(int x =0; x<arr[y].length; x++){
                System.out.println(arr[y][x]);
            }
            System.out.println();
        }
    }
}

数组的排序与查找

冒泡排序

在这里插入图片描述

/*
 * 数组之冒泡排序
 *      相邻元素两两比较，大的往后放，第一次完毕，最大值出现在最大索引位置
 */
public class maobao {

	public static void main(String[] args) {

        int[] arr = { 24, 67, 80, 57, 13 };

        /*
            第一次比较
                arr.length -1: 因为是两两比较，最后一个没有元素比较所有-1
         */
        for(int x = 0; x< arr.length -1 -0; x++){
            if(arr[x] > arr[x+1]){
               int temp = arr[x];
                arr[x]  = arr[x+1];
                arr[x+1] = temp;
            }
        }

        /*
            第二次比较
                arr.length -1-2：因为每一次比较都是把最大值放在最大索引处，减少最后元素也是最大索引比较
         */
        for(int x = 0; x< arr.length -1-1; x++){
            if(arr[x] > arr[x+1]){
                int temp = arr[x];
                arr[x]  = arr[x+1];
                arr[x+1] = temp;
            }
        }
        //第三次比较
        for(int x = 0; x< arr.length -1-2; x++){
            if(arr[x] > arr[x+1]){
                int temp = arr[x];
                arr[x]  = arr[x+1];
                arr[x+1] = temp;
            }
        }

        //第四次比较
        for(int x = 0; x< arr.length -1-3; x++){
            if(arr[x] > arr[x+1]){
                int temp = arr[x];
                arr[x]  = arr[x+1];
                arr[x+1] = temp;
            }
        }

        System.out.println("=============以上比较了4次=============");

        for (int i = 0; i < 4; i++) {
            for(int x = 0; x< arr.length -1- i; x++){
                if(arr[x] > arr[x+1]){
                    int temp = arr[x];
                    arr[x]  = arr[x+1];
                    arr[x+1] = temp;
                }
            }
        }

        System.out.println("===========今后比较多少次未知===============");
        for (int i = 0; i < arr.length -1; i++) {
            for(int x = 0; x< arr.length -1- i; x++){
                if(arr[x] > arr[x+1]){
                    int temp = arr[x];
                    arr[x]  = arr[x+1];
                    arr[x+1] = temp;
                }
            }
        }

        //实现遍历
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.println(arr[x] + "]");
            } else {
                System.out.print(arr[x] + ",");
            }
        }

    }
}

选择排序

在这里插入图片描述

/**
 * 选择排序： 从0索引开始，依次和后面元素比较，小的放前面，第一次完毕，最小值出现在最小索引处
 */
public class ArrayDemo {

	public static void main(String[] args) {

        int[] arr = { 24, 69, 80, 57, 13 };

        /*// 第一次比较
        int x = 0; //代表第一个
        for(int y = x+1; y< arr.length; y++){ //代表后面的面的元素
            if(arr[y] < arr[x]){ //交换位置
                int temp = arr[x];
                arr[x] =  arr[y];
                arr[y] = temp;
            }
        }

        // 第二次比较
        x = 1; //代表第一个
        for(int y = x+1; y< arr.length; y++){ //代表后面的面的元素
            if(arr[y] < arr[x]){ //交换位置
                int temp = arr[x];
                arr[x] =  arr[y];
                arr[y] = temp;
            }
        }

        // 第三次比较
        x = 2; //代表第一个
        for(int y = x+1; y< arr.length; y++){ //代表后面的面的元素
            if(arr[y] < arr[x]){ //交换位置
                int temp = arr[x];
                arr[x] =  arr[y];
                arr[y] = temp;
            }
        }

        // 第四次比较
        x = 3; //代表第一个
        for(int y = x+1; y< arr.length; y++){ //代表后面的面的元素
            if(arr[y] < arr[x]){ //交换位置
                int temp = arr[x];
                arr[x] =  arr[y];
                arr[y] = temp;
            }
        }*/

        System.out.println("==============循环改进===============");
        
        for (int x = 0; x < arr.length -1; x++) {
            for (int y = x + 1; y < arr.length; y++) {
                if(arr[y] < arr[x]){
                    int temp = arr[y];
                    arr[y] = arr[x];
                    arr[x] = temp;
                }
            }
        }


        //遍历
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i== arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }
}

二分查找

在这里插入图片描述

/*
 * 二分查找：
 * 		前提：是一个有序的数组
 * 		理解：折半查找
 * 分析：
 * 		1：定义最大索引，最小索引
 * 		2：计算出中间索引
 * 		3：拿中间索引的值和要查找的值进行比较
 * 			相等：就直返回当前的索引
 * 			不相等：
 * 				大了：左边找
 * 				小了：右边找
 * 		4：重新计算出中间的索引
 * 			大   左边找
 * 				max = mid - 1;
 * 			小  右边找
 * 				min = mid + 1;
 *       5:回到2继续
 */
public class ArrayErFen {
    public static void main(String[] args) {

		int[] arr = { 11, 22, 33, 44, 55, 66, 77 };

        // 要查找的元素
        int value = 33;

		// 定义最大索引，最小索引
		int max = arr.length - 1;
        int min = 0;

        // 计算出中间索引
        int mid = (max + min) / 2;

        // 拿中间索引的值和要查找的值进行比较
        while(arr[mid] != value){
        	if(value < arr[mid]){
            	max = mid -1;
            }else if(value > arr[mid]){
                    min = mid + 1;
            }
            // 重新计算出中间索引
            mid = (max + min) / 2;
        }
        System.out.println("查询的元素的索引是："+mid);
    }
}
BoatsZhou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java数组自定义排序
10-31
java中数组的自定义排序，种类繁多，简单实现，可自由操控。
JS数组对象排序
qq_37899792的博客
03-19 4万+
利用数组api ——> sort来进行排序 var person = [{name:"Rom",age:12},{name:"Bob",age:22},{name:"Ma",age:5},{name:"Tony",age:25}] person.sort((a,b)=>{ return a.age-b.age})//升序 person.sort((a,b)=>{ retu...
python数组排序方法详解（sort， sorted，argsort）
热门推荐
什么都干的派森
09-27 6万+
这三个排序方法应对日常工作基本够用 先说一下三者的区别 sort， sorted 是用在 list 数据类型中的排序方法 argsort 是用在 numpy 数据类型中的排序方法（ numpy 里也有一个 sort 方法，下面会讲） sort 和 sorted 的区别如下???? 先看两个简单的升序排序，分别使用 sorted 和 sort 方法 # sorted num_list = [1, 8, 2, 3, 10, 4, 5] ordered_list = sorted(num_list) print
指针数组的排序
码云仓库地址：https://gitee.com/lance-gyq
05-05 3432
指针数组的排序 选择排序 假设排序规则为从小到大 先认定一个最小值下标为i,通过j=i+1找的真实最小下标 判断计算出的真实最小下标和开始认定的i是否相等，如果不相等，交换i和min下标的两个元素 代码示例： #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> //从小到大 选择排序 void selectSort01(int arr[]
php 数组随机排序_php怎么实现数组随机排序
weixin_39978696的博客
03-08 1537
php数组随机排序，我们可以使用PHP shuffle()函数来实现。 PHP shuffle()函数表示随机调整数组中元素或值的顺序。该shuffle()函数FALSE失败时返回。下面我们就结合具体的代码示例，给大家介绍PHP数组元素随机化排序的方法。代码示例如下：首先我们通过range函数，创建一个范围从1到10的数组。...
Js中的数组排序
小太阳的博客
04-01 1万+
本文介绍了数组自带的sort方法以及冒泡排序、选择排序、快排以及插入排序 1.数组的sort() 默认情况下，sort() 方法将按字母和升序将值作为字符串进行排序。 注意: sort() 方法会改变原始数组。 如果想按照别的顺序进行排序，就必须提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数a和b，如果数组中的元素是数值类型，如果需要升序排序，那么就返回a - b;如果需要降序排序，那么就返回b-a; var oldArr = [19, 55
java给数组排序_java数组如何排序
weixin_34927903的博客
02-12 6295
java中几种数组排序的方法：1、使用Arrays.sort()排序Arrays.sort()排序方法在java中是最简单且最常用的排序方法。int []arr1= {45,34,59,55};Arrays.sort(arr1);//调用方法排序即可Arrays.sort()的使用主要分为对基本数据类型数组的排序和对对象数组的排序。2、冒泡排序简单来说，冒泡排序就是重复地走访过要排序的数列，一次比...
VBA数组的排序
qq_39660799的博客
09-13 6719
我们平时用的表格排序，只相对来说是在在表格中的升序降序。今天就好奇如果系统中实现排序 他是怎么实现的呢。 经过一番折腾查找，真是一看吓一跳，真是感觉蚂蚁看大象，发现排序分为： 今天仅整理了最简单的两种排序。。。 先来看下定义和实现的方法吧。 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据
数组排序sort方法
wenxiukeke的博客
12-10 9255
数组排序sort sort里面不加参数，默认是升序排序 let arr = [1, 8, 2, 9]; arr.sort(); console.log(arr); // [1, 2, 8, 9] 如果想要降序排序，可以加参数改变，如下所示： let arr = ['a', 'b', 'd', 'c']; arr.sort(function (a, b) { if(a > b){ re...
js:数组自定义排序
Cat的专栏
04-15 3350
写在前面：没想到我的一篇对IDE评论的文章，得到了十几条评论，真是惭愧。写的具体编程知识点的文章，倒是鲜有评论。~ 23333 数组中已经存在两个可以直接用来重排序的方法：reverse()和sort()。 reverse()方法用于反转数组。 默认情况下，sort()方法按升序排列数组项–即最小值在最前面，最大值在最后面。为了实现排序，sort()方法会调用每个数组项的to...
39.JQ数组排序
T_P_F的博客
11-30 1328
1.一维数组排序 a-b升序 b-a降序 var nums = ["1","4","3","10","5","8","0"] nums = nums.sort(function(a,b){ return a - b; }); 2.二维数组排序 a[i]-b[i]升序 b[i]-a[i]降序 var nums = [["1","张三1","A"],["4","张三2","B"],["4","张三3","C"],["10","张三4","D"],["5","...
java数组排序
09-04
java数组排序的思想，过程和代码实现。多种数组排序的方法，主要有冒泡排序，堆排序，插入排序， 归并操作(merge)， 归并操作(merge)，选择排序，希尔排序。
易语言利用数组进行数值排序
08-27
易语言利用数组进行数值排序，简单粗暴
php数组随机排序实现方法
10-24
主要介绍了php数组随机排序实现方法,涉及php数组随机排序函数shuffle的相关使用技巧,需要的朋友可以参考下
Perl基本数组排序方法介绍
09-21
主要介绍了Perl基本数组排序方法介绍,本文讲解基于ASCII码排序、比较函数、按字母顺序排列、Perl对数值排序等内容,需要的朋友可以参考下
class常量池、运行时常量池和字符串常量池详解
最新发布
weixin_44049823的博客
05-11 616
字符串常量池专门用于存储字符串常量。对于 Hotspot 虚拟机来说，类加载时，字符串字面量作为类常量池的一部分信息被载入运行时常量池中，它们以特殊的形式存储在运行时常量池中，此时它们并未被实例化为Java堆中的String对象。只有当这个字符串字面量被调用时，才会对其进行解析，即检查字符串常量池中是否已经存在相同内容的字符串对象。如果存在，就直接返回指向该对象的引用，如果不存在，虚拟机会在字符串常量池中创建一个对应的String实例，并返回这个新实例的引用。
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 150
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
java jar包如何运行或调用
NLP与推荐算法
05-08 235
java服务启动
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 299
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
数组排序与去重c++
08-14
数组排序与去重是C语言中常见的操作，可以用来对数组进行排序并去除重复元素。 数组排序可以使用多种排序算法来实现，如冒泡排序、插入排序、选择排序等。以下以冒泡排序为例进行说明。 冒泡排序的基本思想是依次...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BoatsZhou

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

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

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

打赏作者

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

抵扣说明：

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

余额充值