数组笔记，

最新推荐文章于 2024-07-21 13:38:21 发布
最新推荐文章于 2024-07-21 13:38:21 发布
阅读量31 收藏
点赞数
文章标签： 算法 java leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73988934/article/details/130069018
版权

数组

1，数组概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-12jqvc53-1681129533087)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-03_20-51-15.png)]

2，数组声明创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WXtuyD1R-1681129533089)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-03_20-55-23.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5IUmk47I-1681129533090)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-03_21-11-23.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ew68t0w5-1681129533090)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-03_21-16-57.png)]

package array;

public class Demo01 {
    public static void main(String[] args) {
        //求10个数的和；
        int[] 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;
        int sum=0;
        for (int i=0;i<nums.length;i++) {
            sum = sum + nums[i];
        }
        System.out.println("总和为：" + sum);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LVmtmVs2-1681129533091)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-03_21-30-50.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vl1uvaVj-1681129533091)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_18-59-40.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MkknfjnS-1681129533092)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-11-08.png)]

package array;

public class Demo02 {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5,6};
        System.out.println(a[2]);
        System.out.println("==========================");
        int [] b = new int[5];
        b[0] = 2;
        b[1] = 3;
        //如果没有定义初始值，数组会默认为0；
        System.out.println(b[1]);
        System.out.println(b[2]);

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-axr2qpwC-1681129533093)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-17-42.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IzVkyty3-1681129533094)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-20-37.png)]

3，数组使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eYMUnM0Y-1681129533094)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-24-23.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tJpNpIUt-1681129533095)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-24-33.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o6uKHgif-1681129533096)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-29-39.png)]

package array;

public class Demo03 {
    public static void main(String[] args) {
        int [] array ={1,2,3,4,5,6};//输出数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("==============");
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum +array[i];
        }
        System.out.println("sum="+sum);//求数组的和
        System.out.println("===============");
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
        if(max<array[i]){
            max = array[i];
            }
        }
        System.out.println("max="+max);//求数组最大值
    }
    
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IpxzyQvx-1681129533098)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-42-31.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F82rDrCD-1681129533099)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_19-41-52.png)]

package array;

public class Demo04 {
    public static void main(String[] args) {
         int [] array = {1,2,3,4,5,6};
        for (int j : array) {
            System.out.println(j);//增强式For循环，适用于打印东西,而且没有下标。

4，多维数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nH2u9uTw-1681129533100)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_20-50-20.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yLvw5SDb-1681129533101)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-04_20-58-15.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T5akPAOd-1681129533102)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-06_18-23-36.png)]

package array;

public class Demo05 {
    public static void main(String[] args) {
        int [][] array = {{1,2},{3,4},{5,6}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);

            }


        }
    }
}

5，Arrays类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ymxxRw58-1681129533103)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-06_18-30-27.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VaVBjf2w-1681129533104)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_19-22-44.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CPJ2fiij-1681129533104)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_19-24-33.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPxiCKUa-1681129533105)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_19-28-10.png)]

	package array;
import java.util.Arrays;
public class Demo06 {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,35,653,3423,52,42};
        System.out.println(a);//[I@4eec7777
        System.out.println( Arrays.toString(a));//输出数组
        printArrays(a);//调用自己写的方法
        Arrays.sort(a);//数组排序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2   ,4,0);//数组填充
        System.out.println(Arrays.toString(a));
    }
    public static void printArrays(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]+", ");
            }
        }
        }
    }

冒泡排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hzb7SWJN-1681129533106)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_19-29-13.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SFBrkpMe-1681129533107)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_20-04-35.png)]

package array;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int [] a = {1,3,4,7,6,23,43,13,645,67,88 };//从小到大排序；
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    public static int [] sort(int [] a){
        int temp = 0;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j <a.length-1-i ; j++) {
                if(a[j+1]>a[j]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;

                }
            }
        }
        return a;
    }

}

