array_arraylist - CSDN
array 订阅
数组(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。
收起全文
  • 为什么要用numpy  Python中提供了list容器,可以当作数组使用。但列表中的元素可以是任何对象,... Python虽然也提供了array模块,但其只支持一维数组,不支持多维数组(在TensorFlow里面偏向于矩阵理解),也...

     

    为什么要用numpy

        Python中提供了list容器,可以当作数组使用。但列表中的元素可以是任何对象,因此列表中保存的是对象的指针,这样一来,为了保存一个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说,这种结构显然不够高效。
        Python虽然也提供了array模块,但其只支持一维数组,不支持多维数组(在TensorFlow里面偏向于矩阵理解),也没有各种运算函数。因而不适合数值运算。
        NumPy的出现弥补了这些不足。

    (——摘自张若愚的《Python科学计算》)

    import numpy as np

     

    数组创建

    ## 常规创建方法
    a = np.array([2,3,4])
    b = np.array([2.0,3.0,4.0])
    c = np.array([[1.0,2.0],[3.0,4.0]])
    d = np.array([[1,2],[3,4]],dtype=complex) # 指定数据类型
    print a, a.dtype
    print b, b.dtype
    print c, c.dtype
    print d, d.dtype

     

    [2 3 4] int32
    [ 2.  3.  4.] float64
    [[ 1.  2.]
     [ 3.  4.]] float64
    [[ 1.+0.j  2.+0.j]
     [ 3.+0.j  4.+0.j]] complex128

     

    数组的常用函数
    print np.arange(0,7,1,dtype=np.int16) # 0为起点,间隔为1时可缺省(引起歧义下不可缺省)
    print np.ones((2,3,4),dtype=np.int16) # 2页,3行,4列,全1,指定数据类型
    print np.zeros((2,3,4)) # 2页,3行,4列,全0
    print np.empty((2,3)) #值取决于内存
    print np.arange(0,10,2) # 起点为0,不超过10,步长为2
    print np.linspace(-1,2,5) # 起点为-1,终点为2,取5个点
    print np.random.randint(0,3,(2,3)) # 大于等于0,小于3,2行3列的随机整数

     

    [0 1 2 3 4 5 6]
    [[[1 1 1 1]
      [1 1 1 1]
      [1 1 1 1]]

     [[1 1 1 1]
      [1 1 1 1]
      [1 1 1 1]]]
    [[[ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]]

     [[ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]]]
    [[  1.39069238e-309   1.39069238e-309   1.39069238e-309]
     [  1.39069238e-309   1.39069238e-309   1.39069238e-309]]
    [0 2 4 6 8]
    [-1.   -0.25  0.5   1.25  2.  ]
    [[1 0 1]
     [0 1 0]]

     

     类型转换
    print float(1)
    print int(1.0)
    print bool(2)
    print float(True)

      

    1.0
    1
    True
    1.0

      

    数组输出

        从左到右,从上向下
        一维数组打印成行,二维数组打印成矩阵,三维数组打印成
    矩阵列表

    print np.arange(1,6,2)
    print np.arange(12).reshape(3,4) # 可以改变输出形状
    print np.arange(24).reshape(2,3,4)# 2页,3行,4页

      

    [1 3 5]
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]

     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]

     

    基本运算

    ## 元素级运算
    a = np.array([1,2,3,4])
    b = np.arange(4)
    print a, b
    print a-b
    print a*b
    print a**2
    print 2*np.sin(a)
    print a>2
    print np.exp(a) # 指数

       

    [1 2 3 4] [0 1 2 3]
    [1 1 1 1]
    [ 0  2  6 12]
    [ 1  4  9 16]
    [ 1.68294197  1.81859485  0.28224002 -1.51360499]
    [False False  True  True]
    [  2.71828183   7.3890561   20.08553692  54.59815003]

     

    ## 矩阵运算(二维数组)
    a = np.array([[1,2],[3,4]]) # 2行2列
    b = np.arange(6).reshape((2,-1)) # 2行3列
    print a,b
    print a.dot(b) # 2行3列

     

    [[1 2]
     [3 4]] [[0 1 2]
     [3 4 5]]
    [[ 6  9 12]
     [12 19 26]]

     

    ## 非数组运算,调用方法
    a = np.random.randint(0,5,(2,3))
    print a
    print a.sum(),a.sum(axis=1),a.sum(0) # axis用于指定运算轴(默认全部,可指定0或1)
    print a.min(),a.max(axis=1),a.mean(axis=1) # axis = 0: 按列计算,axis = 1: 按行计算
    print a.cumsum(1) # 按行计算累积和

     

    [[2 3 3]
     [0 2 1]]
    11 [8 3] [2 5 4]
    0 [3 2] [ 2.66666667  1.        ]
    [[2 5 8]
     [0 2 3]]

     

    索引,切片,迭代

    ## 一维数组
    a = np.arange(0,10,1)**2
    print a
    print a[0],a[2],a[-1],a[-2] # 索引从0开始,-1表示最后一个索引
    print a[2:5],a[-5:-1] # 包括起点,不包括终点
    a[-1] = 100; print a # 赋值
    a[1:4]=100; print a # 批量赋值
    a[:6:2] = -100; print a # 从开始到第6个索引,每隔一个元素(步长=2)赋值
    print a[: :-1];print a # 将a逆序输出,a本身未发生改变
    b = [np.sqrt(np.abs(i)) for i in a]; print b # 通过遍历赋值

      

    [ 0  1  4  9 16 25 36 49 64 81]
    0 4 81 64
    [ 4  9 16] [25 36 49 64]
    [  0   1   4   9  16  25  36  49  64 100]
    [  0 100 100 100  16  25  36  49  64 100]
    [-100  100 -100  100 -100   25   36   49   64  100]
    [ 100   64   49   36   25 -100  100 -100  100 -100]
    [-100  100 -100  100 -100   25   36   49   64  100]
    [10.0, 10.0, 10.0, 10.0, 10.0, 5.0, 6.0, 7.0, 8.0, 10.0]

      

    ## 多维数组
    a = np.arange(0,20).reshape((4,5))
    print a, a[2,3], a[:,1], a[1:4,2], a[1:3,:]
    print a[-1] # 相当于a[-1,:],即索引少于轴数时,确实的索引默认为整个切片

    b = np.arange(0,24).reshape((2,3,4))
    print b,b[1] # 相当于b[1,:,:] 和b[1,...]
    print '-------------------'
    for row in a:
        print row # 遍历以第一个轴为基础

     

    [[ 0  1  2  3  4]
     [ 5  6  7  8  9]
     [10 11 12 13 14]
     [15 16 17 18 19]] 13 [ 1  6 11 16] [ 7 12 17] [[ 5  6  7  8  9]
     [10 11 12 13 14]]
    [15 16 17 18 19]
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]

     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]

     [[12 13 14 15]
     [16 17 18 19]
     [20 21 22 23]]
    -------------------
    [0 1 2 3 4]
    [5 6 7 8 9]
    [10 11 12 13 14]
    [15 16 17 18 19]

      

    形状操作

    a = np.floor(10*np.random.random((3,4)))
    print a, a.shape #输出a的形状
    print a.ravel() # 输出平坦化后的a(a本身不改变)
    a.shape = (6,2); print a # 改变a的形状
    print a.transpose() # 输出a的转置

     

    [[ 0.  4.  3.  2.]
     [ 1.  1.  3.  3.]
     [ 4.  4.  6.  5.]] (3, 4)
    [ 0.  4.  3.  2.  1.  1.  3.  3.  4.  4.  6.  5.]
    [[ 0.  4.]
     [ 3.  2.]
     [ 1.  1.]
     [ 3.  3.]
     [ 4.  4.]
     [ 6.  5.]]
    [[ 0.  3.  1.  3.  4.  6.]
     [ 4.  2.  1.  3.  4.  5.]]

     

    ## 补充:reshape和resize
    a = np.array([[1,2,3],[4,5,6]])
    b = a
    a.reshape((3,2))# 不改变数组本身的形状
    print a
    b.resize((3,2))# 改变数组本身形状
    print b

      

    [[1 2 3]
     [4 5 6]]
    [[1 2]
     [3 4]
     [5 6]]

    ---------------------

      在numpy模块中,我们经常会使用resize 和 reshape,在具体使用中,通常是使用resize改变数组的尺寸大小,使用reshape用来增加数组的维度。

    1.resize

    之前看到别人的博客说,resize没有返回值,其实这取决于你如何使用resize,resize有两种使用方式,一种是没有返回值的,直接对原始的数据进行修改,还有一种用法是有返回值的,所以不会修改原有的数组值。

    1.1有返回值,不对原始数据进行修改

        import numpy as np
        X=np.array([[1,2,3,4],
                      [5,6,7,8],
                      [9,10,11,12]])
         
        X_new=np.resize(X,(3,3)) # do not change the original X
        print("X:\n",X)  #original X
        print("X_new:\n",X_new) # new X
         
        >>
        X:
         [[ 1  2  3  4]
         [ 5  6  7  8]
         [ 9 10 11 12]]
        X_new:
         [[1 2 3]
         [4 5 6]
         [7 8 9]]

    1.2 无返回值,直接修改原始数组的大小

        import numpy as np
        X=np.array([[1,2,3,4],
                      [5,6,7,8],
                      [9,10,11,12]])
         
        X_2=X.resize((3,3))  #change the original X ,and do not return a value
        print("X:\n",X)  # change the original X
        print("X_2:\n",X_2) # return None
         

         
        X:
         [[1 2 3]
         [4 5 6]
         [7 8 9]]
        X_2:
         None


    2.reshape

    给数组一个新的形状而不改变其数据

        import numpy as np
        X=np.array([1,2,3,4,5,6,7,8])
         
        X_2=X.reshape((2,4)) #retuen a 2*4 2-dim array
        X_3=X.reshape((2,2,2)) # retuen a 2*2*2 3-dim array
         
        print("X:\n",X)
        print("X_2:\n",X_2)
        print("X_3:\n",X_3)
         
        >>
        X:
         [1 2 3 4 5 6 7 8]
        X_2:
         [[1 2 3 4]
         [5 6 7 8]]
        X_3:
         [[[1 2]
          [3 4]]
         
         [[5 6]
          [7 8]]]
    ---------------------
    作者:墨晓白
    原文:https://blog.csdn.net/qq_24193303/article/details/80965274
     

    展开全文
  • Array

    2020-04-09 20:04:43
    存储具有一对一逻辑关系数据的存储顺序结构。 数组最大的优点:快速查询,最好应用于...bool Array<T>::add(const int index, const T& e) { if (index<0 || index>size)return false; //判断索...
    • 存储具有一对一逻辑关系数据的存储顺序结构
    • 数组最大的优点:快速查询,最好应用于索引有语义的情况。
      在这里插入图片描述

    插入元素

    在这里插入图片描述

    template<typename T>
    bool Array<T>::add(const int index, const T& e) 
    {
    	if (index<0 || index>size)return false;		//判断索引是否正确
    	if (size == capacity)resize(1.5 * capacity);	//判断空间是否足够,不够扩容为当前的2倍
    	for (int i = size - 1; i >= index; --i)		//从后向前循环
    	{
    		data[i + 1] = data[i];					//全部元素向后移一位
    	}
    	data[index] = e;							//插入元素	
    	++size;										//数组元素的个数+1
    	return true;
    }
    

    扩容与缩减

    在这里插入图片描述

    template<typename T>
    void Array<T>::resize(const int newcapacity)
    {
    	T* newdata = new T[newcapacity];	//创建新的传入大小数组空间
    	for (int i = 0; i < size; ++i)	//把原本的数组元素放入新的数组空间
    	{
    		newdata[i] = data[i];
    	}
    	data = newdata;		//把原本的数组指向新的数组
    	capacity = newcapacity;	//新的空间大小给原本的空间大小
    	newdata = nullptr;	//把新数组置为空
    	delete[] newdata;	//释放新数组
    }
    

    删除元素

    在这里插入图片描述

    template<typename T>
    T Array<T>::remove(const int index)	
    {
    	if (index<0 || index>size)return -1;	//判断索引是否正确
    	T ret = data[index];					//保存临时元素
    	for (int i = index + 1; i < size; ++i)	
    	{
    		data[i - 1] = data[i];				//从要插入的元素后一位所有元素向前移一位
    	}
    	--size;	//元素个数-1
    	if (size == capacity / 4 && capacity / 2 != 0)	//判断元素个数是否为数组容量的1/4并且数组空间不为0
    	{
    		resize(capacity / 2);	//调用resize传入当前容量的一半
    	}
    	return ret;		//返回被删除的元素
    }
    

    时间复杂度

    在这里插入图片描述

    均摊复杂度

    在这里插入图片描述
    在这里插入图片描述
      9次addLast操作,触发resize,总共进行了17次基本操作,平均每次addLast操作,进行2次基本操作。

      假设capacity = n,n+1次addLast,触发resize,总共进行2n+1次基本操作,平均每次addLast操作进行2次基本操作。

      这样均摊计算时间复杂度是O(1),同理removeLast操作,均摊复杂度也为O(1)。

    代码清单

    Array.h
    #pragma once
    #include<iostream>
    template<typename T>
    class Array
    {
    public:
    	//无参构造
    	Array() :size(0), capacity(10)	
    	{
    		data = new T[10];	//默认初始化10个空间
    	}
    	//有参构造
    	Array(int capacity) :size(0), capacity(capacity)
    	{
    		data = new T[capacity];
    	}
    	//返回元素个数
    	int getSize()const;
    	//返回数组容量
    	int getCapacity()const;
    	//返回第一个元素
    	T getFirst();
    	//返回最后一个元素
    	T getLast();
    	//判断是否为空
    	bool isEmpty()const;
    	//插入元素
    	bool add(const int index, const T& e);
    	//头插
    	bool addFirst(const T& e);
    	//尾插
    	bool addLast(const T& e);
    	//查找数组中是否存在该元素
    	bool contains(const T& e)const;
    	//查找数组中元素的索引,不存在返回-1
    	int find(const T& e)const; 
    	//删除索引元素,返回删除元素
    	T remove(const int index);
    	//删除头,返回头
    	T removeFirst();
    	//删除尾,返回尾
    	T removeLast();
    	//设置索引值
    	bool set(const int index, const T& e);
    	//获取索引值
    	T get(const int index)const;
    	//打印元素
    	void print()const;
    	//释放空间
    	~Array();
    private:
    	void resize(const int newcapacity);	//重新分配空间
    	T* data;
    	int size;	//数组大小
    	int capacity;	//数组容量
    };
    
    template<typename T>
    int Array<T>::getSize() const
    {
    	return size;	//返回数组长度	
    }
    
    template<typename T>
    int Array<T>::getCapacity() const
    {
    	return capacity;	//返回数组容量
    }
    
    template<typename T>
    inline T Array<T>::getFirst()
    {
    	return get(0);
    }
    
    template<typename T>
    inline T Array<T>::getLast()
    {
    	return get(size - 1);
    }
    
    template<typename T>
    bool Array<T>::isEmpty() const
    {
    	return size == 0;	//判断是否为空,
    }
    
    template<typename T>
    bool Array<T>::add(const int index, const T& e) 
    {
    	if (index<0 || index>size)return false;		//判断索引是否正确
    	if (size == capacity)resize(2 * capacity);	//判断空间是否足够,不够扩容为当前的2倍
    	for (int i = size - 1; i >= index; --i)		//从后向前循环
    	{
    		data[i + 1] = data[i];					//全部元素向后移一位
    	}
    	data[index] = e;							//插入元素	
    	++size;										//数组元素的个数+1
    	return true;
    }
    
    template<typename T>
    bool Array<T>::addFirst(const T& e) 
    {
    	return add(0, e);	//调用add从0号索引元素插入
    }
    
    template<typename T>
    bool Array<T>::addLast(const T& e)
    {
    	return add(size, e);	//调用add从size号索引元素插入
    }
    
    template<typename T>
    bool Array<T>::contains(const T& e) const
    {
    	for (int i = 0; i < size; ++i)	//遍历是否有查找的元素
    	{
    		if (data[i] == e)return true;	
    	}
    	return false;
    }
    
    template<typename T>
    int Array<T>::find(const T& e) const
    {
    	for (int i = 0; i < size; ++i)	//遍历是否有查找的元素,有返回索引,无返回-1
    	{
    		if (data[i] == e)return i;	
    	}
    	return -1;
    }
    
    template<typename T>
    T Array<T>::remove(const int index)	
    {
    	if (index<0 || index>size)return -1;	//判断索引是否正确
    	T ret = data[index];					//保存临时元素
    	for (int i = index + 1; i < size; ++i)	
    	{
    		data[i - 1] = data[i];				//从要插入的元素后一位所有元素向前移一位
    	}
    	--size;	//元素个数-1
    	if (size == capacity / 4 && capacity / 2 != 0)	//判断元素个数是否为数组容量的1/4并且数组空间不为0
    	{
    		resize(capacity / 2);	//调用resize传入当前容量的一半
    	}
    	return ret;		//返回被删除的元素
    }
    
    template<typename T>
    T Array<T>::removeFirst()		
    {
    	return remove(0);		//删除0号索引元素
    }
    
    template<typename T>
    T Array<T>::removeLast() 
    {
    	return remove(size - 1);	//删除size-1号索引元素
    }
    
    template<typename T>
    bool Array<T>::set(const int index, const T& e)
    {
    	if (index<0 || index>size)return false;	//判断索引元素是否正确
    	data[index] = e;						//设置索引的新元素
    	return true;
    }
    
    template<typename T>
    T Array<T>::get(const int index) const
    {
    	if (index<0 || index>size)return -1;	//判断索引元素是否正确
    	return data[index];						//返回索引元素
    }
    
    template<typename T>
    void Array<T>::print() const
    {
    	std::cout << "Array:size = " << size << "	Array:capacity = " << capacity << std::endl;
    	std::cout << "Array:data = " << "[";
    	for (int i = 0; i < size; ++i)
    	{
    		std::cout << data[i] << ",";
    	}
    	std::cout << "]" << std::endl;
    }
    
    template<typename T>
    Array<T>::~Array()
    {
    	delete[] data;	//释放空间
    	data = nullptr;
    }
    
    template<typename T>
    void Array<T>::resize(const int newcapacity)
    {
    	T* newdata = new T[newcapacity];	//创建新的传入大小数组空间
    	for (int i = 0; i < size; ++i)	//把原本的数组元素放入新的数组空间
    	{
    		newdata[i] = data[i];
    	}
    	data = newdata;		//把原本的数组指向新的数组
    	capacity = newcapacity;	//新的空间大小给原本的空间大小
    	newdata = nullptr;	//把新数组置为空
    	delete[] newdata;	//释放新数组
    }
    
    main.cpp
    #include"Array.h"
    using namespace std;
    
    int main()
    {
    	Array<int>* arr = new Array<int>(10);
    	for (int i = 0; i < 10; ++i)
    	{
    		arr->addLast(i);
    	}
    	arr->print();
    	cout << endl;
    	cout << "arr->add(1, 1)" << arr->add(1, 1) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->addLast(0) " << arr->addLast(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->addFirst(0)" << arr->addFirst(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->contains(0)" << arr->contains(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->find(0)" << arr->find(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->get(1)" << arr->get(1) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->set(0, 5)" << arr->set(0, 5) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getCapacity()" << arr->getCapacity() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getSize()" << arr->getSize() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->isEmpty()" << arr->isEmpty() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->remove(1)" << arr->remove(1) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->removeFirst()" << arr->removeFirst() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->removeLast()" << arr->removeLast() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getFirst" << arr->getFirst() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getLast" << arr->getLast() << endl;
    	arr->print();
    
    	delete arr;
    	return 0;
    }
    
    展开全文
  • Array [] 数组

    2018-08-13 15:46:44
    Array 数组 数组是指一组数据的集合,(容器)数组中的每个数据称为元素。在Java中,数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引 用类),但同一个数组里只能存放类型相同的元素。长度不可变...

    java.util.Arrays类

    ※ Array 数组

    数组是指一组数据的集合,(容器)数组中的每个数据称为元素。在Java中,数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引
    用类),但同一个数组里只能存放类型相同的元素。长度不可变,构建时会有默认值(JVM)创建数组大致包括如下步骤:

    . 声明一个数组类型的引用变量,简称为数组变量;
    . 用new语句构造数组的实例。new语句为数组分配内存,并且为数组中的每个元素赋予默认值;
    . 初始化,即为数组的每个元素设置合适的初始值。

    声明/创建/初始化赋值
    基本数据类型的声明
    int[] n;
    int n[];
    引用类型的声明
    Student[] stuff; Student是类名,[]存的是地址值
    Student stuff[];

    本章的主要内容:

    . 数组的创建,包括基本类型数组的创建和类类型数组的创建;
    . 访问数组的元素和长度属性;
    . 创建一个数组的数组;

    我之前已经接触过数组了,就是主函数(main方法)中的参数:
    public static void main(String[] args){

    }

    一. 数组变量的声明;

    声明数组:
    1) 一个存放同一类型数据的集合
    a. 即可以是基本类型,也可以是对象类型;
    b. 数组中的每个数据为元素;
    2) 数组是一个对象,成员是数组长度和数组中的元素;
    3) 声明了一个数组变量并不是创建了一个对象;
    4) 声明数组的方式:

    int[] IArray 或者 int IArray[] 基本数据类型数组,数组中存放的是基本数据类型。
    Teacher[] tArray 或者 Teacher tArray[] 类类型数组,数组中存放的是Teacher类创建的若干个的对象。

    注意:1) 声明数组变量的时侯,不能指定数组的长度,以下声明方式是非法的。

             int x[1];
             int[2] x;
    

    二. 初始化

    初始化:自变量创建后首次赋值的过程;

    1)创建数组对象;

    数组对象和其他Java对象一样,也用new语句创建;

       int[] iArray = new int[2];
    

    构建数组:第二个[]必须加参数,表示数组存储元素个数

    new int[2]语句执行以下步骤:

    a. 在堆区中为数组分配内存空间,以上代码创建了一个包含2个元素的int数组
    b. 为数组中的每个元素赋予其数据类型的默认值。
    byte/short/int/long 0
    float 0.0f
    double 0.0d
    String null
    char ‘\u0000’
    boolean false
    c. 返回数组对象的引用

    在用new语句创建数组对象时,需要指定数组长度。数组长度表示数组中包含的元素数目。数组长度可以用具体的数值表示,也可以用
    变量表示。如:

       int[] x = new int[10];
       或
       int[] x={1,23,54};
       int[] x=new int[]{3,43,23};//先给默认值在覆盖
       或
       int size=10;
       int[] x = new int[size];
    

    数组的长度可以为0,此时数组中一个元素也没有。例如:

       int[] x = new int[0];
    

    对于Java类的程序入口方法main(String args[]),如果运行时这个类没有输入参数,那么main()方法的参数args并不是null, 而是一个长度为0的数组。例如:

       public class Sample {
           public static void main(String[] args) {
                System.out.println(args.length);           //打印0
           }
       }
    
      java.util.Arrays
      toString(n);方法
       System.out.print(x[0]);//获取x[0]地址
       System.out.print(Arrays.toString(x[0]));//获取x[0]中的值
      sort(n)//对数组排序
      n.length//获取数组长度
      binarySearch(n,2)//前提:先排序
    

    数组对象创建后,它的长度是固定的。数组对象的长度是无法改变的,但是数组变量可以改变所引用的数组对象。

       int[] x = new int[3];
       int[] y = x;
       x = new int[4];
    

    2)初始化数组对象;

    数组中的每个元素都有一个索引,或者称为下标。数组中的第一个元素的索引为0,第二个元素的索引为1, 依次类推。
    通过索引可以访问数组中的元素或者给数组中元素内容赋值。

    (1) 声明、创建、初始化分开:
    //声明
    int[] iArray;
    //创建
    iArray = new int[2];
    //初始化
    iArray[0] = 0;
    iArray[1] = 1;

    (2) 声明、创建的同时并初始化数组;

    int[] iArray = {0, 1};
    int[] iArray = new int[]{0, 1};
    Student sArray[] = new Student[] { new Student(“George”, “Male”, 20), new Student()};
    Student[] stArray = { new Student(), new Student()} ;

    注意:a.下面这些都是非法的数组初始化方式:
    int[] x = new int[5]{5,4,3,2,1}; //编译出错,创建数组对象的同时并初始化的时候就不能指定数组长度了;

                   int[] x;
                   x = {5,4,3,2,1};                           //{5,4,3,2,1}必须在声明数组变量的语句中使用,不能单独使用
    

    3)多维数组;

    二维数组:
    本质:一维数组里面的元素也是数组
    int[] n=new int[]{1,2,3,4};
    n[0]=1;
    int[][] n=new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};
    n[0]={1,2,3,4}
    n[0][0]=1;

    Java支持多维数组。假定某个宾馆有三层楼,第一层有4个房间,第二层有3个房间,第三层有5个房间。某一天客户人住宿情况如
    下图所示:

       第三层:           |    |Tom |Jerry|    |Rose|
       第二层:          |Mary|    |Kevin|
       第一层:          |Mike|Jane|Duke |    |
    

    可以用两维数组来存储各个房间的客人信息。

       String[][] room = new String[3][];
       room[0] = new Stirng[]{"Mike","Jane","Duke",null};
       room[1] = new String[]{"Mary",null,"kevin"};
       room[2] = new String[]{null,"Tom","Jerry",null,"Rose"}
    
       以上代码等价于:
    
       String[][] room = {
                            {"Mike","Jane","Duke",null},
                            {"Mary",null,"kevin"},
                            {null,"Tom","Jerry",null,"Rose"}
             };
    

    多维数组本质上是数组的数组,数组的元素内容还是数组;写一个类MultiArray.java来创造一个二维数组并输出其中元素

    4)数组的边界:

    (1).一个数组的下标从0开始,数组通过数组的对象引用变量的下标访问数组。数组中第一个元素的索引为0, 第二元素的索引为1,依次类推。如果一个数组长度是5,要访问最后一个数组元素可以通过下标4来访问,如果通过下标5访问,超出了数组的边界,在运行时会抛出ArrayIndexOutOfBoundsException。

    (2).通过调用数组的length方法可以获得一个数组的元素个数(数组长度)。所有Java数组都有一个length属性,表示数组的长度. 该属性只能读取,但是不能修改。

    以下修改数组的length属性,这是非法的。

          int[] x = new int[4];
          x.length = 10;            //编译出错,length属性不能被修改。
    

    注:a. 数组变量必须在指向一个数组对象之后,才能访问其元素。

    public class Sample {
                       private int[] x;
    
                       public static void main(String[] args) {
                              Sample s = new Sample();
                              System.out.println(s.x);            //打印null
                              System.out.println(s.x[0]);         //运行时抛出NullPointerException
                              System.out.println(s.x.length);      //运行时抛出NullPointerException
                       }
                  }
    

    b. 当数组的元素为引用类型时,数组中存放的是对象的引用,而不是对象本身;

    练习:(1) 求一组值的平均值:

                     public class ArrayAvgTest {
                          public double avg(int[] n) {
                               double result = 0.0;
                               for(int i=0;i<n.length;i++) {
                                      result += n[i];
                               }
                               result /= n.length;
    
                               return result;
                          }
    
                          public static void main(String[] args) {
                               ArrayAvgTest a = new ArrayAvgTest();
                               int[] a = {100,60,80,90,75,38};
                               System.out.println("Avg score: " + a.avg(a));
                          }
                     }          

    (2) 求一组值的最大值:

                     public class ArrayMaxTest {
                          public int max(int[] n) {
                               int result = n[0];
                               for(int i=1;i<n.length;i++) {
                                      if(result<n[i])
                                            result = n[i];
                               }
    
                               return result;
                          }
    
                          public static void main(String[] args) {
                               ArrayMaxTest a = new ArrayMaxTest();
                               int[] n = {100,60,80,90,75,38};
                               System.out.println("Max score: " + a.max(n));
                          }
                     } 
    

    (3) 数组内容排序
    详见算法,选择排序、插入排序、冒泡排序。
    (4)java.util.Arrays辅助类的使用。sort(int[] n)以及binarySearch(int[] n,int key)
    方法的使用。

    注意: a. 这二个方法均为static方法,可直接通过类名使用;
    b. binarySearch方法必须保证数组中的元素已经按照升序排列,这样才能得到正确的结果;

    import java.util.Arrays;
    
            public class ArraySortTest2 {
    
                public void print(int[] n) {
                    for(int i=0;i<n.length;i++)
                        System.out.print(n[i] + "\t");
    
                    System.out.println();
                }
    
                public static void main(String[] args) {
                    ArraySortTest2 s = new ArraySortTest2();
                    int[] n = {100,60,80,90,75,38};
                    Arrays.sort(n);
                    System.out.println(Arrays.binarySearch(n, 80));
                    s.print(n);
                    System.out.println(Arrays.binarySearch(n, 80));     
                }
            }

    (5) 从众多手机号码中抽取一个获奖手机号码

            public class ArrayRandomTest {
                public String getTel(String[] n) {
                    int index = (int)(Math.random()*n.length);
                    return n[index];
                }
    
                public static void main(String[] args) {
                    ArrayRandomTest a = new ArrayRandomTest();
                    String[] n = { "1318259016", "13564560540","13858687810","13999999999"};
                    System.out.println(a.getTel(n));
                }
            }

    (6)产生四位长度的验证码, 验证码内容为大小写字母或数字组成;

            public class ArrayValidateCodeTest {
    
                private char[] c;
    
                public ArrayValidateCodeTest() {
                    String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                    c = s.toCharArray();
                }
    
                public String getValidateCode() {
                    int i1 = (int)(Math.random()*c.length);
                    int i2 = (int)(Math.random()*c.length);
                    int i3 = (int)(Math.random()*c.length);
                    int i4 = (int)(Math.random()*c.length);
    
                    return ""+c[i1]+c[i2]+c[i3]+c[i4];
                }
    
                public static void main(String[] args) {
                    ArrayValidateCodeTest a = new ArrayValidateCodeTest();
                    System.out.println(a.getValidateCode());
                }
            }

    5)数组的拷贝:
    数组的长度一旦确定之后便不能调整,我们可以通过复制数组的内容变通实现改变数组长度。在System类中提供一个辅助的arraycopy方法提供复制数组内容的功能:

       System.arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)
    
    参数1,需要被复制的目标数组(原始数组)
    参数2,从这个数组的那个一个位置开始复制(原始数组起始位置)
    参数3,需要把数据复制到的另外的那一个新的数组对象(目标数组)
    参数4,复制到新数组里面哪个位置(从这个位置开始算)(目标数组开始追加数组的角标)
    参数5,复制的目标数组的长度(原始数组复制的长度)
    

    6) 可变参数 JDK1.5或以上
    之前的写法
    在方法中可以把可变参当做数组使用。
    可变参表示当前参数的类型可以接受0到多个

    public void test(int[] a){
    
        }
        main:
            int[] i = {1,2,3,4};
            a.test(i);
    
        可变参数写法
        public void test2(int... a){
    
        }
        main:
            int[] i = {1,2,3,4};
            test2(i);
            test2();
            test2(1,2,3,4);
            test2(1,2,3,4,5,6,7);
    

    可变参数前面可以加其他参数(可变参必须在最后,不能同时出现两个可变参)

        public static void test3(String msg,int... a){
    
        }
        main:
            int[] i = {1,2,3,4};
            String msg = "helo";
            test3(msg,i);
            test3(msg);
            test3(msg,1,2,3,4);
            test3(msg,1,2,3,4,5,s6,7);
    
        可变参数后面不能加任何参数 这样是编译不通过的
        public static void test4(int... a,String msg){
    
        }

    7) 格式化输出 JDK1.5或以上
    System.out.printf是JDK1.5之后加入的新的方法,可以给我们格式化输出内容

    常见用法例子:
    // 定义一些变量,用来格式化输出。
    double d = 345.678;
    String s = “你好!”;
    int i = 1234;
    // “%”表示进行格式化输出,”%”之后的内容为格式的定义。
    // “f”表示格式化输出浮点数。
    System.out.printf(“%f”, d); //345.678000
    System.out.println();
    // “9.2”中的9表示输出的长度,2表示小数点后的位数。 注意输出数字前面的空格
    System.out.printf(“%9.2f”, d);// 345.68
    System.out.println();
    // “+”表示输出的数带正负号。
    System.out.printf(“%+9.2f”, d);// +345.68
    System.out.println();
    // “-“表示输出的数左对齐(默认为右对齐)。
    System.out.printf(“%-9.4f”, d);//345.6780
    System.out.println();
    // “+-“表示输出的数带正负号且左对齐。
    System.out.printf(“%+-9.3f”, d);//+345.678
    System.out.println();
    // “d”表示输出十进制整数。
    System.out.printf(“%d”, i);//1234
    System.out.println();
    // “o”表示输出八进制整数。
    System.out.printf(“%o”, i);//2322
    System.out.println();
    // “x”表示输出十六进制整数。
    System.out.printf(“%x”, i);//4d2
    System.out.println();
    // “#x”表示输出带有十六进制标志的整数。
    System.out.printf(“%#x”, i);//0x4d2
    System.out.println();
    // “s”表示输出字符串。
    System.out.printf(“%s”, s);//你好!
    System.out.println();
    System.out.printf(“输出一个浮点数:%f,一个整数:%d,一个字符串:%s”, d, i, s);
    //输出一个浮点数:345.678000,一个整数:1234,一个字符串:你好!

    展开全文
  • Array对象常用的方法

    2018-09-14 11:10:03
    Array对象常用的方法 不改变原数组的方法 1、concat() 语法:arrayObject.concat(arrayX,arrayX,......,arrayX)  输入值: 输入值可以是单个元素(多个元素),也可以是单个数组(多个数组) 功能:连接两个或...

    Array对象常用的方法

    不改变原数组的方法

    1、concat()

    语法:arrayObject.concat(arrayX,arrayX,......,arrayX)

     输入值: 输入值可以是单个元素(多个元素),也可以是单个数组(多个数组)

    功能:连接两个或多个数组

    返回值:返回被连接数组的一个副本

    栗子:

    // arrayObject.concat(arrayX,arrayX,......,arrayX)
    var arr = [1,2,3];
    var arr2 = arr.concat(4,5,6);
    console.log("arr: " + arr);
    console.log("arr2: " + arr2);
    
    var arr3 = arr.concat([7,8]);
    console.log("arr: " + arr);
    console.log("arr3: " + arr3);
    
    var arr4 = arr.concat([9,10],[11,12]);
    console.log("arr: " + arr);
    console.log("arr4: " + arr4);

     

    输出结果:

     

    arr: 1,2,3
    arr2: 1,2,3,4,5,6
    arr: 1,2,3
    arr3: 1,2,3,7,8
    arr: 1,2,3
    arr4: 1,2,3,9,10,11,12

    2、join()

    语法:arrayObject.join(separator)

    输入值:分隔符

    功能:把数组中的所有元素放入一个字符串中

    返回值:返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串,然后把这些字符串连接起来,在两个元素之间插入 separator 字符串而生成的。

    栗子:

    // arrayObject.join(separator)
    var arr = new Array(3);
    arr[0] = "A";
    arr[1] = "B";
    arr[2] = "C";
    console.log('arr.join(): ' + arr.join());
    console.log('arr.join(-): ' + arr.join('-'));

    输出结果:

    arr.join(): A,B,C
    arr.join(-): A-B-C

    3、slice()

    语法:arrayObject.slice(start,end)---包括start但不包括end,没有找到元素,则返回空的数组

    输入值:

    返回值:返回一个新的数组,包含从 start 到 end (不包括该元素)的 arrayObject 中的元素

    栗子:

    // arrayObject.slice(start,end)
    var arr = [1,2,3,4,5];
    console.log('arr.slice(0): ' + arr.slice(0));  //arr.slice(0): 1,2,3,4,5
    console.log('arr.slice(0,5): ' + arr.slice(0,5));//超出数组最大的index值,则忽略超出部分arr.slice(0,5): 1,2,3,4,5
    console.log('arr.slice(0,1): ' + arr.slice(0,1)); //arr.slice(0,1): 1
    console.log('arr.slice(0,-1): ' + arr.slice(0,-1));//arr.slice(0,-1): 1,2,3,4
    console.log('arr.slice(-3,-1): ' + arr.slice(-3,-1));//arr.slice(-3,-1): 3,4
    console.log('arr.slice(-2,-3): ' + {}.toString.call(arr.slice(-2,-3)));//第一个下标要大于第二个下标,否则返回的是空的数组
    console.log('arr.slice(-1,-3): ' + arr.slice(-1,-3));  //slice()的第一个参数要小于第二个参数
    var arr = [1,2,3,4,5];
    let tmp =arr.slice(5);
    console.log({}.toString.call(tmp)); //没有找到元素,返回的是空的数组'[object Array]'

     

    4、toString()

    语法:booleanObject.toString()

    输入值:无

    功能:把一个逻辑值转换为字符串,并返回结果

    返回值:根据原始布尔值或者booleanObject对象的值返回字符串"true"或“false”

    栗子:

    // booleanObject.toString()
    var boo = new Boolean(true)
    console.log(boo.toString());
    var arr = new Array();
    console.log(arr.toString());  //console显示的是空的

    输出结果:

    true
      

     

    改变原数组

    1、pop()

    语法:arrayObject.pop()

    输入值:无

    功能:用于删除并返回数组的最后一个元素

    返回值:被删除的元素;如果是空数组则不改变数组,返回undefined

    栗子:

    // arrayObject.pop()
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the pop element: '+ arr.pop());
    console.log('arr: '+ arr);

    输出结果:

    arr: 1,2,3
    the pop element: 3
    arr: 1,2

    2、push()

    语法:arrayObject.push(newelement1,newelement2,....,newelementX)

    输入值:

    功能:想数组的末尾添加一个或多个元素

    返回值:把指定的值添加到数组之后的新长度

    栗子:

    // arrayObject.push(newelement1,newelement2,....,newelementX)
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the new length: '+ arr.push(4,5));
    console.log('arr: '+ arr);

    输出结果:

    arr: 1,2,3
    the new length: 5
    arr: 1,2,3,4,5

    3、shift()

    语法:arrayObject.shift()

    输入值:无

    功能:把数组的第一个元素从其中删除

    返回值:数组原来的第一个元素的值

    栗子:

    // arrayObject.shift()
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the shift element: '+ arr.shift());
    console.log('arr: '+ arr);

    输出结果:

    arr: 1,2,3
    the shift element: 1
    arr: 2,3

    4、unshift()

    语法:arrayObject.unshift(newelement1,newelement2,....,newelementX)

    输入值:

     


    功能:向数组的开头添加一个或多个元素

    返回值:返回数组的新长度

    栗子:

    // arrayObject.unshift(newelement1,newelement2,....,newelementX)
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the new length: '+ arr.unshift(14,5));
    console.log('arr: '+ arr);

    输出结果:

    arr: 1,2,3
    the new length: 5

    arr: 14,5,1,2,3

    5、splice()

    语法:arrayObject.splice(index,howmany,item1,.....,itemX)

    输入值:

     

    功能:向数组添加项目或者从数组中删除项目

    返回值:

    向/从数组中添加/删除项目,然后返回被删除的项目

    栗子:

    // arrayObject.splice(index,howmany,item1,.....,itemX)
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('delete element: '+ arr.splice(0,1));
    console.log('arr: '+ arr);
    console.log('do not delete element: '+ arr.splice(0,0,6));
    console.log('arr: '+ arr);

     

    输出结果:

    arr: 1,2,3
    delete element: 1
    arr: 2,3
    do not delete element: 
    arr: 6,2,3

    6、reverse()

    语法: arrayObject.reverse()

    输入值:无

    功能:用于颠倒数组中的元素的顺序

    返回值:返回颠倒顺序之后的数组

    栗子:

    // arrayObject.reverse()
    var arr = [1,2,3];
    console.log('arr: ' + arr);
    console.log('reverse arr: ' + arr.reverse());
    console.log('arr: '+ arr);

    输出结果:

    arr: 1,2,3
    reverse arr: 3,2,1
    arr: 3,2,1

    7、sort()

    语法:arr.sort()   或者  arr.sort(compareFunction)

    输入值;无  或者  函数(用来指定按某种顺序进行排列的函数。如果省略,元素按照转换为的字符串的各个字符的Unicode位点进行排序

     

    功能:排序

    返回值:排序之后的数组

    栗子:

    // arr.sort() 
    // arr.sort(compareFunction)
    var numbers = [4, 2, 5, 1, 3];
    numbers.sort(function(a, b) {
      return a - b;
    });
    console.log(numbers);

    输出结果:

    [ 1, 2, 3, 4, 5 ]

    栗子2:

    // arr.sort() 
    // arr.sort(compareFunction)
    var numbers = [4, 2, 5, 10, 3];
    numbers.sort();
    console.log(numbers);

    输出结果:

    [ 10, 2, 3, 4, 5 ]

     

    在Array的prototype对象上有12个方法

     Array.prototype.indexOf
     Array.prototype.lastIndexOf
     Array.prototype.every
     Array.prototype.some
     Array.prototype.forEach
     Array.prototype.map
     Array.prototype.filter
     Array.prototype.reduce
     Array.prototype.reduceRight
     Array.prototype.includes
     Array.prototype.find
     Array.prototype.findIndex

    1)Array.prototype.indexOfstringObject.indexOf(searchvalue,fromindex)--searchvalue要检索的值,fromindex开始检索的位置,从前向后检索,返回首次出现的位置,找不到返回-1

    2)Array.prototype.lastIndexOf:stringObject.lastIndexOf(searchvalue,fromindex)--searchvalue要检索的值,fromindex开始检索的位置,从后向前检索返回最后出现的位置,找不到返回-1

    3)Array.prototype.map:arr.map(function(currentValue,index,arr), thisValue)--thisValue作为this的值,如果忽略则为undefined,返回一个经过callback处理数组的每一个元素之后的结果组成的新数组,不改变原数组

    4)Array.prototype.reduce:arr.reduce(function(total, currentValue, currentIndex, arr), initialValue)--total作为callback的返回值,initialValue是total的初始值,返回一个经过callback处理之后的结果数组,不改变原数组,对于空数组是不会执行回调函数的

    5)Array.prototype.reduceRight:arr.reduce(function(total, currentValue, currentIndex, arr), initialValue),同reduce一样,只不过是从数组末尾向前遍历,不改变原数组,对于空数组是不会执行回调函数的

    6)Array.prototype.every:arr.every(function(currentValue,index,arr), thisValue),检测数组所有元素是否都符合指定条件

    如果数组中检测到有一个元素不满足,则整个表达式返回 false ,且剩余的元素不会再进行检测,否则为true

    7)Array.prototype.forEach():array.forEach(function(currentValue, index, arr), thisValue),调用数组的每个元素,并将元素传递给回调函数,对于空数组是不会执行回调函数的,没有返回值

    8)Array.prototype.some():arr.some(function(currentValue,index,arr),thisValue),依次执行数组的每个元素,如果有一个元素满足条件,则表达式返回true , 剩余的元素不会再执行检测创建一个新的数组,不会对空数组进行检测,不会改变原始数组

    9)Array.prototype.filter():arr.filter(function(currentValue,index,arr), thisValue)创建一个新的数组,新数组中的元素是通过检查指定数组中符合条件的所有元素,不会对空数组进行检测,不会改变原始数组

    10)Array.prototype.find():返回通过测试(函数内判断)的数组的第一个元素的值之后的值不会再调用执行函数,如果没有符合条件的元素返回 undefined,对于空数组,函数是不会执行的,并没有改变数组的原始值
    11)Array.prototype.findIndex():传入一个测试条件(函数)符合条件的数组第一个元素位置,当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置,之后的值不会再调用执行函数,没有符合条件的元素返回 -1对于空数组,函数是不会执行的,并没有改变数组的原始值

     

    下面是在ES6中添加的

    12)Array.of():将元素列表转为数组,避免new Array()带来的诡异行为(由传入参数的个数不同造成的问题)

    // Array()只有一个参数的时候,参数的大小表示数组的长度
    // 有多于一个参数,则表示数组元素
    let arr1 = new Array(3);
    console.log( arr1 );   //[ <3 empty items> ]
    console.log( arr1.length ); //3
    
    let arr2 = new Array(3,2,1);  
    console.log( arr2 );   //[ 3, 2, 1 ]
    console.log( arr2.length ); //3
    
    // Array.of()函数里面只要有参数,都表示数组元素成员
    let arr3 = Array.of(1); 
    console.log( arr3 );  //[1]
    console.log( arr3.length );  //1
    
    let arr4 = Array.of(1,undefined);  
    console.log( arr4 );  //2
    console.log( arr4.length );  //[ 1, undefined ]
    
    

    12)Array.from(iterator,fn,obj):将具有Iterator接口的对象或类数组对象转成数组

    其中iterator必须,表示要转换的对象,fn表示对对象的每个成员进行处理的映射函数,obj表示映射函数的this的值

    // 例1,将函数中的arguments对象转换成数组对象
    Array.from(arguments);
    
    // 例2,对对象的每个成员进行处理
    function translate(){
    	return Array.from(arguments,val=>val+1);
    }
    console.log(translate(1,2,3)); // [2,3,4]
    
    // 例3,指定映射函数中的this的值
    let helper = {
    	diff:1,
    	add(val){
    		return val + this.diff;
    	}
    };
    function translate2(){
    	return Array.from(arguments,helper.add,helper);
    }
    console.log(translate2(3,4,5));//[ 4, 5, 6 ]

    13)Array.keys()   Array,values()   Array.entries()

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • array([:]) &gt;&gt;&gt; import numpy as np &gt;&gt;&gt; &gt;&gt;&gt; x=np.array([1,2,3,4,5,6,7,8,9,10,11,12]) &gt;&gt;&gt; print(x[1:5])#打印index为1~5...
  • TypeScript 数组Array操作

    2018-06-20 18:20:21
    let array1:Array&amp;lt;number&amp;gt;; let array2:number[]; 二、数组初始化 let array1:Array&amp;lt;number&amp;gt; = new Array&amp;lt;number&amp;gt;(); let ...
  • 8.Array(数组) 数组是作为对象来实现的。(really occupy the memopry,真实的占用内存 ) An array is a data structure that stores a collection of value of the same type.(数组是一个数据结构,它存储一堆...
  • Array和Arrays的区别

    2017-12-18 21:48:54
    Array的api如下: public final class Array extends Object The Array class provides static methods to dynamically create and access Java arrays. Array permits widening conversions to occur during a
  • Array[]数组(java)

    2019-06-14 20:24:51
    Array[]数组 1、概述 数组(Array), 是多个相同类型数据按一定顺序排列的集合, 并使用一个名字命名, 并通过编号的方式对这些数据进行统一管理。 2、注意点 数组本身是引用数据类型, 而数组中的元素可以是任何...
  • ES6-数组

    2019-05-16 16:43:07
    Array.of(x,…) :将参数中所有值作为元素形成数组 Array.from(x,fn) :将类数组对象或可迭代对象转化为数组 类数组对象:必须含有lenght属性,且元素属性名必须是数值或者可转换数值的字符 使用方法 // 1.创建数组...
  • python numpy.array 操作总结
  • python中的list和array的不同之处  python中的list是python的内置数据类型,list中的数据类不必相同的,而array的中的类型必须全部相同。在list中的数据类型保存的是数据的存放的地址,简单的说就是指针,并非...
  • 准备工作: 增、删、改、查的方法有很多很多种,这里只展示出常用的几种。... a = np.array([[1,2],[3,4],[5,6]])#创建3行2列二维数组。 >>> a array([[1, 2], [3, 4], [5, 6]]) >>&...
  • [558]python3之数组(array)

    2019-12-14 19:34:12
    当我们需要1000万个浮点数的时候,数组(array)的效率要比列表(list)要高得多,因为数组在背后存的并不是float对象,而是数字的机器翻译,也就是字节表述。这一点和c语言中的数组一样。 再比如说,如果需要频繁对...
  • python中找出numpy array数组的最值及其索引 在list列表中,max(list)可以得到list的最大值,list.index(max(list))可以得到最大值对应的索引 但在numpy中的array没有index方法,取而代之的是where,其又是list...
  • 一、背景 &...网上百度一下array_map,然后发现了array_walk。这两个函数在某些情境下有异曲同工之妙,然后区别还是很大的。 二、关于array_map 1、文档 &amp;nbsp;&amp;nbsp;&amp;
  • 最新消息,Hi小程序小编了解到,微信小程序开发教程之Array数组对象。 微信小程序开发教程已经是当下最热门的话题,下面将从多方面来谈谈Array数组对象相关的内容。 Array,又称作数组对象我们通常通过 ...
  • 有两种情况下会出现这种错误。 场景一 ...$arr = array(0, 1, 2); //错误1,双引号可以解析变量,但是双引号中,就会认为它是字符串。 var_dump("$arr"); //错误2 echo $arr; 这种情况会...
  • 在python中利用numpy创建一个array, 然后我们想获取array的最大值,最小值。可以使用一下方法: 一、创建数组 np.max(a) np.min(a) 这样就可以获得一个array的最大值和最小值了。 并且可以利用np.where(a==np....
  • 前提:list以及array是python中经常会用到的数据类型,当需要对list以及array进行文件的读写操作的时候,由于write函数参数需要的是一个str,所以这时就需要对list或者array进行str的转换了。list和array的不同:在...
1 2 3 4 5 ... 20
收藏数 1,755,733
精华内容 702,293
关键字:

array