数组 (Array)

最新推荐文章于 2024-04-21 21:52:08 发布
最新推荐文章于 2024-04-21 21:52:08 发布
阅读量3.5k 收藏 38
点赞数 2
分类专栏： JavaSe 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/122981115
版权

1 数组的概念

1.1 数组的定义

数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先 后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标） 来访问它们。数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组变量属于引用类型，数组也是对象。

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

1.2 创建数组和初始化

数组的创建和初始化是数组使用的第一步，我们通过内存分析也让大家更深入的了解数 组。同时，通过内存分析更加明白数组的本质其实还是“对象”。

1.2.1 数组声明

数组的声明方式(以一维数组为例),代码如下：

type[ ] arr_name; // 方式一（推荐使用这种方式） 
type arr_name[ ]; // 方式二

注意事项：
1.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM 才分配空间，这时 才与长度有关。
2.声明一个数组的时候并没有数组真正被创建。 
3.构造一个数组，必须指定长度。

创建基本类型一维数组代码如下：

package com.txw.arrary;

/**
 * 创建基本类型一维数组
 * @author Adair
 * @date 2022/2/17 下午 1:15
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int [] s = null;   // 声明数组
        s = new int[10];   // 给数组分配空间
        for (int i = 0; i < 10; i++) {
            s[i] = 2 * i + 1;   // 给数组元素赋值； 数组是对象，数组中的元素就是对象的属性
            System.out.println(s[i]);
        }
    }
}

基本类型数组分配内存图，如图所示：在这里插入图片描述
创建引用类型一维数组的代码如下：

package com.txw.arrary;

class Man{
    private int age;
    private int id;

    public Man(int age, int id) {
        this.age = age;
        this.id = id;
    }
}
/**
 * 创建引用类型一维数组
 * @author Adair
 * @date 2022/2/17 0017下午 1:22
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class AppMain {
    public static void main(String[] args) {
        Man[ ] mans;    // 声明引用类型数组；
        mans = new Man[10];         // 给引用类型数组分配空间；
        Man m1 = new Man(1,11);
        Man m2 = new Man(2,22);
        mans[0]=m1;     // 给引用类型数组元素赋值；
        mans[1]=m2;     // 给引用类型数组元素赋值；
    }
}

引用类型数组内存分配图，如图所示：
在这里插入图片描述

1.2.2 初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。下面针对这三 种方式分别讲解。
1. 静态初始化
除了用 new 关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配 空间并赋值。
数组的静态初始化的代码如下：

package com.txw.arrary;

/**
 * 数组的静态初始化
 * @author Adair
 * @date 2022/2/17 下午 1:15
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int [ ] a = { 1, 2, 3 };        // 静态初始化基本类型数组；
        Man[ ] mans = { new Man(1, 1), new Man(2, 2) };     // 静态初始化引用类型数组；
    }
}

2.动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
数组的动态初始化的代码如下：

int[ ] a1 = new int[2];		// 动态初始化数组，先分配空间；
a1[0]=1;					// 给数组元素赋值；
a1[1]=2;					// 给数组元素赋值；

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

int a2[ ] = new int[2];					 // 默认值：0,0 
boolean[ ] b = new boolean[2]; 			// 默认值：false,false S
tring[ ] s = new String[2]; 			// 默认值：null, null

2 数组常见操作

数组创建后，我们经常需要对数组做两种最常见的操作：遍历、拷贝。
遍历指的就是“通过循环遍历数组的所有元素”。
拷贝指的是将某个数组的内容拷贝到另一个数组中。 实质上，后面大家学到的容器， 容器的扩容本质上就是“数组的拷贝”。

2.1 数组的遍历

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍 历时可以读取元素的值或者修改元素的值。
使用循环初始化和遍历数组的代码如下：

package com.txw.arrary;

/**
 * 使用循环初始化和遍历数组
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int [ ] a = new int[10];
        // 初始化数组元素的值
        for (int i = 0; i < a.length; i++) {
            a[i] = 100 * i;
        }
        // 读取元素的值
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

2.2 for-each 循环

增强 for 循环 for-each 是 JDK1.5 新增加的功能，专门用于读取数组或集合中所有的元 素，即对数组进行遍历。
使用增强for循环遍历数组的代码如下：

package com.txw.arrary;

/**
 * 使用增强for循环遍历数组
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
       String [] ss = {"aa","bbb","ccc","ddd"};
        for (String temp : ss) {
            System.out.println(temp);
        }
    }
}

注意事项：
1.for-each 增强 for 循环在遍历数组过程中不能修改数组中某元素的值。 
2.for-each 仅适用于遍历，不涉及有关索引（下标）的操作。

2.3 数组的拷贝

System 类里也包含了一个 static void arraycopy（object src，int srcpos，object dest， int destpos，int length）方法，该方法可以将 src 数组里的元素值赋给 dest 数组 的元素，其中 srcpos 指定从 src 数组的第几个元素开始赋值，length 参数指定将 src 数组 的多少个元素赋给 dest 数组的元素。
演示的代码如下：

package com.txw.arrary;

/**
 * 数组的拷贝
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        String[ ] s = {"阿里","学无止路","京东","搜狐","网易"};
        String[ ] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }
    }
}

执行结果为如图所示：在这里插入图片描述

2.4 java.util.Arrays 类

JDK 提供的 java.util.Arrays 类，包含了常用的数组操作，方便我们日常开发。Arrays 类包含了：排序、查找、填充、打印内容等常见的操作。
使用 Arrays 类输出数组中的元素代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 使用Arrays类输出数组中的元素
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] a = { 1, 2 };
        System.out.println(a); // 打印数组引用的值
         System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}

执行的结果如图所示：在这里插入图片描述

菜鸟雷区
此处的 Arrays.toString()方法是 Arrays 类的静态方法，不是前面讲的 Object 的 toString() 方法。

使用 Arrays 类对数组元素进行排序一的代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 使用Arrays类对数组元素进行排序一
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

执行的结果如图所示：在这里插入图片描述
使用Arrays类实现二分法查找法，代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 使用Arrays类实现二分法查找法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a); // 使用二分法查找，必须先对数组进行排序;
        System.out.println(Arrays.toString(a)); // 返回排序后新的索引位置,若未找到返回负数。
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
    }
}

使用 Arrays 类对数组进行填充，代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 使用Arrays类对数组进行填充
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] a= {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100); // 将2到4索引的元素替换为100;
        System.out.println(Arrays.toString(a));
    }
}

执行的结果如图所示：在这里插入图片描述

2.5 Comparable 接口

想对某个类的对象之间做比较，就需要实现 Comparable 接口。接口中只有一个方法 compareTo，这个方法定义了对象之间的比较规则。 依据这个“比较规则”，我们就能对 所有对象实现排序。
事实上，java 中排序算法的底层也依赖 Comparable 接口。 C
omparable 接口中只有一个方法：

 public int compareTo(Object obj) obj 为要比较的对象

方法中，将当前对象和 obj 这个对象进行比较，如果大于返回 1，等于返回 0，小于返 回-1. (此处的 1 也可以是正整数，-1 也可以是负整数)。 compareTo 方法的代码也比较 固定，案例如下：

public int compareTo(Object o) {
	Man man = (Man) o; 
	if (this.age < man.age) { 
		return -1; 
	}
	if (this.age > man.age) { 
		return 1;
	}
	return 0;
}

使用 Arrays 类对数组元素进行排序二的代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 使用Arrays类对数组元素进行排序二
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        Man[ ] msMans = { new Man(3, "a"), new Man(60, "b"), new Man(2, "c") };
        Arrays.sort(msMans);
        System.out.println(Arrays.toString(msMans));
    }
}
class Man implements Comparable {
    int age;
    int id;
    String name;

    public Man(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public String toString() { 
        
        return this.name; 
    }
    public  int compareTo(Object o) { 
        Man man = (Man) o; 
        if (this.age < man.age) {
            return -1; 
        }
        if (this.age > man.age) {
            return 1;
        }
        return 0;
    }
}

执行的结果如图所示：
在这里插入图片描述

3 多维数组

3.1 多维数组

多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实 际开发中用的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都 很少）。
二维数组的声明代码如下：

package com.txw.arrary;

/**
 * 二维数组的声明
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args){
        // Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[ ][ ] a = new int[3][ ];
        a[0] = new int[2]; 
        a[1] = new int[4]; 
        a[2] = new int[3];
        // int a1[ ][ ]=new int[ ][4];      // 非法
    }
}

二维数组的静态初始化代码如下：

package com.txw.arrary;

/**
 * 二维数组的静态初始化
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args){
        int[ ][ ] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } }; 
        System.out.println(a[2][3]);
    }
}

内存分配图：在这里插入图片描述
二维数组的动态初始化的代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 二维数组的动态初始化
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args){
        int[ ][ ] a = new int[3][ ];
        // a[0] = {1,2,5};      // 错误，没有声明类型就初始化
        a[0] = new int[ ] { 1, 2 }; 
        a[1] = new int[ ] { 2, 2 }; 
        a[2] = new int[ ] { 2, 2, 3, 4 };
        System.out.println(a[2][3]);
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}

执行的结果为如图所示：在这里插入图片描述
获取数组长度的代码如下：

package com.txw.arrary;

/**
 * 获取数组长度
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args){
        int[ ][ ] a = new int[3][5];
        //获取的二维数组第一维数组的长度。
        System.out.println(a.length);
        // 获取第二维第一个数组长度。
        System.out.println(a[0].length);
    }
}

3.2 数组存储表格数据

表格数据模型是计算机世界最普遍的模型，可以这么说，大家在互联网上看到的所有数 据本质上都是“表格”，无非是表格之间互相套用。如下表格是一张雇员表：在这里插入图片描述
我们观察表格，发现每一行可以使用一个一维数组存储：

Object[ ] a1 = {1001,"Adair",25,"开发工程师","2018-7-30"}; 
Object[ ] a2 = {1002,"Mars",28,"开发工程师","2016-8-12"};
Object[ ] a3 = {1003,"Kevin",33,"开发工程师","2012-1-10"};

注意事项：
1.此处基本数据类型”1001”，本质不是 Object 对象。JAVA 编译器会自动把基本数据 类型“自动装箱”成包装类对象。大家在下一章学了包装类后就懂了。

这样我们只需要再定义一个二维数组，将上面 3 个数组放入即可：

 Object[ ][ ] emps = new Object[3][ ]; 
 emps[0] = a1;
 emps[1] = a2;
 emps[2] = a3;

使用二维数组保存表格数据的代码如下：

package com.txw.arrary;

import java.util.Arrays;

/**
 * 使用二维数组保存表格数据
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args){
        Object[ ] a1 = {1001,"Adair",25,"开发工程师","2018-7-30"};
        Object[ ] a2 = {1002,"Mars",28,"开发工程师","2016-8-12"};
        Object[ ] a3 = {1003,"Kevin",33,"开发工程师","2012-1-10"};
        Object[ ][ ] emps = new Object[3][ ];
        emps[0] = a1;
        emps[1] = a2;
        emps[2] = a3;
        System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));
    }
}

执行的结果如图所示：
在这里插入图片描述
使用javabean和一维数组保存表格信息。代码如下：

package com.txw.arrary;

/**
 * 使用javabean和一维数组保存表格信息
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args){
        Emp[] emps = {
                new Emp(1001, "Adair", 25, "开发工程师", "2018-7-30"),
                new Emp(1002,"Mars",28,"开发工程师","2016-8-12"),
                new Emp(1003,"Kevin",33,"开发工程师","2012-1-10")
        };
        for (Emp emp : emps) {
            System.out.println(emp);
        }
    }
}
class Emp {
    private int id;
    private String name;
    private int age;
    private String job;
    private String hiredate;

    public Emp(int id, String name, int age, String job, String hiredate) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.job = job;
        this.hiredate = hiredate;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", hiredate='" + hiredate + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getHiredate() {
        return hiredate;
    }

    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}

4 常见算法

本节课讲解冒泡排序、二分法查找（折半查找）等常见的算法。大家如果想更好的理解， 可以看这个网站（上面可以根据程序执行看到动画效果）：
https://visualgo.net/en
这个网站汇聚了各种算法，可以用程序和动画结合的方式学习，大家想详细 理解算法，可以借助这个网站。如图所示：
在这里插入图片描述

4.1 冒泡排序算法

冒泡排序是最常用的排序算法，在笔试中也非常常见，能手写出冒泡排序算法可以说是 基本的素养。本节讲解冒泡的基础算法和优化算法，既提高大家算法的素养，也可以从容面 对找工作时 JAVA 的笔试题目。

4.1.1 冒泡排序的基础算法

冒泡排序算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就 把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。 冒泡排序算法的运作如下：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最 后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
大家可以用如上思想，将下面的人按照身高从低到高重新排列：在这里插入图片描述
冒泡排序的基础算法的代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 冒泡排序的基础算法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
        bubbleSort(values);
        System.out.println(Arrays.toString(values));
    }

    private static void bubbleSort(int[] values) {
        int temp;
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < values.length - 1 - i; j++) {
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                }
            }
        }
    }
}

执行的结果如图所示：在这里插入图片描述

4.1.2 冒泡排序的优化算法

其实，我们可以把7.6.1的冒泡排序的算法优化一下，基于冒泡排序的以下特点：
1.整个数列分成两部分：前面是无序数列，后面是有序数列。
2.初始状态下，整个数列都是无序的，有序数列是空。
3.每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加 1），也就是不用再去顾及有序序列。
4.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到 无序数列的末尾即可（而不是数列的末尾）；如果前一个大于后一个，交换。
5.判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序， 无需再进行后续趟数的比较了。此时可以中止比较。
冒泡排序的优化算法,的代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 冒泡排序的优化算法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
        bubbleSort(values);
        System.out.println(Arrays.toString(values));
    }

    private static void bubbleSort(int[] values) {
        int temp;
        int i;
        // 外层循环：n个元素排序，则至多需要n-1趟循环
        for (i = 0; i < values.length - 1; i++) {
            // 定义一个布尔类型的变量，标记数组是否已达到有序状态
            boolean flag = true;
            /*内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序 数组的最后*/
            for (int j = 0; j < values.length - 1 - i; j++) {
                // 如果前一个元素大于后一个元素，则交换两元素的值；
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                    // 本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
                    flag = false;
                }
            }
            // 根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
            if (flag) {
                break;
            }
        }
    }
}

