精华内容
下载资源
问答
  • 数组的基本操作

    2013-06-06 04:03:25
    java数组的基本操作 查找最大元素 选择排序 优化选择排序 冒泡排序 交换数组元素
  • 下面小编就为大家带来一篇PHP数组的基本操作及遍历数组的经典操作实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java数组的基本操作方法整理,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 主要介绍了简单了解python数组的基本操作,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 原标题:Python Numpy 数组的基本操作示例Numpy是一个通用的数组处理包。它提供了一个高性能的多维数组对象,以及处理这些数组的工具。它是Python科学计算的基本包。Numpy除了具有明显的科学用途外,还可以作为通用...

    原标题:Python Numpy 数组的基本操作示例

    Numpy是一个通用的数组处理包。它提供了一个高性能的多维数组对象,以及处理这些数组的工具。它是Python科学计算的基本包。

    Numpy除了具有明显的科学用途外,还可以作为通用数据的高效多维容器。

    Numpy中的数组

    Numpy中的数组是一个元素表(通常是数字),所有元素都是相同的类型,由一个正整数元组索引。在Numpy中,数组的维数称为数组的秩。一个整数的元组给出了数组在每个维度上的大小,称为数组的形状。Numpy中的数组类称为ndarray。Numpy数组中的元素可以使用方括号访问,也可以使用嵌套Python列表初始化。

    创建一个Numpy数组

    Numpy中的数组可以通过多种方式创建,具有不同数量的秩,定义数组的大小。数组还可以使用各种数据类型(如列表、元组等)创建。合成阵列的类型由序列中元素的类型导出。

    注意:可以在创建数组时显式定义数组的类型。

    # Python程序

    # 数组的创建

    importnumpy asnp

    # 创建rank 1数组

    arr = np.array([1, 2, 3])

    print("Array with Rank 1: n",arr)

    # 创建rank 2数组

    arr = np.array([[1, 2, 3],

    [4, 5, 6]])

    print("Array with Rank 2: n", arr)

    # 从元组创建一个数组

    arr = np.array((1, 3, 2))

    print("nArray created using "

    "passed tuple:n", arr)

    输出如下:

    Array with Rank 1:

    [1 2 3]

    Array with Rank 2:

    [[1 2 3]

    [4 5 6]]

    Array created using passed tuple:

    [1 3 2]

    访问数组索引

    在numpy数组中,索引或访问数组索引可以通过多种方式完成。要打印一系列数组,请完成切片。切片数组是在新数组中定义一个范围,用于从原始数组中打印一系列元素。由于切片数组包含原始数组的一系列元素,因此在切片数组的帮助下修改内容会修改原始数组内容。

    #Pthon程序来演示

    #numpy数组中的索引

    importnumpy asnp

    #初始数组

    arr = np.array([[-1, 2, 0, 4],

    [4, -0.5, 6, 0],

    [2.6, 0, 7, 8],

    [3, -7, 4, 2.0]])

    print("Initial Array: ")

    print(arr)

    #打印数组的范围

    #使用切片方法

    sliced_arr = arr[:2, ::2]

    print("Array with first 2 rows and"

    " alternate columns(0 and 2):n", sliced_arr)

    #打印元素

    #specific Indices

    Index_arr = arr[[1, 1, 0, 3],

    [3, 2, 1, 0]]

    print("nElements at indices (1, 3), "

    "(1, 2), (0, 1), (3, 0):n", Index_arr)

    输出如下:

    Initial Array:

    [[-1. 2. 0. 4. ]

    [ 4. -0.5 6. 0. ]

    [ 2.6 0. 7. 8. ]

    [ 3. -7. 4. 2. ]]

    Array with first 2 rows and alternate columns(0 and 2):

    [[-1. 0.]

    [ 4. 6.]]

    Elements at indices (1, 3), (1, 2), (0, 1), (3, 0):

    [0. 6. 2. 3.]

    基本阵列操作

    在numpy中,数组允许可以在特定阵列或阵列组合上执行的各种操作。这些操作包括一些基本的数学运算以及一元和二元运算。

    #Pthon程序来演示

    #单个阵列的基本操作

    importnumpy asnp

    #定义数组1

    a = np.array([[1, 2],

    [3, 4]])

    # Defining Array 2

    b = np.array([[4, 3],

    [2, 1]])

    #向每个元素添加1

    print("Adding 1 to every element:", a + 1)

    # 每个元素减去2

    print("nSubtracting 2 from each element:", b - 2)

    # 数组元素和

    # 执行一元操作

    print("nSum of all array "

    "elements: ", a.sum)

    #添加两个数组

    #执行二进制操作

    print("nArray sum:n", a + b)

    输出如下:

    Adding 1 to every element: [[2 3]

    [4 5]]

    Subtracting 2 from each element: [[ 2 1]

    [ 0 -1]]

    Sum of all array elements: 10

    Array sum:

    [[5 5]

    [5 5]]

    Numpy中的数据类型

    每个Numpy数组都是一个元素表(通常是数字),都是相同的类型,由正整数元组索引。每个ndarray都有一个关联的数据类型(dtype)对象。此数据类型对象(dtype)提供有关阵列布局的信息。ndarray的值存储在缓冲区中,缓冲区可以被认为是可以由dtype对象解释的连续的存储器字节块。Numpy提供了大量可用于构造数组的数值数据类型。在创建数组时,Numpy尝试猜测数据类型,但构造数组的函数通常还包含一个可选参数来显式指定数据类型。

    构造数据类型对象

    在Numpy中,除非需要特定的数据类型,否则无需定义数组的数据类型。Numpy试图猜测构造函数中未预定义的数组的数据类型。

    #Python程序创建

    #数据类型对象

    importnumpy asnp

    #整数数据类型

    x = np.array([1, 2])

    print("Integer Datatype: ")

    print(x.dtype)

    #浮动数据类型

    x = np.array([1.0, 2.0])

    print("nFloat Datatype: ")

    print(x.dtype)

    # 强制数据类型

    x = np.array([1, 2], dtype = np.int64)

    print("nForcing a Datatype: ")

    print(x.dtype)

    Integer Datatype:

    int64

    Float Datatype:

    float64

    Forcing a Datatype:

    int64

    DataType数组上的数学运算

    在Numpy数组中,基本数学运算在数组上以元素方式执行。这些操作既可以作为操作符重载也可以作为函数应用。Numpy中提供了许多有用的函数,用于对数组执行计算,例如sum:用于添加数组元素,T:用于元素的转置等。

    #Python程序创建

    #数据类型对象

    importnumpy asnp

    #第一个数组

    arr1 = np.array([[4, 7], [2, 6]],

    dtype = np.float64)

    #第二个数组

    arr2 = np.array([[3, 6], [2, 8]],

    dtype = np.float64)

    #添加两个阵列

    Sum = np.add(arr1, arr2)

    print("Addition of Two Arrays: ")

    print(Sum)

    #添加所有数组元素

    #使用预定义的sum方法

    Sum1 = np.sum(arr1)

    print("nAddition of Array elements: ")

    print(Sum1)

    # 数组的平方根

    Sqrt = np.sqrt(arr1)

    print("nSquare root of Array1 elements: ")

    print(Sqrt)

    #数组转置

    #使用内置功能'T'

    Trans_arr = arr1.T

    print("nTranspose of Array: ")

    print(Trans_arr)

    输出如下:

    Addition of Two Arrays:

    [[ 7. 13.]

    [ 4. 14.]]

    Addition of Array elements:

    19.0

    Square root of Array1 elements:

    [[2. 2.64575131]

    [1.41421356 2.44948974]]

    Transpose of Array:

    [[4. 2.]

    [7. 6.]]

    更多Python相关信息见Python 专题页面 https://www.linuxidc.com/topicnews.aspx?tid=17

    Linux公社的RSS地址:https://www.linuxidc.com/rssFeed.aspx

    本文永久更新链接地址:https://www.linuxidc.com/Linux/2019-05/158506.htm返回搜狐,查看更多

    责任编辑:

    展开全文
  • Java数组的基本操作方法整理这篇文章主要介绍了Java数组的基本操作方法整理,是Java入门学习中的基础知识,需要的朋友可以参考下数组是具有相同数据类型的一组数据的集合,Java支持多为数组,一维数组的每个基本单元...

    Java数组的基本操作方法整理

    这篇文章主要介绍了Java数组的基本操作方法整理,是Java入门学习中的基础知识,需要的朋友可以参考下

    数组是具有相同数据类型的一组数据的集合,Java支持多为数组,一维数组的每个基本单元都是基本数据类型的数据,二维数组就是每个基本单元是一维数组的一维数组,以此类推,n维数组的每个基本单元都是n-1为数组的n-1维数组。下面以一维数组为例说明Java数组的用法。

    411c42131a974a5e77ac8562302a6ce3.png

    1、数组声明

    数组声明有如下两种形式(方括号的位置不同):

    int arr[];

    int[] arr2;

    2、数组初始化

    数组初始化也有两种形式,如下(使用new或不使用new):

    int arr[] = new int[]{1, 3, 5, 7, 9};

    int[] arr2 = {2, 4, 6, 8, 10};

    3、遍历数组

    遍历数组可用for/foreach,如下:

    public staTIc void main(String[] args) {

    int arr[] = new int[]{1, 3, 5, 7 ,9};

    int[] arr2 = {2, 4, 6, 8, 10};

    for (int i = 0; i 《 arr.length; ++i) {

    System.out.print(arr[i] + “\t”); // 1 3 5 7 9

    }

    for (int x: arr2) {

    System.out.print(x + “\t”); // 2 4 6 8 10

    }

    }

    4、Arrays.fill()填充数组

    使用Arrays类的静态方法,需要import包java.uTIl.Arrays,定义了许多重载方法。

    void fill(int[] a, int val)全部填充

    void fill(int[] a, int fromIndex, int toIndex, int val)填充指定索引的元素

    int[] arr3 = new int[5];

    for (int x: arr3) {

    System.out.print(x + “\t”); // 0 0 0 0 0 全部初始化为0

    }

    System.out.println();

    Arrays.fill(arr3, 10);

    for (int x: arr3) {

    System.out.print(x + “\t”); // 10 10 10 10 10 全部填充为10

    }

    System.out.println();

    Arrays.fill(arr3, 1, 3, 8);

    for (int x: arr3) {

    System.out.print(x + “\t”); // 10 8 8 10 10 填充指定索引

    }

    System.out.println();

    5、Arrays.sort()对数组排序

    void sort(int[] a)全部排序

    void sort(int[] a, int fromIndex, int toIndex)排序指定索引的元素

    int[] arr4 = {3, 7, 2, 1, 9};

    Arrays.sort(arr4);

    for (int x: arr4) {

    System.out.print(x + “\t”); // 1 2 3 7 9

    }

    System.out.println();

    int[] arr5 = {3, 7, 2, 1, 9};

    Arrays.sort(arr5, 1, 3);

    for (int x: arr5) {

    System.out.print(x + “\t”); // 3 2 7 1 9

    }

    System.out.println();

    283f446c96a641ace8faa3cea84f218b.png

    6、Arrays.copyOf()复制数组

    int[] copyOf(int[] original, int newLength)复制数组,指定新数组长度

    int[] copyOfRange(int[] original, int from, int to)复制数组,指定所复制的原数组的索引

    int[] arr6 = {1, 2, 3, 4, 5};

    int[] arr7 = Arrays.copyOf(arr6, 5); // 1 2 3 4 5

    int[] arr8 = Arrays.copyOfRange(arr6, 1, 3); // 2 3

    for (int x: arr7) {

    System.out.print(x + “\t”);

    }

    System.out.println();

    for (int x: arr8) {

    System.out.print(x + “\t”);

    }

    System.out.println();

    7、检查数组中是否包含某一个值

    String[] stringArray = { “a”, “b”, “c”, “d”, “e” };

    boolean b = Arrays.asList(stringArray).contains(“a”);

    System.out.println(b);

    // true

    先使用Arrays.asList()将Array转换成List《String》,这样就可以用动态链表的contains函数来判断元素是否包含在链表中。

    8、连接两个数组

    int[] intArray = { 1, 2, 3, 4, 5 };

    int[] intArray2 = { 6, 7, 8, 9, 10 };

    // Apache Commons Lang library

    int[] combinedIntArray = ArrayUTIls.addAll(intArray, intArray2);

    ArrayUTIls是Apache提供的数组处理类库,其addAll方法可以很方便地将两个数组连接成一个数组。

    45072cd31c4c5b305cb6f4a4044b56ec.png

    9、数组翻转

    int[] intArray = { 1, 2, 3, 4, 5 };

    ArrayUtils.reverse(intArray);

    System.out.println(Arrays.toString(intArray));

    //[5, 4, 3, 2, 1]

    依然用到了万能的ArrayUtils。

    10、从数组中移除一个元素

    int[] intArray = { 1, 2, 3, 4, 5 };

    int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array

    System.out.println(Arrays.toString(removed));

    展开全文
  • 涉及到数组的基本操作:初始化,赋值,定位,销毁等 代码: 头文件“SeqArray.h" #pragma once #define MaxArraySize 3 #include<stdarg.h> #include <stdio.h> #include<stdlib.h> typedef st....

    问题:

    利用数组的基本运算队数组进行初始化,然后输出数组的值

    涉及到数组的基本操作:初始化,赋值,定位,销毁等

    代码:

    头文件“SeqArray.h"

    #pragma once
    #define  MaxArraySize 3
    #include<stdarg.h>
    #include <stdio.h>
    #include<stdlib.h>
    
    
    typedef struct
    {
    	DataType *base;
    	int  dim;// 数组的维数
    	int *bounds; // 数组的每一位界限间的地址
    	int *constants; //数组存储映像常量地址,里面的数据用来数组元素定位
    
    
    }Array;
    
    int InitArray(Array *A, int dim, ...)
    /*初始化数组,根据数组的维数和各维的长度构造一个数组,为数组的所有元素分配内存单元,确定每一维的界限
    地址,便于以后为数组赋值和获取数组中的元素,构造成功则返回1*/
    {
    	int i;
    	int ElemTotal = 1;
    	va_list ap;
    	if (dim < 1 || dim >MaxArraySize)
    	{
    		return 0;
    	}
    	A->dim = dim;
    	A->bounds = (int*)malloc(dim * sizeof(int));
    	if (!A->bounds)
    		exit(-1);
    	va_start(ap, dim);
    	for (i = 0; i < dim; i++)
    	{
    		A->bounds[i] = va_arg(ap, int);//依次获得各维参数,即各维的长度
    		if (A->bounds[i] < 0)
    			return -1;
    		ElemTotal *= A->bounds[i];
    	}
    	va_end(ap);
    	A->base = (DataType*)malloc(ElemTotal * sizeof(DataType)); // 为数组所有元素分配空间
    	if (!A->base)
    		exit(-1);
    	A->constants = (int*)malloc(dim * sizeof(int));//为数组的常量基址分配内存单元
    	if (!A->constants)
    		exit(-1);
    	A->constants[dim - 1] = 1;
    	for (i = dim - 2; i >= 0; i--)
    	{
    		A->constants[i] = A->bounds[i + 1] * A->constants[i + 1];
    	}
    	return 1;
    }
    
    int LocateArray(Array A, va_list ap, int *offset)
    /*根据数组中元素的下标,求出该元素在数组中的相对位置*/
    {
    	int i, instand;
    	*offset = 0;
    	for (i = 0; i < A.dim; i++)
    	{
    		instand = va_arg(ap, int);//一个一个把取值出来
    		if (instand < 0 || instand >= A.bounds[i])
    			return 0;
    		*offset += A.constants[i] * instand;
    
    	}
    	return 1;
    }
    
    int  AssignValue(Array A, DataType e, ...)
    /*数组的赋值操作,将e的值赋给指定的数组元素,...为坐标*/
    {
    	va_list ap;//指向可变参数的指针
    	va_start(ap, e);//ap指向e的下一个参数。。。
    	int offset;
    	if (LocateArray(A, ap, &offset) == 0)
    		return 0;
    	va_end(ap);
    	*(A.base + offset) = e;
    	return 1;
    }
    
    int GetValue(DataType *e, Array A, ...)
    /*返回数组中指定的元素*/
    {
    	va_list ap;
    	int offset;
    	va_start(ap, A);
    	if (LocateArray(A, ap, &offset) == 0)
    		return -1;
    	va_end(ap);
    	(*e) = *(A.base+offset);
    	return 1;
    
    }
    
    void DestroyArray(Array *A)
    /*销毁数组*/
    {
    	if (A->base)
    		free(A);
    	if (A->bounds)
    		free(A->bounds);
    	if (A->constants)
    		free(A->constants);
    	A->base = A->constants = A->bounds = NULL;
    	A->dim = 0;
    }
    

    源文件

    // SeqArray.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //利用数组的基本运算队数组进行初始化,然后输出数组的值
    
    #include "pch.h"
    #include <iostream>
    typedef int DataType;
    #include"SeqArray.h"
    
    
    int main()
    {
    	Array A;
    	int i, j, k;
    	int dim = 3;
    	int bound1 = 5, bound2 = 3, bound3 = 2;//初始化数组的维数和各维的长度
    	DataType e;
    	InitArray(&A, dim, bound1, bound2, bound3);
    	std::cout << "数组A的各维长度是:\n";
    	for (i = 0; i < dim; i++)
    	{
    		printf("%3d", A.bounds[i]);
    	}
    	printf("\n");
    	std::cout << "数组A的常量基值是:";
    	for (i = 0; i < dim; i++)
    	{
    		printf("%3d", A.constants[i]);
    	}
    	printf("\n");
    	printf("数组A[%d][%d][%d]的元素如下", bound1, bound2, bound3);
    	for (i = 0; i < bound1; i++)
    	{
    		for (j = 0; j < bound2; j++)
    		{
    			for (k = 0; k < bound3; k++)
    			{
    				AssignValue(A, 100 * i + 10 * j + k, i, j, k);
    				GetValue(&e, A, i, j, k);//把该元素赋值e
    				printf("A[%d][%d][%d] = %3d   ", i, j, k, e);
    			}
    			printf("\n");
    		}
    		printf("\n");
    	}
    
    	printf("按照数组的先行序列输出元素,利用基地址输出元素:\n");
    	for (i = 0; i < bound1*bound2*bound3; i++)
    	{
    		printf("第%d个元素 = %3d\t", i + 1, *(A.base + i));
    		if ((i + 1) % bound2 == 0)
    			printf("\n");
    	}
    	DestroyArray(&A);
    }
    
    

    在这里插入图片描述

    展开全文
  • 数组的基本操作方法

    千次阅读 2019-06-25 08:59:07
    数组的基本操作 1、往数组中添加一个元素: push方法(在尾部添加)unshift方法(在头部添加) 二者均返回数组长度 2、从数组中删除一个元素: pop() 方法(在尾部删除)shift() 方法(在头部删除) 二者均...

    数组的基本操作

    1、往数组中添加一个元素:
    push方法(在尾部添加)unshift方法(在头部添加)
    二者均返回数组长度

    2、从数组中删除一个元素:
    pop() 方法(在尾部删除)shift() 方法(在头部删除)
    二者均返回删除元素在这里插入图片描述
    总结:push()、pop()、shift()、unshift()都会改变原数组
    3、提取数组中的一部分
    slice() 方法:slice(开始位置,结束位置)
    若只有一个参数,即无结束位置参数,则从开始到结束
    若结束位置大于开始位置,则返回空数组

    其中计算时不包括结束位置,不改变原素组,返回提取的新数组
    当位置上的数字为正时:
    在这里插入图片描述
    当位置上的数字小于0时:
    在这里插入图片描述
    最后,原数组不改变
    在这里插入图片描述
    4、删除数组中的一部分元素
    最终操作的结果会改变原数组
    splice()方法:splice(开始位置,删除个数)返回删除的元素
    在这里插入图片描述
    splice(开始位置,删除个数,插入元素)
    负数表示从倒数开始计算
    在这里插入图片描述
    5、reverse()
    将数组中的元素逆转放置,操作改变原数组
    在这里插入图片描述
    6、sort()
    sort() 方法用于对数组的元素进行排序。
    请注意,下面的代码没有按照数值的大小对数字进行排序,而是按照字典进行排序
    操作会改变原数组
    在这里插入图片描述
    7、join()
    join() 方法用于把数组中的所有元素放入一个字符串。
    元素是通过指定的分隔符进行分隔的。
    若括号里什么都不写,则默认用逗号分隔
    若是引号,则空白分隔
    在这里插入图片描述
    在这里插入图片描述
    8、for…in 遍历数组
    在这里插入图片描述
    for in 会遍历数组内所有可枚举的属性,包括原型上的属性和方法,如下:
    在这里插入图片描述
    所以,for in更适合遍历对象,尽量不要使用for in 遍历数组
    使用for in 遍历对象时,index为该对象的键,Object[index]能取到每个键对应的值,来看下面的例子:
    在这里插入图片描述
    9、concat() (连接两个或多个数组)
    concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组,而仅仅会返回被连接数组的一个副本。在没有给 concat()方法传递参数的情况下,它只是复制当前数组并返回副本。

    <script>
    	var arr=[1,2,3,4];
    	var arr2=[11,12,13] 
    	var arrCopy = arr.concat(arr2);
    	console.log(arr.concat()); // [1, 2, 3, 4] (复制数组)
    	console.log(arrCopy); // [1, 2, 3, 4, 11, 12, 13]
    	console.log(arr); // [1, 2, 3, 4] (原数组未改变)
    </script>
    

    如果传入的参数是一个二维数组呢?

    <script>
    	var arr=[1,2,3,4];
    	var arr2=[11,[12,13]] 
    	var arrCopy = arr.concat(arr2);	
    	console.log(arrCopy); // [1, 2, 3, 4, 11, Array(2)]
    	console.log(arr); // [1, 2, 3, 4] (原数组未改变)
    </script>
    

    从上面代码中可以看出concat方法只能将传入数组中的每一项添加到数组中,如果传入数组中有些项是数组,那么也会把这一数组项当作一项添加到arrCopy中。

    9、map()函数

    和foreach类似,此方法是将数组中的每个元素调用一个提供的函数,结果作为一个新的数组返回,并没有改变原来的数组,(map也会把数组的每一项都遍历一遍),值得注意的是,map不会对空数组进行检测
    在这里插入图片描述
    5个迭代方法:forEach()、map()、filter()、some()、every()
    10、foreach()函数
    foreach会从头到尾对数组里的每个元素遍历一遍 ,他不会生成新数组,也不改变原数组,回调函数接收三个值,分别是 数组的元素,索引和当前数组。
    在这里插入图片描述

    11、Array.map()

    map() 方法返回一个新数组,数组中的元素为原始数组元素调用函数处理后的值。
    map() 方法按照原始数组元素顺序依次处理元素。
    注意: map() 不会对空数组进行检测。
    注意: map() 不会改变原始数组。

    12、filter()函数
    filter为过滤的意思,也就是说它会把满足条件的元素拿出来形成一个新的数组
    在这里插入图片描述
    13、Array.every()
    接收参数:array.every(function(currentValue,index,arr), thisValue)

    thisValue :可选。对象作为该执行回调时使用,传递给函数,用作 “this” 的值。
    如果省略了 thisValue ,“this” 的值为 “undefined”

    此方法是将所有元素进行判断返回一个布尔值,如果所有元素都满足判断条件,则返回true,否则为false:

    	let arr = [1, 2, 3, 4, 5]
        const h1 = value => value < 4
        const h2 = value => value < 6
        arr.every(h1 ) //false
        arr.every(h2 ) //true
    

    14、Array.some()

    此方法是将所有元素进行判断返回一个布尔值,如果存在元素都满足判断条件,则返回true,若所有元素都不满足判断条件,则返回false:

    	let arr= [1, 2, 3, 4, 5]
        const h1 = value => value < 4
        const h2 = value => value > 6
        arr.some(h1) //true
        arr.some(h2 ) //false
    

    15、Array.reduce()

    此方法是所有元素调用返回函数,返回值为最后结果,传入的值必须是函数类型:

       let arr = [1, 2, 3, 4, 5]
       const add = (a, b) => a + b
       let sum = arr.reduce(add)
       //sum = 15  相当于累加的效果
    

    与之相对应的还有一个 Array.reduceRight() 方法,区别是这个是从右向左操作的

    16、Array.indexOf(item,start)

    indexOf() 方法可返回数组中某个指定的元素位置。
    该方法将从头到尾地检索数组,看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头(没有指定 start 参数时)。如果找到一个 item,则返回 item 的第一次出现的位置。开始位置的索引为 0。
    如果在数组中没找到指定元素则返回 -1。

    var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
    var a = fruits.indexOf("Apple",4); //结果为 6
    

    17、Array.lastIndexOf(item,start)

    lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置,从该字符串的后面向前查找。
    如果要检索的元素没有出现,则该方法返回 -1。
    该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾(没有指定 start 参数时)。如果找到一个 item,则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。
    如果在数组中没找到指定元素则返回 -1。

    Es6新增数组方法:
    1、Array.fill()
    fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

    • arr.fill(value[, start[, end]])

      value
      用来填充数组元素的值。
      start 可选
      起始索引,默认值为0。
      end 可选
      终止索引,默认值为 this.length。

    例子
    [1, 2, 3].fill(4); // [4, 4, 4]
    [1, 2, 3].fill(4, 1); // [1, 4, 4]
    [1, 2, 3].fill(4, 1, 2); // [1, 4, 3]
    [1, 2, 3].fill(4, 1, 1); // [1, 2, 3]
    [1, 2, 3].fill(4, 3, 3); // [1, 2, 3]
    [1, 2, 3].fill(4, -3, -2); // [4, 2, 3]
    [1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3]
    [1, 2, 3].fill(4, 3, 5); // [1, 2, 3]
    Array(3).fill(4); // [4, 4, 4]
    [].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3}

    // Objects by reference.
    var arr = Array(3).fill({}) // [{}, {}, {}];
    arr[0].hi = “hi”; // [{ hi: “hi” }, { hi: “hi” }, { hi: “hi” }]

    展开全文
  • js数组的基本操作
  • js中数组的基本操作

    2017-06-12 15:45:49
    1.数组的基本操作前言:ECMAScript数组是很常用的一种数据类型,在其他的语言中,数组也是很常用很重要的一种数据类型.但ECMAScript数组有些地方还是有自己的特点的,如下:1)数组的每一项可以保存任何数据类型的数据,也...
  • 本节课程,我们学习数组的基本操作数组的基本操作包含:数组元素的输入输出、插入和删除元素、查询等。数组元素的输入在数组声明后,数组元素的值均为其数据类型的初始值,比如数值型初始值为0。因此,通常在正式...
  • 1. 数组的基本操作 1)定长数组 数组的概念和C,JAVA中的数组是一样的, 都是存储同一种类型的元素。定长数组存储一定长度的数组。  //声明一个数组,类型为Int,元素个数为10.   val nums = new ...
  • 一、数组的基本操作 java.util 包的 Arrays 类包含了用来操作数组(如排序和搜索)的各种方法。 1.1 遍历数组 遍历数组就是获取数组中的每个元素。通常遍历数组都是使用 for 循环来实现。 遍历二维数组需使用...
  • numpy数组 NumPy中最重要的一个特点就是其N维数组对象,既ndarray(别名array)对象,该对象可以执行一些科学计算 Ndarray对象中定义了一些重要的元素 创建NumPy数组 ...查看数组的信息 ...查看数组的数据类...
  • 这里写自定义目录标题JavaScript的数组操作数组的连接数组的排序数组的倒置数组的插入数组的删除数组同时添加和删除数组的截取数组转字符串 本人新手一枚,有错还请指出来,共同进步!!! JavaScript的数组操作 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,682
精华内容 7,872
关键字:

数组的基本操作