数组 订阅
数组(Array)是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。 展开全文
数组(Array)是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。
信息
定    义
同类数据元素的集合
分    类
一维、二维(矩阵)、三维数组
中文名
数组
外文名
Array
数组产生来源
在C语言中, 数组 [2]  属于构造数据类型。一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同,数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。关于可变长数组(VLA)的问题:原来的C89标准中是不允许可变长数组出现的,但是在C99标准中,加入了对VLA的支持 [3]  ,但是支持的编译器不多,而且由于栈溢出的安全问题,没有太多的人敢用这个可变长数组,所以在C11标准中又把它规定为可选实现的功能了 [4]  。如果有过用其它语言编程的经历,那么想必会熟悉数组的概念。由于有了数组,可以用相同名字引用一系列变量,并用数字(索引)来识别它们。在许多场合,使用数组可以缩短和简化程序,因为可以利用索引值设计一个循环,高效处理多种情况。数组有上界和下界,数组的元素在上下界内是连续的。因为 Visual Basic对每一个索引值都分配空间,所以不要不切实际声明一个太大的数组。此处数组是程序中声明的变量数组。它们不同于控件数组,控件数组是在设计时通过设置控件的 Index 属性规定的。变量数组总是连续的;与控件数组不同的是,不能从一个数组的中部加载或卸载数组元素。一个数组中的所有元素具有相同的数据类型(在C、C++、Java、pascal中都这样。但也并非所有涉及数组的地方都这样,比如在Visual Foxpro中的数组就并没这样的要求)。当然,当数据类型为 Variant 时,各个元素能够包含不同种类的数据(对象、字符串、数值等等)。可以声明任何基本数据类型的数组,包括用户自定义类型和对象变量。如果要用户输入的是一个数组,一般是用一个循环,但是在输入前也需要固定数组的大小。compact跟变长数组没有太大的关系,也应该用不到变长数组。因为一般的传数组到函数中就是传数组的地址和元素的个数的,那只是一个提示,不是要求。原型可以这样写(假设数组的元素是type):数组类型说明 在C语言中使用数组必须先进行类型说明。数组说明的一般形式为:类型说明符 数组名 [常量表达式],……; 其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号中的常量表达式表示数据元素的个数,也称为数组的长度。数组就是一次性定义相同数据类型的一组变量数组定义。说明整型数组a,有10个元素。若要表示第10个元素,则使用a[9]。第一个则是a[0]。说明实型数组b,有10个元素,实型数组c,有20个元素。说明字符数组ch,有20个元素。1.数组是相同数据类型的元素的集合。2.数组中的各元素的存储是有先后顺序的,它们在内存中按照这个先后顺序连续存放在一起。3.数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如,a[0]表示名字为a的数组中的第一个元素,a[1]代表数组a的第二个元素,以此类推。对于VB的数组,表示数组元素时应注意:1下标要紧跟在数组名后,而且用圆括号括起来(不能用其他括号)。2下标可以是常量,变量,或表达式,但其值必须是整数(如果是小数将四舍五入为整数)。3下标必须为一段连续的整数,其最小值成为下界,其最大值成为上界。不加说明时下界值默认为1。
收起全文
精华内容
下载资源
问答
  • 数组

    千次阅读 2017-10-06 14:39:56
    重点: 定义数组初始化数组遍历数组Arrays类 难点: 遍历数组二维数组及使用 ...数组类型 数组名[]=new 数组类型[数组长度]; 数组元素分配的初始值: 数组元素类型  默认初始值 byt
    重点:
    • 定义数组
    • 初始化数组
    • 遍历数组
    • Arrays类
    难点:
    • 遍历数组
    • 二维数组及使用

    1.1一维数组
    1.1.1定义数组
    在Java中,定义数组的语法有两种。
    语法:
    • 数据类型[] 数组名=new 数据类型[数组长度];
    • 数组类型 数组名[]=new 数组类型[数组长度];
    数组元素分配的初始值:
    数组元素类型 默认初始值
    byte、short、int、long 0
    float、double  0.0
    char '\u0000'
    booleanfalse
    引用数据类型null

    1.1.2数组元素的表示与赋值
    由于定义数组时,内存分配的是连续空间,所以数组元素在数组里顺序排列编号,该编号即元素下标,它标明了元素在数组 中的位置。
    语法:
    数组名[下标值]
    1.1.3数组的初始化
    所谓数组初始化,就是在 定义数组的同时一并完成赋值操作
    语法:
    • 数据类型 [] 数组名={值1,值2,值3,……,值n};
    • 数组类型 [] 数组名=new 数据类型[]{值1,值2,值3,……,值n}
    1.1.4遍历数组
    在编写程序时,数组和循环往往结合在一起使用,可以大大地简化代码,提高程序效率。通常,使用for循环遍历数组。

    2.1二维数组
    Java中定义和操作多维数组的语法与一维数组类似。在实际应用中,三维及以上的数组很少使用,主要使用二维数组。
    语法:
    • 数组类型 [][] 数组名;
    • 数组类型 数组 [][];
    需要强调的是,虽然从语法上看,Java支持多维数组,但从内存分配原理的角度讲,Java中只有一维数组,没有多维 数组。或者说,表面上是多维数组,实质上都是一维数组。
    2.2二维数组及其使用
    1.初始化二维数组
    二维数组也可以进行初始化操作,与一维数组类似,同样采用如下两种方式,要注意大括号的结构及书写顺序。
    例:
    • int[][] score=new int[][]{{90,32,43,43,23},{42,32,44},{67}};
    • int score[][]={{90,32,43,43,23},{42,32,44},{67}};
    2.二维数组的遍历
    例:
    public static void main(String[] args){
       int [][] array=new int[][]{{90,32,43,43,23},{42,32,44},{67}};
       int total;
       for(int i=0;i<array.length;i++){
           String str=(i+1)+"班";
           total=0;
           for(int j=0;j<array[i].length;j++){
            total+=array[i][j];
           }
           System.out.println(str+"总成绩:"+total);
       }
    }
    3.1Arrays类及其常用方法
    JDK中提供了一个专门用于操作数组的工具类, 即Arrays类,位于java.util包中。该类提供了一系列方法来操作数 组,如 排列、复制、比较、填充等 ,用户直接调用这些方法即可,不需要自己编写实现,降低了开发难度。
    Arrays类常用方法
    返回类型  方法 说明
    boolean equals(array1,array2)比较两个数组是否相等
    void  shrt(array)对数组array的元素进行升序排列
    StringtoString()将一个数组array转换成一个字符串
    void fill(array,val)把数组array的所有元素都赋值为val
    与array数组类型一致copyOf(array,length)把数组array复制成一个长度为length的新数组
    intbinarySearch(array,val)查询元素值val在数组array中的下标

    总结:
    • 数组是可以再内存中连续存储多个元素的结构。数组中的所有元素必须属于相同的数据类型。
    • 数组中的元素通过数组下标进行访问,数组下标从0开始。
    • 二维数组实际上是一个一维数组,它的每个元素又是一个一维数组。
    • 使用Array类提供的方法可以方便地对数组中的元素进行排序、查询等操作。
    • JDK1.5之后提供了增强for循环,可以用来实现对数组和集合中数据的访问。
    展开全文
  • javascript 数组以及对象的深拷贝(复制数组或复制对象)的方法前言在js中,数组和对象的复制如果使用=号来进行复制,那只是浅拷贝。如下图演示: 如上,arr的修改,会影响arr2的值,这显然在绝大多数情况下,并...

    javascript 数组以及对象的深拷贝(复制数组或复制对象)的方法

    前言

    在js中,数组和对象的复制如果使用=号来进行复制,那只是浅拷贝。如下图演示:

    如上,arr的修改,会影响arr2的值,这显然在绝大多数情况下,并不是我们所需要的结果。
    因此,数组以及对象的深拷贝就是javascript的一个基本功了。

    评论中有很多人说我误导大家。说这些都是浅拷贝。我不做过深的阐述,本文中涉及到的都是比较浅显的内容。诸位请根据自己的需要以及情况自行判断和理解。

    数组的深拷贝

    条条大道通罗马,实现数组的深拷贝,是有好几种方法的。举例如下:

    for 循环实现数组的深拷贝

    for循环是非常好用的。如果不知道高级方法,通过for循环能够完成我们大多数的需求。

    var arr = [1,2,3,4,5]
    var arr2 = copyArr(arr)
    function copyArr(arr) {
    	let res = []
    	for (let i = 0; i < arr.length; i++) {
    	 res.push(arr[i])
    	}
    	return res
    }
    

    如上,通过对数组的for循环,即可实现对数组的深拷贝了。

    slice 方法实现数组的深拷贝

    这个代码实现非常简单。原理也比较好理解,他是将原数组中抽离部分出来形成一个新数组。我们只要设置为抽离全部,即可完成数组的深拷贝。代码如下:

    var arr = [1,2,3,4,5]
    var arr2 = arr.slice(0)
    arr[2] = 5
    console.log(arr)
    console.log(arr2)
    

    运行结果如下:

    更多 slice 内容请访问 w3school JavaScript slice 方法

    concat 方法实现数组的深拷贝

    这个代码也非常简单,原理更加粗暴。它是用于连接多个数组组成一个新的数组的方法。那么,我们只要连接它自己,即可完成数组的深拷贝。代码如下:

    var arr = [1,2,3,4,5]
    var arr2 = arr.concat()
    arr[2] = 5
    console.log(arr)
    console.log(arr2)
    

    运行结果如下:

    更多 concat 内容请访问 w3school JavaScript concat 方法

    2017年10月31日补充:ES6扩展运算符实现数组的深拷贝

    OK,以上之前讲的方法全部过时了,用下面的方法实现数组的深拷贝是最简单的。

    var arr = [1,2,3,4,5]
    var [ ...arr2 ] = arr
    arr[2] = 5
    console.log(arr)
    console.log(arr2)
    

    运行结果如下:

    ES6扩展运算符实现数组的深拷贝

    对象的深拷贝

    对象的深拷贝相比数组也没有困难许多,列举两个方法。

    万能的for循环实现对象的深拷贝

    在很多时候,for循环能够解决大问题。

    var obj = {
      name: 'FungLeo',
      sex: 'man',
      old: '18'
    }
    var obj2 = copyObj(obj)
    function copyObj(obj) {
      let res = {}
      for (var key in obj) {
        res[key] = obj[key]
      }
      return res
    }
    

    转换成json再转换成对象实现对象的深拷贝

    上面的代码实在是比较长,所以,用一个更暴力的方法吧!代码如下:

    var obj = {
      name: 'FungLeo',
      sex: 'man',
      old: '18'
    }
    var obj2 = JSON.parse(JSON.stringify(obj))
    

    这个原理没什么好解释的,实在是够简单粗暴的啦!

    2017年10月31日补充: 扩展运算符实现对象的深拷贝

    var obj = {
      name: 'FungLeo',
      sex: 'man',
      old: '18'
    }
    var { ...obj2 } = obj
    obj.old = '22'
    console.log(obj)
    console.log(obj2)
    

    运行结果如下:

    扩展运算符实现对象的深拷贝

    小结

    数组和对象的深拷贝是js中最常见的应用。理解各种方法是必须的。希望对大家有所帮助。
    本文中并没有对异常进行处理,主要在讲原理。更多的数组以及对象的操作方法,可以参考lodash的源码,查看它的源码可以让你的js基础变得非常牢固。我也在学习中。

    2017年10月31日补充,使用es6提供的扩展运算符的方法实现深拷贝,简单,高效。并且,对象的深拷贝不会像使用 JSON 方法深拷贝一样,丢失函数等信息,只能用来深拷贝 JSON 数据格式的对象。推荐大家使用。

    补充一个数组去重的方法

    function dedupe(array) {
      return [...new Set(array)]
    }
    var arr = [1,2,2,3,3,4,4,5,5]
    console.log(dedupe(arr))
    

    运行结果如下:

    JS数组去重的方法

    2021年03月29日 补充

    这里说的深拷贝,都是指一维的数组和对象的深拷贝。鉴于评论中多人指出,这些是浅拷贝,我本来不想回应,但是提出这个观点的人很多,因此我在这边回应一下。

    浅拷贝的概念不重复了,上文中已经说明。文章中的多种方法,均不是浅拷贝,只是是否支持多维数据而已。而在绝大多数场景下,文中的方法是适用的。

    想要简便的支持多维数据的深拷贝,可以直接适用 JSON 方式。或适用 lodash 工具实现。

    版权申明:本文由FungLeo原创,允许转载,但转载必须附注首发链接。谢谢。

    展开全文
  • 新手小白学JAVA 数组 数组工具类 二维数组

    万次阅读 多人点赞 2021-04-02 08:28:55
    1 数组 1.1 概念 数组Array,标志是[ ] ,用于储存多个相同类型数据的集合 想要获取数组中的元素值,可以通过脚标(下标)来获取 数组下标是从0开始的,下标的最大值是数组的长度减1 1.2 创建数组 数组的创建方式一般...

    1 数组

    1.1 概念

    数组Array,标志是[ ] ,用于储存多个相同类型数据的集合
    想要获取数组中的元素值,可以通过脚标(下标)来获取
    数组下标是从0开始的,下标的最大值是数组的长度减1
    数组结构

    1.2 创建数组

    数组的创建方式一般分为动态初始化和静态初始化

    1. 动态初始化
      int[] a = new int[5];
    2. 静态初始化
      int[] b = new int[]{1,2,3,4,5};
      int[] c = {1,2,3,4,5};

    1.3 创建数组过程分析

    程序创建数组 int[] a = new int[5]; 时发生了什么?

    1. 在内存中开辟连续的空间,用来存放数据,长度是5
    2. 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
    3. 数组完成初始化会分配一个唯一的地址值
    4. 把唯一的地址值交给引用类型的变量a去保存

    数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

    1.4 数组的长度

    数组的长度用 length属性来表示,数组一旦创建,长度不可改变
    数组的长度允许为0

    1.5 练习:向数组中存入数据hello

    数组中存入hello示例
    创建包: cn.tedu.array
    创建类: TestCreateArray.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于练习数组的创建*/
    public class TestCreateArray {
    	public static void main(String[] args) {
    		//1.创建数组
    		//1.1静态创建--创建的时候已经知道了每一个元素的值
    		char[] c1 = {'h','e','l','l','o'};
    		char[] c2 = new char[] {'h','e','l','l','o'};
    		
    		//1.2动态创建--知道了数组的长度,后面再具体赋值
    		char[] c3 = new char[5];//在内存中开辟一块连续的内存空间,用来存放5个字符
    		//1.2.2给c3数组动态的赋值
    		/**我们通过数组的下标来操作数组中的每一个元素,注意数组下标从0开始*/
    		c3[0] = 'h';//给数组中的第1个元素赋值
    		c3[1] = 'e';//给数组中的第2个元素赋值
    		c3[2] = 'l';//给数组中的第3个元素赋值
    		c3[3] = 'l';//给数组中的第4个元素赋值
    		c3[4] = 'o';//给数组中的第5个元素赋值
    		
    		//2.打印查看刚刚创建好的数组
    		System.out.println(c1);
    		System.out.println(c2);
    		System.out.println(c3);
    		
    		//3.创建String类型的数组,存放数据"a","b","c"
    		String[] s1 = {"a","b","c"};
    		String[] s2 = new String[] {"a","b","c"};
    		String[] s3 = new String[3];
    		s3[0] = "a";//给s3数组的第1个元素赋值为"a"
    		s3[1] = "b";//给s3数组的第2个元素赋值为"b"
    		s3[2] = "c";//给s3数组的第3个元素赋值为"c"
    		
    		/**char类型的数组底层中做了处理,可以直接打印数组中的具体元素
    		 * 除了char类型以外的数组想要查看数组中的具体元素,需要使用数组的工具类Arrays
    		 * 具体方式:Arrays.toString(数组名);
    		 * 注意Arrays使用时需要导包*/
    		//4.打印创建好的数组
    		System.out.println(s1);//打印出来的是数组的地址值
    		System.out.println(Arrays.toString(s2));
    		
    		//5.查看数组的长度--数组中存放的元素的个数
    		/**数组一旦创建,长度不可改变,如果想要增加/删除数组中的元素
    		 * 只能先创建一个新长度的数组,再将原来的数据复制过去*/
    		System.out.println(c1.length);
    		System.out.println(s1.length);
    		
    	}
    	
    }
    

    1.6 数组的遍历

    遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
    我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

    开始:开始下标0 结束:结束下标length-1 如何变化:++
    for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
    循环体;
    }`

    1.7 练习-1:输出每个月的天数

    创建类: TestArrayExec.java

    package cn.tedu.array;
    /**本类用于练习数组的遍历
     * 需求:输出一年中每个月份的天数
     * */
    public class TestArrayExec {
    	public static void main(String[] args) {
    		m ();//本方法用于输出每个月的天数,快速修复快捷键Ctrl+1
    	}
    	//打印需求:例如 1月有31天
    	public static void m () {
    		//1.创建数组用来存12个月的天数
    		int[] a = {31,28,31,30,31,30,30,31,30,31,30,31};
    		
    		//2.输出每个月的天数打印到控制台
    		//数组的遍历--通过循环的方式--操作的是数组的下标
    		//循环开始:a[0]--数组中的第一个元素
    		//循环结束:a[a.length-1]--数组中的最后一个元素
    		//如何变化:++
    		//for(int i = 0 ; i <=a.length-1 ; i++) {
    		for(int i = 0 ; i <a.length ; i++) {
    			//a[i]--根据下标i来获取数组a中对应位置上元素的值
    			System.out.println((i+1)+"月有:"+a[i]+"天");
    		}
    	}
    }
    

    1.8 练习-2:遍历数组,存入1到10

    //需求:遍历数组,存入1-10
    	public static void m2() {
    		//1.创建数组--动态创建
    		int[] a = new int[10];
    		
    		//2.遍历数组,依次给每个位置赋值
    		//循环开始:a[0]--数组中的第一个元素
    		//循环结束:a[a.length-1]--数组中的最后一个元素
    		//如何变化:++
    		for(int i = 0 ; i <= a.length-1 ; i++) {
    			//a[i]--根据下标i来获取数组a中对应位置上元素的值
    			a[i] = i+1;
    		}//for循环结束
    		//3.在存入10个数据之后,打印a数组
    		System.out.println(a);//[I@15db9742
    		//除了char类型的数组,其他类型的数组想要查看具体内容需要借助工具类Arrays
    		//Arrays.toString(要打印的数组的名字)来查看数组中的具体内容
    		System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    		
    	}
    

    1.9 练习-3:创建随机数组

    需求:创建数组,数组中的内容是100以内的随机数

    public static void m3() {
    	//1.创建数组--动态
    	int[] a = new int[10];
    	//2.遍历数组,给数组中的每个元素赋值
    	for(int i = 0 ; i <a.length ; i++) {
    		//100是自定义的数据,表示生成的随机整数的范围是[0,100)
    		a[i] = new Random().nextInt(100);
    		//a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)
    	}
    	//3.使用数组的工具类查看数组中的元素
    	System.out.println(Arrays.toString(a));
    }
    

    2 数组工具类Arrays

    2.1 Arrays.toString(数组)

    把数组里的数据,用逗号连接成一个字符串[值1,值2]
    

    2.2 Arrays.sort(数组)

    对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
    对引用类型数组,使用的是优化后的合并排序算法
    

    2.3 练习:练习Arrays.sort(数组)

    创建类: TestArraysSort.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于测试数组的工具类Arrays*/
    public class TestArraysSort {
    	public static void main(String[] args) {
    		//1.创建无序数组
    		int[] a = {21,96,75,23,25};
    		
    		//底层使用的排序算法是进行优化后的快速排序算法
    		Arrays.sort(a);//对无序数组进行直接排序
    		System.out.println(Arrays.toString(a));
    	}
    }
    

    2.4 Arrays.copyOf(数组,新的长度)

    把数组赋值成一个指定长度的新数组
    新数组的长度 大于 原数组, 相当于复制,并增加位置
    新数组的长度 小于 原数组, 相当于截取一部分数据

    2.5 练习:练习Arrays. copyOf(数组,新的长度)

    创建类: TestArraysCopyOf.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于练习数组的缩容与扩容*/
    public class TestArraysCopyOf {
    	public static void main(String[] args) {
    		//1.创建数组
    		int[] from = {1,2,3,4,5};//数组一旦创建,长度不可改变
    		
    		//2.1 数组的普通复制
    		/**copyOf()用于完成数组的复制,两个参数:
    		 * 参数1:要复制哪个数组
    		 * 参数2:新数组的长度*/
    		int[] to = Arrays.copyOf(from, 5);
    		System.out.println(Arrays.toString(to));
    		
    		//2.2数组的扩容
    		/**扩容:给数组扩大容量,新数组的长度>原数组的长度
    		 * 扩容思路:先创建对应长度的新数组,每个位置上都是默认值0
    		 * 然后从原数组中将元素复制到新数组,没有被覆盖的元素还是默认值0*/
    		int[] to2 = Arrays.copyOf(from, 10);
    		System.out.println(Arrays.toString(to2));
    		
    		//2.3数组的缩容
    		/**缩容:缩小数组的容量,新数组的长度<原数组的长度
    		 * 缩容思路:先创建对应长度的新数组,每个位置上都是默认值0
    		 * 然后从原数组中复制指定个数的元素到新数组中,类似于截取*/
    		int[] to3 = Arrays.copyOf(from, 3);
    		System.out.println(Arrays.toString(to3));
    		
    		//2.4指定首尾截取原数组中的元素
    		/**copyOfRange()用于完成数组的截取,3个参数:
    		 * 参数1:要截取哪个数组【原数组】
    		 * 参数2:从原数组的哪个下标开始
    		 * 参数3:到原数组的哪个下标结束
    		 * 注意:截取的元素包含开始下标处的元素,不包含结束下标处的元素*/
    		int[] to4 = Arrays.copyOfRange(from, 2, 4);
    		System.out.println(Arrays.toString(to4));
    	}
    }
    

    3 拓展之二维数组

    3.1 概念

    存放数组的数组,也就是说数组里存的还是数组的数据形式
    二维数组图示

    3.2 创建二维数组

    int[][] a = {{3,5},{7,9},{1,2}};
    –创建外部数组,长度是3
    –给每个外部数组的位置创建内部数组,每个内部数组的长度是2
    –给每个内部数组进行数据初始化
    –二维数组生成唯一的地址值
    –把地址值交给引用类型变量a来保存

    3.3 遍历二维数组

    for (int i = 0; i < a.length; i++) {//遍历外部数组
    for (int j = 0; j < a[i].length; j++) {//遍历内部数组
    System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
    }
    }

    3.4 打印二维数组中的数据

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于打印二维数组中的数据*/
    public class TestArrays2 {
    	public static void main(String[] args) {
    		//1.创建二维数组
    		//    3      5    
    		//a[0][0] a[0][1]
    		//    7       9
    		//[1][0] a[1][1] 
    		//    1       2      3
    		//a[2][0] a[2][1] a[2][2]
    		int[][] a = {{3,5},{7,9},{1,2,3}};
    		
    		//2.遍历二维数组
    		for (int i = 0; i < a.length; i++) {
    //			System.out.println(Arrays.toString(a[i]));
    			for (int j = 0; j < a[i].length; j++) {
    				//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
    				System.out.print(a[i][j]);
    			}
    			System.out.println();
    		}
    	}
    }
    
    展开全文
  • c语言数组介绍

    万次阅读 热门讨论 2021-08-13 09:13:39
    文章目录一、一维数组的创建和初始化1.数组的创建2.数组的初始化3.一维数组的使用4.一维数组在内存中的存储二、二维数组的创建和初始化1.二维数组的创建2.二维数组的创建3.二维数组的创建4.二维数组在内存中的存储二...


    一、一维数组的创建和初始化

    1.数组的创建

    数组是一组相同类型元素的集合。
    数组的创建方式:

    type_t   arr_name[const_n];
    //type_t 是指数组的元素类型
    //const_n 是一个常量表达式,用来指定数组的大小
    

    数组创建的实例:

    //代码1
    int arr1[10];
    //代码2
    int count = 10;
    int arr2[count];
    //数组时候可以正常创建?
    //代码3
    char arr3[10];
    float arr4[1];
    double arr5[20];
    

    :数组创建,[]中要给一个常量才可以,不能使用变量。

    2.数组的初始化

    数组的初始化是指,在创建数组的同时给数组的内容一些合理初始值(初始化)。
    看代码:

    int arr1[10] = { 1,2,3 };
    int arr2[] = { 1,2,3,4 }; 
    int arr3[5] = { 12345 }char arr4[3] = { 'a',98, 'c' }; 
    char arr5[] = { 'a','b','c' }; 
    char arr6[] = "abcdef";
    

    数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。
    但是对于下面的代码要区分,内存中如何分配。

    char arr1[] = "abc";
    char arr2[3] = {'a','b','c'};
    

    3.一维数组的使用

    对于数组的使用我们之前介绍了一个操作符:[],下标引用操作符。它其实就数组访问的操作符。我们来看代码:

    #include <stdio.h>
    int main(){    
    	int arr[10] = {0};
    	//数组的不完全初始化   
    	//计算数组的元素个数    
    	int sz = sizeof(arr)/sizeof(arr[0]);  
    	//对数组内容赋值,数组是使用下标来访问的,下标从0开始。所以:    
    	int i = 0;
    	for(i=0; i<10; ++i)    {
    		printf("%d ", arr[i]);   
    	}    return 0;
    }
    

    总结:

    1. 数组是使用下标来访问的,下标是从0开始。
      2.数组的大小可以通过计算得到。

    4.一维数组在内存中的存储

    接下来我们探讨数组在内存中的存储。
    看代码

    #include <stdio.h>
    int main() {
    	int arr[10] = { 0 };
    	int i = 0;
    	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
    		printf("&arr[%d] = %p\n", i, &arr[i]);
    	}
    	return 0;
    }
    

    在这里插入图片描述
    仔细观察输出的结果,我们知道,随着数组下标的增长,元素的地址,也在有规律的递增。
    由此可以得出结论:数组在内存中是连续存放的。

    二、二维数组的创建和初始化

    1.二维数组的创建

    //数组创建
    int arr[3][4];
    char arr[3][5];
    double arr[2][4];
    

    2.二维数组的创建

    //数组初始化
    int arr[3][4] = {1,2,3,4};
    int arr[3][4] = {{1,2},{4,5}};
    int arr[][4] = {{2,3},{4,5}};
    

    3.二维数组的创建

    二维数组的使用也是通过下标的方式。
    看代码:

    #include <stdio.h>
    int main(){   
    	int arr[3][4] = {0};   
    	int i = 0;   
    	for(i=0; i<3; i++)    {
    		int j = 0;
    		for(j=0; j<4; j++)        {
    			arr[i][j] = i*4+j;      
    		}  
    		  }    
    	for(i=0; i<3; i++)    {
    		int j = 0;
    		for(j=0; j<4; j++)        {
    			printf("%d ", arr[i][j]);     
    		}   
    		 }    
    	return 0;
    }
    

    4.二维数组在内存中的存储

    像一维数组一样,这里我们尝试打印二维数组的每个元素。

    #include <stdio.h>
    int main(){   
    	int arr[3][4];  
    	int i = 0;    
    	for(i=0; i<3; i++)    {
    		int j = 0; 
    		for (j = 0; j < 4; j++) { 
    			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
    		}
    	}   
    	return 0;
    }
    

    在这里插入图片描述
    通过结果我们可以分析到,其实二维数组在内存中也是连续存储的。

    二、数组越界

    数组的下标是有范围限制的。
    数组的下规定是从0开始的,如果输入有n个元素,最后一个元素的下标就是n-1。
    所以数组的下标如果小于0,或者大于n-1,就是数组越界访问了,超出了数组合法空间的访问。
    C语言本身是不做数组下标的越界检查,编译器也不一定报错,但是编译器不报错,并不意味着程序就是正确的,所以程序员写代码时,最好自己做越界的检查。

    #include <stdio.h>
    int main(){    
    	int arr[10] = {1,2,3,4,5,6,7,8,9,10};  
    	int i = 0;    
    	for(i=0; i<=10; i++)    {
    		printf("%d\n", arr[i]);//当i等于10的时候,越界访问了   
    	}    
    	return 0;
    }
    

    二维数组的行和列也可能存在越界。

    1. 数组名是什么?

    #include <stdio.h>
    int main(){    
    	int arr[10] = {1,2,3,4,5};    
    	printf("%p\n", arr);   
    	printf("%p\n", &arr[0]);   
    	printf("%d\n", *arr);    
    	//输出结果    
    	return 0;
    }
    

    结论:
    数组名是数组首元素的地址。(有两个例外)
    如果数组名是首元素地址,那么:

    int arr[10] = {0};
    printf("%d\n", sizeof(arr));
    

    为什么输出的结果是:40?
    补充:

    1. sizeof(数组名),计算整个数组的大小,sizeof内部单独放一个数组名,数组名表示整个数组。
    2. &数组名,取出的是数组的地址。&数组名,数组名表示整个数组。
    3. 除此1,2两种情况之外,所有的数组名都表示数组首元素的地址。
    展开全文
  • 数组指针和指针数组

    万次阅读 多人点赞 2019-09-17 16:39:06
    首先,理解一下数组指针和指针数组这两个名词: “数组指针”和“指针数组”,只要在名词中间加上“的”字,就知道中心了—— 数组的指针:是一个指针,什么样的指针呢?指向数组的指针。 指针的数组:是一个数组...
  • JQ数组操作(定义一个数组,给数组赋值)

    万次阅读 多人点赞 2016-07-14 13:36:33
    JQ数组操作(定义一个数组,给数组赋值)1、JS定义一个数组:(1)、var select=[]; (2)、var select=new Array();2、JS给一个数组赋值:(1)、select.push(); 具体详解: js中添加数组用push.示例如下: var arr = []; ...
  • C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素的引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 ...
  • Java数组的三种打印方式

    万次阅读 多人点赞 2018-01-06 16:01:49
    1.数组的输出的三种方式 一维数组: 定义一个数组 int[] array = {1,2,3,4,5}; (1)传统的for循环方式 for(int i=0;i<array.length;i++) { System.out.println(array[i]); } (2)for each循环 for...
  • JAVA中的数组插入与删除指定元素

    万次阅读 热门讨论 2017-08-02 19:28:30
    今天学了Java的数组,写了数组的插入和删除,本人小白,写给不会的小白看,大神请忽略,有错请大家指出来; /** 给数组指定位置数组的插入 */ import java.util.*; public class ArrayInsert{ public static ...
  • Java创建数组的方法

    万次阅读 多人点赞 2018-10-13 22:43:01
    最近在学Java,一点小心得,希望和大家分享一下,第一次写文章,写的不好希望大家谅解,当然我也会尽力写好这篇文章!本章介绍的创建数组的各种方法,并对它们进行了对比和剖析,最后还扩展了一些知识。
  • 算法 - 求子数组的最大和(C++)

    万次阅读 多人点赞 2019-02-27 18:11:55
    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍...数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和。 * 求所有子数组的和的最大值。要求时间复杂度为O(n...
  • 指针数组数组指针详解

    万次阅读 多人点赞 2016-09-28 21:21:20
    指针数组:指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中,指针占四个字节。 数组指针:数组指针可以说成是”...
  • java如何向数组里添加元素

    万次阅读 多人点赞 2018-09-14 23:54:52
    java篇 哇,菜鸟第一次写这个东西,当加深印象,大佬们请略过,欢迎...但有个可以改变大小的数组为ArrayList,即可以定义一个ArrayList数组,然后用add(element)方法往里添加元素即可,还可add(index,element)往指...
  • vue.js中$set与数组更新

    万次阅读 多人点赞 2017-09-19 10:39:48
    由于 JavaScript 的限制,Vue 不能检测以下变动的数组: 当利用索引直接设置数组的某一项时,例如:vm.items[indexOfItem] = newValue 当你修改数组的长度时,例如:vm.items.length = newLength,不会更新数组...
  • 指针数组数组指针——用指针访问数组方法总结

    万次阅读 多人点赞 2019-01-14 09:51:11
    1.数组元素的访问 2.通过指针访问数组 2.1 通过指针访问一维数组 2.2 通过指针访问二维数组 2.2.1 指向元素的指针 2.2.2 指向每一行的指针(指针数组方式) 2.2.3 指向整个数组的指针(数组指针方式) 3 总结...
  • ES6数组去重的三个简单办法

    万次阅读 多人点赞 2019-06-19 00:43:09
    ES6数组去重的三个简单办法 简单说一下利用ES6实现数组去重的三个办法。 第一种: 利用Map对象和数组的filter方法 贴上相关代码 打印后的结果 通过打印我们发现,确实实现了我们想要的效果。那么下面简单来解释一下...
  • 详解C语言中的数组指针与指针数组

    万次阅读 多人点赞 2018-05-06 21:52:39
    ·详解数组指针与指针数组 ·数组指针 一、区分 首先我们需要了解什么是数组指针以及什么是指针数组,如下图: int *p[5]; int (*p)[5]; 数组指针的意思即为通过指针引用数组,p先和*结合,说明了p是一个指针...
  • 数组(ArrayList)底层怎样扩容

    万次阅读 2021-04-23 09:59:05
    ArrayList维护了数组transient Object[] elementData; 初始化 数组需要扩容时
  • Java中数组的定义与使用(一)

    万次阅读 多人点赞 2018-09-01 00:05:13
    数组的基本概念 如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ... i100; 但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间...
  • 当我们了解伪数组之前先了解下普通的数组的特点 数组是用来存储一系列值的一个集合,而每个值在数组里面都有一个对应的索引,也可以叫做下标,索引是从0开始的,依次递增。 比如: let arr = ['a','b','c']; // 字符...
  • JavaSE数组

    千次阅读 多人点赞 2020-11-27 20:46:14
    JavaSE数组一维数组数组的定义数组的创建数组的初始化数组赋值数组的遍历数组的异常二维数组数组的声明、创建、初始化二维数组的遍历 数组可以看成是多个相同类型数据的组合,实现对这些数据的统一管理。 一维数组...
  • java对象数组 创建对象数组,初始化对象数组

    万次阅读 多人点赞 2019-07-30 16:34:15
    对象数组的概念: 如果一个数组中的元素是对象类型,则称该数组为对象数组。 当需要一个类的多个对象时,应该用该类的对象数组来表示,通过改变下标值就可以访问到不同的对象。 对象数组的定义和使用: 对象数组的...
  • 二维数组与指针、指针数组数组指针的用法

    万次阅读 多人点赞 2018-03-12 18:16:20
    二维数组和指针⑴ 用指针表示二维数组元素。要用指针处理二维数组,首先要解决从存储的角度对二维数组的认识问题。我们知道,一个二维数组在计算机中存储时,是按照先行后列的顺序依次存储的,当把每一行看作一个...
  • 一维数组是一条线 二维数组是一页纸 三维数组是一本书 四维数组是书架 五维数组是图书室2201(好几个书架) 六维数组是图书馆某一层,2楼/3楼,好几个图书室 七维数组是整个图书馆 第N维数组是...
  • JavaScript清空数组的三种方法

    万次阅读 多人点赞 2018-05-20 20:17:42
    用length方法可以很轻松地清空数组,代码示例: var arr = [1,2,3]; console.log(arr); arr.length = 0; console.log(arr); 结果如下: 2、splise splice() 方法向/从数组中添加/删除项目,然后返回被...
  • python 数组添加数组_Python添加到数组

    万次阅读 2020-07-18 00:14:52
    python 数组添加数组Python doesn’t have any specific data type as an array. We can use List that has all the characteristics of an array. Python没有任何特定的数据类型作为数组。 我们可以使用具有数组...
  • es6 删除数组指定元素

    万次阅读 多人点赞 2018-12-14 14:46:14
    //后面的额id是数组的id,是不能随便写的,如果你数组里面写的是id,这里就写id,如果数组里面写的是num,那这里就写num , //=== 后面的id是你想要删除的元素的id号,同理,如果你数组里面写的是num,那这里...
  • 数组的三种定义方式

    万次阅读 多人点赞 2017-12-25 16:16:58
    1.数组的定义 用于存储同一类型数据的集合,其实数组就是一个容器。 连续的存储单元 2.数组的好处 自动给数组中的元素从零开始编号。自动给下标,从零开始0-1-2-3-…… 3.书写格式 元素类型[] 数组名 = new...
  • Python输入数组(一维数组、二维数组

    万次阅读 多人点赞 2018-08-09 20:14:34
    一维数组: arr = input("") //输入一个一维数组,每个数之间使空格隔开 num = [int(n) for n in arr.split()] //将输入每个数以空格键隔开做成数组 print(num) //打印数组 一维数组输入输出示例:  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,964,022
精华内容 1,985,608
关键字:

数组