执行的结果如图所示：在这里插入图片描述

4.2 二分法查找

二分法检索（binary search）又称折半检索，二分法检索的基本思想是设数组中的元 素从小到大有序地存放在数组（array）中，首先将给定值 key 与数组中间位置上元素的关键码(key)比较，如果相等，则检索成功；
否则，若 key 小，则在数组前半部分中继续进行二分法检索;
若 key 大，则在数组后半部分中继续进行二分法检索。
这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。 二分法检索是一种效率较高的检索方法。比如，我们要在数组[7, 8, 9, 10, 12, 20, 30, 40, 50, 80, 100]中查询到 10 元素，过程如下：在这里插入图片描述
二分法查找法的基本算法，的代码如下：

package com.txw.arrary;

import java.util.Arrays;
/**
 * 二分法查找法的基本算法
 * @author Adair
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   //注解警告信息
public class Test {
    public static void main(String[] args) {
        int[ ] arr = { 30,20,50,10,80,9,7,12,100,40,8};
        int searchWord = 20; // 所要查找的数
        Arrays.sort(arr); // 二分法查找之前，一定要对数组元素排序
        System.out.println(Arrays.toString(arr));
        System.out.println(searchWord+"元素的索引： "+binarySearch(arr,searchWord));
    }

    public static int binarySearch(int[ ] array, int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int middle = (low + high) / 2;
            if(value == array[middle]){
                return middle; // 返回查询到的索引位置
            }
            if(value > array[middle]){
                low = middle + 1;
            }
            if(value < array[middle]){
                high = middle - 1;
            }
        }
        return -1; // 上面循环完毕，说明未找到，返回-1
    }
}

执行的结果如图所示：在这里插入图片描述

学无止路
关注
  • 2
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
vbscript基础篇 - vbs数组Array的定义与使用方法
08-27
vbscript基础篇 - vbs数组Array的定义与使用方法 VBScript中的数组是一种非常重要的数据类型，它允许开发者存储和操作多个值。下面将详细介绍VBScript中的数组的定义和使用方法。 数组的定义 在VBScript中，数组...
JAVA中一维数组的简单使用！
qq_45620589的博客
12-15 1154
JAVA中一维数组的简单使用！ 一、数组的概述 1.数组的常见概念： 数组名 下标(或索引) 元素 数组的长度 2. 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 3. 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度...
数组 Array (全世界最详细的数组解释）
Miketutu的博客
01-16 6456
数组 Array (全世界最详细的数组解释）
C语言中数组的分类
最新发布
a15884871479的博客
04-21 1455
文仅仅简单介绍了C语言的数组，祝愿你我的朋友在学习的路上一帆风顺，也祝愿我会成为一个优秀的嵌入式工程师。
数组（超详细）
m0_62420605的博客
10-17 6396
数组（必须掌握的）
详细讲解 —— 数组（C语言初阶）
IT_Infector的博客
09-05 2233
本文主要讲解：一维数组（创建、初始化、使用、储存），二维数组（创建、初始化、使用、储存），数组越界问题，数组作为函数参数的应用（数组名、冒泡排序），还有两个利用前面学过的知识，实现两个小游戏（三子棋和扫雷游戏）。 本文干货满满，期待你的访问。
数组的基本知识
m0_63783532的博客
10-31 4047
数组：按照一定个数排列起来的，具有相同类型的数据元素的集合。一维数组：若线性表中的数据元素为非结构的简单元素，则称为一维数组。一维数组的逻辑结构：线性结构。定长的线性表。声明格式：数据类型 变量名称[长度] int a[5];二维数组：若一维数组中的元素又是一维数组结构，则称为二维数组。二维数组的逻辑结构（可以看成非线性结构也可以看成线性结构）：1.非线性结构：每一个数据元素既在一个行表中，又在一个列表中。2.线性结构：该线性表的每个数据元素也是一个定长的线性表。
Javascript数组Array基础介绍
10-22
JavaScript中的数组Array是编程中非常基础且重要的概念，尤其在JavaScript这种动态类型的脚本语言中，数组具有灵活性和广泛的应用场景。本文主要介绍了Array的基本知识，让我们深入了解一下JavaScript数组的特性。 ...
TIA博途中数组Array【】的基本使用方法详解.docx
10-08
TIA博途中数组Array【】的基本使用方法详解
Javascript基础教程之数组 array
10-24
1. **数组创建**：在JavaScript中，我们可以使用`Array`构造函数来创建数组，如`new Array(length)`或`new Array(element1, element2, ..., elementN)`。长度可以在创建时指定，也可以在创建后动态添加元素。 2. **...
Javascript数组Array方法解读
10-22
是Javascript数组Array系列文章的第二篇，主要给大家讲解的是javascript数组arrayd的所有方法，希望大家能够喜欢。
数组（Array)——数组介绍
热门推荐
Sun.ME的博客
02-12 11万+
Arrays(数组) 数组是一个固定长度的存储相同数据类型的数据结构，数组中的元素被存储在一段连续的内存空间中。它是最简单的数据结构之一，大多数现代编程语言都内置数组支持。 为何使用数组存储一堆变量 与单独为每一个元素声明一个变量名相比，我们可以使用数组的索引值访问数组中的每一个元素。 例如：我们需要实现一个系统来存储办公室所有员工的年龄，传统的存储方式如下： 我们为办公室的每一个员工创建一...
数组的定义及使用
L.
07-26 2万+
一、基本概念 数组指的就是一组相关变量的集合。例如：如果现在要想定义100个整型变量，如果按照传统的思路： int i1,i2,……i100,一共写100个变量。 这100个变量满足逻辑要求，但是没有任何的逻辑的控制关系，完全独立，那么就会出现对象不方便管理的情况。这种情况下，就可以利用数组来解决此类问题，而数组本身也属于引用数据类型。数组的定义语法如下： ·  声明并开辟数组：数据类型...
数组的三种定义方式
小灰~的博客
12-25 7万+
1.数组的定义 用于存储同一类型数据的集合，其实数组就是一个容器。 连续的存储单元 2.数组的好处 自动给数组中的元素从零开始编号。自动给下标，从零开始0-1-2-3-…… 3.书写格式 元素类型[] 数组名 = new元素类型[]{元素，元素，元素……}; 格式1：int [] arr = new int[5]; ...
java合法的数组声明_Java数组01：数组的声明和创建、内存分析
weixin_36162235的博客
02-24 543
一、数组概述数组的定义：数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标访问他们。二、数组声明创建2.1、数组的声明创建首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：dataType[] arrayRefVar; //首选的方法//或dataType arrayRe...
数组（Array)
jyr2014的博客
11-28 3541
数组 数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。 数组是用于储存多个相同类型数据的集合。分为一维数组、二维数组和三维数组。 int[] arr={1,2,3,4,5,6}; ...
C语言：数组(详解)
m0_74068921的博客
05-19 8724
数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。所以，数组是用于储存多个相同类型数据的集合。
数组的详细介绍
m0_50708613的博客
01-29 1629
目录 一、集合、列表和数组的概念 1.集合 （1）集合概念 （2）集合的三要素 （3）集合的特性 2.列表 （1）列表概念 （2）列表特征 （3）主要表现 3.索引 （1）索引概念 （2）优缺点 4.数组 （1）数组概念 （2）数组与列表的区别 二、一维数组 1.一维数组概念 2.定义方式 3.数组初始化 4.一维数组的下标 5.一维数组的运用 1.求数组中的最大最小值 2.对数组a[10]={10,4,3,7,9,18,14,12,17,15}进行排序 ..
数组的概述
weixin_63407059的博客
10-15 484
1、JVM是执行Java代码的容器，空间很大，需要划分不同的区域，具有不同的功能，也具有不同。（2）指针：是C语言中的一个概念，Java中并不存在这个东西，地址值指向数据的操作，就像是C。（6）Java中实际上不存在任何真实的地址，我们看到的地址都是经过转化的伪地址，我们以后就。2.使用一个容器，容器具有一个名字，以后只需要寻找这个容器，就可以得到所有的数据。（2）堆内存【常用】：用于存储数组、对象等数据量较大的数据，这些数据一般都是引用数据类型。索引：数组空间位置的编号，别名：下标，脚标，角标。
用汇编语言将包含20个数据的数组Array分成两个数组，正数数组arrayp和负数数组arrayn，并分别将这两个数组中的数据个数显示出来
04-23
但是，我可以告诉你如何将包含20个数据的数组Array分成两个数组，正数数组arrayp和负数数组arrayn，并分别将这两个数组中的数据个数显示出来： 首先，我们可以遍历数组Array中的每一个元素，使用if语句判断每一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

学无止路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值