6，稀疏数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FcU8D5my-1681129533108)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_20-25-12.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nlGlML6l-1681129533109)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_21-17-39.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JZmZYQcx-1681129533110)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_21-19-20.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-APMCwVfj-1681129533110)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_21-20-46.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PPqiMwUU-1681129533111)(D:/ksjava/%E7%8B%82%E7%A5%9Ejava%E8%B5%84%E6%96%99%E5%9B%BE/Snipaste_2023-04-07_21-22-06.png)]

package array;

public class Demo08 {
    public static void main(String[] args) {
        //创建一个二维数组10*10，
        int [] [] a1 = new int [10] [10];
        a1 [1][2]=6;
        a1 [2][3]=8;
        //输出二维数组；
        System.out.println("输出原始数组");
        for (int[] ints : a1) {
            for(int anInt :ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println( "===================");
        //转化为稀疏数组保存
        //获取有效值得个数
        int sum =0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(a1[i][j]!=0){
                    sum++;
                }
            }
            
        }
        System.out.println("有效值个数："+sum);

        //创建一个稀疏数组的数组；
        int [][] a2 = new int[sum+1][3];
        a2[0][0]=10;
        a2[0][1]=10;
        a2[0][2]=sum;
        //遍历二维数组，将非零值放入稀疏数组中；
        int count = 0;
        for (int i = 0; i <a1.length ; i++) {
            for (int j = 0; j <     a1[i].length; j++) {
                if (a1[i][j]!=0){
                    count++;
                    a2[count][0]=i;
                    a2[count][1]=j;
                    a2[count][2]=a1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 1; i < a2.length; i++) {
            System.out.println(a2[i][0]+"\t"
                    +a2[i][1]+"\t"
                    +a2[i][2]+"\t");
        }
        System.out.println("=================");
        System.out.println("还原");
        //读取稀疏数组
        int [][] a3 = new int[a2[0][0]][a2[0][1]];
        //给其中的元素还原其中的值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]]=a2[i][2];
        }
        //打印
        System.out.println("输出还原数组");
        for (int[] ints : a1) {
            for(int anInt :ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}
雪热了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
javascript数组笔记1
08-08
在本篇笔记中，我们将深入探讨数组的一些关键方法，包括添加、删除、排序以及转换和操作数组元素的方法。 1. **添加元素** - `push()` 方法用于向数组的末尾添加一个或多个元素，并返回新的数组长度。例如，`...
js基础数组笔记.docx
04-15
js基础数组笔记.docx
Java数组笔记
m0_73692315的博客
11-29 171
数组和方法
java数组笔记
wang1490975886的博客
03-12 614
Java： 数组 数组：储存相同类型的集合。 数组的创建和初始化 类型名 [ ] 数组名=new 类型名[数组长度]； 初始化分为动态初始化和静态初始化。 动态初始化：直接指定数组中的元素个数。 静态初始化：不指定具体的元素个数，直接将具体的内容进行指定。 注意：静态初始化虽然没有设置具体的数组大小，但是会按照{}中的元素个数设置数组长度。 静态和动态初始化也可以分为两步，但是格式不能省略。 如果没有对数组中的元素初始化则有默认值： 如果数组中的数据类型是引用数据类型
DaVinci 创建结构体数组 笔记
YELL_DOLL的博客
01-15 652
设置元素 （看需求）这里设置u8。引用刚才创建的结构体。
c语言数组笔记
m0_75170685的博客
05-06 865
所谓的变长数组指的是数组的大小是可以使用变量的，在c99之前，数组的大小是用常量或常量表达式的，在c99之后，数组的 大小是可以使用变量的，但是在vs中，暂且不支持数组使用变量，在vscode中可以。举个例子，比如1个int类型的数据是占4个字节，当我们知道数组元素共占多少内存空间时，用总空间大小除以这个数组所存放的数据类型大小，就可以得到这个数组一共有多少个元素。数组也是有类型的，它属于自定义类型，它的类型主要取决于数组的大小，去掉数组名就是数组的类型。(数组的大小是多少，数组里就存放多少个元素)
C语言——数组笔记（1）
weixin_42015918的博客
11-17 163
出现上述原因： 数组作为返回值时，确实可以返回数组首元素的地址，但是函数结束后，数组的空间就会被释放，所以再次访问数组的内容时，就会有可能访问不到原来的数组。 解决方案： ①将数组设置为全局变量； ②在数组定义前面加static关键词进行修饰。 ...
【C语言】数组 笔记
qq_42995393的博客
05-30 602
数组传参只会传数组首元素的地址，所以如果在函数内计算数组大小，大小为4字节，等于首元素的大小。若为字符串（ch4）数组前三位值为abc, 第四位为\0，剩余为0。仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）若直接初始化为字符（ch3），前三位为abc，其余为0。因为数组在内存中连续存放，若不规定列的数量，访问时则无法计算坐标。可完全初始化或者不完全初始化，若不完全初始化，剩余元素默认为0。
C语言--数组笔记
2302_80250536的博客
12-09 614
一.数组的概念一.数组的概念数组是⼀组相同类型元素的集合。•数组中存放的是1个或者多个数据，但是数组元素个数不能为0。•数组中存放的多个数据，类型是相同的。数组的元素都是内置类型的，如果我们把，这时候就是，⼆维数组作为数组元素的数组被称为三维数组，⼆维数组以上的数组统称为多维数组。二.一维数组2. 1⼀维数组的创建和初始化2.1.1数组创建⼀维数组创建的基本语法如下：存放在数组的值被称为，数组在创建的时候可以指定和类型。•type指定的是数组中，可以是：char。
数组笔记【一】
m0_73850645的博客
12-25 791
2.数组创建时，在C99标准前，数组大小[]内给定一个常量才可以，不能使用变量。而C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但数组不能初始化。a2没有'\0'没有结束标志，所以我们只能在后面的内存中寻找'\0'来充当结束的标志。通过监视窗口可以看出，a1后面会补上a[3]='\0',也就是说a1有结束的标志。二维数组常规的使用大家已经清楚了，今天就讲一讲二维数组有关指针调用的方法。我们知道strlen可以计算字符数组的长度那么整型数组应该怎么计算呢。一堆数组在内存中存放是连续存放的。
数组笔记代码
Alex_YueLi的博客
01-05 351
【代码】数组笔记代码。
vector实现二维数组笔记
weixin_53432918的博客
07-31 1149
row：行，col：列。
初学不久js中数组笔记.md
08-05
初学不久js中数组笔记.md
利用for循环把遍历数组中的元素依次获取出来 数组笔记及基本知识点.pdf
05-20
本篇笔记主要探讨如何利用for循环遍历数组中的元素，并介绍一些与数组相关的知识点。 首先，我们要明白数组的基本概念。数组是一种线性数据结构，它允许我们在一个单一的变量中存储多个值。在JavaScript中，数组...
PHP学习笔记之数组篇
12-18
一、如何定义数组：在ＰＨＰ中创建数组主要有两种方式，下面就让我们来看看如何创建一个数组 （1）直接给每个元素赋值的方法创建数组。 格式为：$arrayname[key]=value; 其中arrayname为数组的名字，key为数组的元素...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 220
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
AtCoder Beginner Contest 363
最新发布
2301_80105412的博客
07-21 377
AtCoder Beginner Contest 363 ABCDE
排序思想-快排
m0_58257626的博客
07-17 394
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 281
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
JavaScript进阶笔记：数据类型、数组、对象与DOM操作详解
接着，它特别关注了数组(Array)，这是集合数据结构，可用于存储一组有序的值，支持各种操作如索引、推导等。 2. **对象和类**：对象是JavaScript中的核心概念，它不仅包括键值对（属性和方法），还讨论了如何创建和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值