精华内容
下载资源
问答
  • Numpy | 04 数组属性
    千次阅读
    2020-12-22 15:00:11

    NumPy 数组的维数称为秩(rank),一维数组的秩为 1,二维数组的秩为 2,以此类推。

    在 NumPy中,每一个线性的数组称为是一个轴(axis),也就是维度(dimensions)。比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴(axis),第一个轴相当于是底层数组,第二个轴是底层数组里的数组。而轴的数量——秩,就是数组的维数。

    很多时候可以声明 axis。axis=0,表示沿着第 0 轴进行操作,即对每一列进行操作;axis=1,表示沿着第1轴进行操作,即对每一行进行操作。

    NumPy 的数组中比较重要 ndarray 对象属性有:

    属性说明

    ndarray.ndim

    秩,即轴的数量或维度的数量

    ndarray.shape

    数组的维度,对于矩阵,n 行 m 列

    ndarray.size

    数组元素的总个数,相当于 .shape 中 n*m 的值

    ndarray.dtype

    ndarray 对象的元素类型

    ndarray.itemsize

    ndarray 对象中每个元素的大小,以字节为单位

    ndarray.flags

    ndarray 对象的内存信息

    ndarray.real

    ndarray元素的实部

    ndarray.imag

    ndarray 元素的虚部

    ndarray.data

    包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。

    ndarray.ndim

    ndarray.ndim 用于返回数组的维数,等于秩。

    importnumpy as np

    a= np.arange(24)b= a.reshape(2, 4, 3)print(a.ndim,b.ndim)

    输出结果为:

    1 3

    ndarray.shape

    ndarray.shape 表示数组的维度,返回一个元组,这个元组的长度就是维度的数目,即 ndim 属性(秩)。比如,一个二维数组,其维度表示"行数"和"列数"。

    importnumpy as np

    a= np.array([[1,2,3],[4,5,6]])print (a.shape)

    输出结果为:

    (2,3)

    ndarray.shape 也可以用于调整数组大小

    importnumpy as np

    a= np.array([[1,2,3],[4,5,6]])

    a.shape= (3,2)print (a)

    输出结果为:

    [[12][34][56]]

    NumPy 也提供了 reshape 函数来调整数组大小

    importnumpy as np

    a= np.array([[1,2,3],[4,5,6]])

    b= a.reshape(3,2)print (b)

    输出结果为:

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

    ndarray.itemsize

    ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。

    例如,一个元素类型为 float64 的数组 itemsiz 属性值为 8(float64 占用 64 个 bits,每个字节长度为 8,所以 64/8,占用 8 个字节);一个元素类型为 complex32 的数组 item 属性为 4(32/8)。

    importnumpy as np#数组的 dtype 为 int8(一个字节)

    x = np.array([1,2,3,4,5], dtype =np.int8)print(x.itemsize)#数组的 dtype 现在为 float64(八个字节)

    y = np.array([1,2,3,4,5], dtype =np.float64)print (y.itemsize)

    输出结果为:

    18

    ndarray.flags

    ndarray.flags 返回 ndarray 对象的内存信息,包含以下属性:

    属性描述

    C_CONTIGUOUS (C)

    数据是在一个单一的C风格的连续段中

    F_CONTIGUOUS (F)

    数据是在一个单一的Fortran风格的连续段中

    OWNDATA (O)

    数组拥有它所使用的内存或从另一个对象中借用它

    WRITEABLE (W)

    数据区域可以被写入,将该值设置为 False,则数据为只读

    ALIGNED (A)

    数据和所有元素都适当地对齐到硬件上

    UPDATEIFCOPY (U)

    这个数组是其它数组的一个副本,当这个数组被释放时,原数组的内容将被更新

    importnumpy as np

    x= np.array([1,2,3,4,5])print (x.flags)

    输出结果为:

    C_CONTIGUOUS :TrueF_CONTIGUOUS :TrueOWNDATA :TrueWRITEABLE :TrueALIGNED :TrueWRITEBACKIFCOPY :FalseUPDATEIFCOPY :False

    更多相关内容
  • Python:numpy数组属性

    2020-03-23 10:45:48
    本章内容:了解 NumPy 数组。Numpy数据类型详见https://mp.csdn.net/console/editor/html/105042451! NumPy 数组的维数称为秩(rank),秩就是轴的数量,即数组的维度,一维数组的秩为 1,二维数组的秩为 2,...

    本章内容:了解 NumPy 数组。Numpy数据类型详见https://mp.csdn.net/console/editor/html/105042451

    NumPy 数组的维数称为秩(rank),秩就是轴的数量,即数组的维度,一维数组的秩为 1,二维数组的秩为 2,以此类推

    在 NumPy中,每一个线性的数组称为是一个轴(axis),也就是维度(dimensions)。比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴(axis),第一个轴相当于是底层数组,第二个轴是底层数组里的数组。而轴的数量——秩,就是数组的维数。

    很多时候可以声明 axis。axis=0,表示沿着第 0 轴进行操作,即对每一列进行操作;axis=1,表示沿着第1轴进行操作,即对每一行进行操作。

    NumPy 的数组中比较重要 ndarray 对象属性有:

    属性说明
    ndarray.ndim秩,即轴的数量或维度的数量
    ndarray.shape数组的维度,对于矩阵,n 行 m 列
    ndarray.size数组元素的总个数,相当于 .shape 中 n*m 的值
    ndarray.dtypendarray 对象的元素类型
    ndarray.itemsizendarray 对象中每个元素的大小,以字节为单位
    ndarray.flagsndarray 对象的内存信息
    ndarray.realndarray元素的实部
    ndarray.imagndarray 元素的虚部
    ndarray.data包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。

    1、ndarray.ndim

    ndarray.ndim 用于返回数组的维数,等于秩。

    import numpy as np

    a = np.arange(24)

    print (a.ndim) # a 现只有一个维度 # 现在调整其大小

    b = a.reshape(2,4,3) # b 现在拥有三个维度

    print (b.ndim)

    输出结果为:1 3

    2、ndarray.shape

    ndarray.shape 表示数组的维度,返回一个元组,这个元组的长度就是维度的数目,即 ndim 属性(秩)。比如,一个二维数组,其维度表示"行数"和"列数"。

    import numpy as np

    a = np.array([[1,2,3],[4,5,6]])

    print (a.shape)

    输出结果为:(2, 3)

    ndarray.shape 也可以用于调整数组大小。

    import numpy as np

    a = np.array([[1,2,3],[4,5,6]]) a.shape = (3,2)

    print (a)

    输出结果为:[[1 2] [3 4] [5 6]]

    NumPy 也提供了 reshape 函数来调整数组大小。

    import numpy as np

    a = np.array([[1,2,3],[4,5,6]])

    b = a.reshape(3,2)

    print (b)

    输出结果为:[[1, 2] [3, 4] [5, 6]]

    3、ndarray.itemsize

    ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。

    例如,一个元素类型为 float64 的数组 itemsiz 属性值为 8(float64 占用 64 个 bits,每个字节长度为 8,所以 64/8,占用 8 个字节),又如,一个元素类型为 complex32 的数组 item 属性为 4(32/8)。

    import numpy as np # 数组的 dtype 为 int8(一个字节)

    x = np.array([1,2,3,4,5], dtype = np.int8)

    print (x.itemsize) # 数组的 dtype 现在为 float64(八个字节)

    y = np.array([1,2,3,4,5],

    dtype = np.float64)

    print (y.itemsize)

    输出结果为:1 8

    4、ndarray.flags

    ndarray.flags 返回 ndarray 对象的内存信息,包含以下属性:

    属性描述
    C_CONTIGUOUS (C)数据是在一个单一的C风格的连续段中
    F_CONTIGUOUS (F)数据是在一个单一的Fortran风格的连续段中
    OWNDATA (O)数组拥有它所使用的内存或从另一个对象中借用它
    WRITEABLE (W)数据区域可以被写入,将该值设置为 False,则数据为只读
    ALIGNED (A)数据和所有元素都适当地对齐到硬件上
    UPDATEIFCOPY (U)这个数组是其它数组的一个副本,当这个数组被释放时,原数组的内容将被更新

    import numpy as np

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

    print (x.flags)

    输出结果为:

      C_CONTIGUOUS : True
      F_CONTIGUOUS : True
      OWNDATA : True
      WRITEABLE : True
      ALIGNED : True
      WRITEBACKIFCOPY : False
      UPDATEIFCOPY : False

    以上为NumPy数组属性的全部内容,想了解更多,可点击小编相关numpy文章了解哦!希望可以帮助到大家!

    展开全文
  • 前面我们提到了shape和dtype属性,ndarray对象还要很多其他的属性下面一一介绍。  shape:通过元组的形式返回数组每一维度元素的个数。  dtype:返回数组的元素类型   ndim属性  给出数组的维数,或数组轴...

    前面我们提到了shape和dtype属性,ndarray对象还要很多其他的属性,下面一一介绍。
        shape:通过元组的形式返回数组每一维度元素的个数。

        dtype:返回数组的元素类型

     

    ndim属性

        给出数组的维数,或数组轴的个数:

     

     

    size属性

        给出数组元素的总元素个数:

     

     

    itemsize属性

        给出数组中元素在内存中所占的字节数:

     

     

    nbytes属性    

        如果你想知道整个数组所占的存储空间,可以用nbytes属性来查看。这个属性的值其实就是itemsize和size属性的乘积:

     

     

    T属性

        T属性的效果和transpose函数一样:

        对于一维数组,其T属性就是原数组:

     

    在Numpy中,复数的虚部就是用j表示的。例如,我们可以创建一个由复数构成的数组:

     

    real属性

        给出复数的实部。如果数组中只包含实数元素,则其real属性将输出原数组:

     

    imag属性

        给出复数的虚部:

     

     

     

     

     

     

     

     

    展开全文
  • Java中数组的特性

    2021-02-12 21:14:46
    数组是基本上所有语言都会有的一种数据类型,它表示一组相同类型的数据的集合,具有固定的长度,并且在内存中占据连续的空间。在C,C++等语言中,数组的定义简洁清晰,而在java中确有一些会让人迷惑的特性。本文就...

    数组是基本上所有语言都会有的一种数据类型,它表示一组相同类型的数据的集合,具有固定的长度,并且在内存中占据连续的空间。在C,C++等语言中,数组的定义简洁清晰,而在java中确有一些会让人迷惑的特性。本文就尝试分析这些特性。

    Java中的数组是对象吗?

    Java和C++都是面向对象的语言。在使用这些语言的时候,我们可以直接使用标准的类库,也可以使用组合和继承等面向对象的特性构建自己的类,并且根据自己构建的类创建对象。那么,我们是不是应该考虑这样一个问题:在面向对象的语言中,数组是对象吗?

    要判断数组是不是对象,那么首先明确什么是对象,也就是对象的定义。在较高的层面上,对象是根据某个类创建出来的一个实例,表示某类事物中一个具体的个体。对象具有各种属性,并且具有一些特定的行为。而在较低的层面上,站在计算机的角度,对象就是内存中的一个内存块,在这个内存块封装了一些数据,也就是类中定义的各个属性,所以,对象是用来封装数据的。以下为一个Person对象在内存中的表示:

    db951bc9e60fc26025539653f71d0144.png

    注意:

    1)小的红色矩形表示一个引用(地址)或一个基本类型的数据,大的红色矩形表示一个对象,多个小的红色矩形组合在一块,可组成一个对象。

    2)name在对象中只表示一个引用, 也就是一个地址值,它指向一个真实存在的字符串对象。在这里严格区分了引用和对象。

    那么在Java中,数组满足以上的条件吗?在较高的层面上,数组不是某类事物中的一个具体的个体,而是多个个体的集合。那么它应该不是对象。而在计算机的角度,数组也是一个内存块,也封装了一些数据,这样的话也可以称之为对象。以下是一个数组在内存中的表示:

    e59d2d62717ed0e6ad613fd24f450031.png

    这样的话, 数组既可以是对象, 也可以不是对象。至于到底是不是把数组当做对象,全凭Java的设计者决定。数组到底是不是对象, 通过代码验证:

    int[] a = new int[4];

    //a.length;  //对属性的引用不能当成语句

    int len = a.length;  //数组中保存一个字段, 表示数组的长度

    //以下方法说明数组可以调用方法,java中的数组是对象.这些方法是Object中的方法,所以可以肯定,数组的最顶层父类也是Object

    a.clone();

    a.toString();

    在数组a上, 可以访问他的属性,也可以调用一些方法。这基本上可以认定,java中的数组也是对象,它具有java中其他对象的一些基本特点:封装了一些数据,可以访问属性,也可以调用方法。所以,数组是对象。

    而在C++中,数组虽然封装了数据,但数组名只是一个指针,指向数组中的首个元素,既没有属性,也没有方法可以调用。如下代码所示:

    int main(){

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

    int* pa = a;

    //无法访问属性,也不能调用方法。

    return 0;

    }

    所以C++中的数组不是对象,只是一个数据的集合,而不能当做对象来使用。

    Java中数组的类型

    Java是一种强类型的语言。既然是对象, 那么就必须属于一个类型,比如根据Person类创建一个对象,这个对象的类型就是Person。那么数组的类型是什么呢?看下面的代码:

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

    System.out.println(a1.getClass().getName());

    //打印出的数组类的名字为[I

    String[] s = new String[2];

    System.out.println(s.getClass().getName());

    //打印出的数组类的名字为  [Ljava.lang.String;

    String[][] ss = new String[2][3];

    System.out.println(ss.getClass().getName());

    //打印出的数组类的名字为    [[Ljava.lang.String;

    打印出a1的类型为[ I ,s 的类型是[Ljava.lang.String;  ,  ss的类型是[[Ljava.lang.String;

    所以,数组也是有类型的。只是这个类型显得比较奇怪。你可以说a1的类型是int[],这也无可厚非。但是我们没有自己创建这个类,也没有在Java的标准库中找到这个类。也就是说不管是我们自己的代码,还是在JDK中,都没有如下定义:

    public class int[] {

    // ...

    // ...

    // ...

    }

    这只能有一个解释,那就是虚拟机自动创建了数组类型,可以把数组类型和8种基本数据类型一样, 当做java的内建类型。这种类型的命名规则是这样的:

    *

    每一维度用一个[表示;开头两个[,就代表是二维数组。

    * [后面是数组中元素的类型(包括基本数据类型和引用数据类型)

    在java语言层面上,s是数组,也是一个对象,那么他的类型应该是String[],这样说是合理的。但是在JVM中,他的类型为[java.lang.String。顺便说一句普通的类在JVM里的类型为 包名+类名,也就是全限定名。同一个类型在java语言中和在虚拟机中的表示可能是不一样的。

    Java中数组的继承关系

    上面已经验证了,数组是对象,也就是说可以以操作对象的方式来操作数组。并且数组在虚拟机中有它特别的类型。既然是对象,遵循Java语言中的规则 -- Object是上帝, 也就是说所有类的顶层父类都是Object。数组的顶层父类也必须是Object,这就说明数组对象可以向上直接转型到Object,也可以向下强制类型转换,也可以使用instanceof关键字做类型判定。 这一切都和普通对象一样。如下代码所示:

    //1     在test1()中已经测试得到以下结论: 数组也是对象, 数组的顶层父类是Object, 所以可以向上转型

    int[] a = new int[8];

    Object obj = a ; //数组的父类也是Object,可以将a向上转型到Object

    //2     那么能向下转型吗?

    int[] b = (int[])obj;  //可以进行向下转型

    //3     能使用instanceof关键字判定吗?

    if(obj instanceof int[]){  //可以用instanceof关键字进行类型判定

    System.out.println("obj的真实类型是int[]");

    }

    Java中数组的另一种“继承”关系

    如下代码是正确的,却很容易让我们疑惑:

    String[] s = new String[5];

    Object[] obja = s;   //成立,说明可以用Object[]的引用来接收String[]的对象

    Object[]类型的引用可以指向String[]类型的数组对象? 由上文的验证可以得知数组类型的顶层父类一定是Object,那么上面代码中s的直接父类是谁呢?难道说String[]继承自Object[],而Object[]又继承自Object? 让我们通过反射的方式来验证这个问题:

    //5     那么String[] 的直接父类是Object[] 还是 Object?

    System.out.println(s.getClass().getSuperclass().getName());

    //打印结果为java.lang.Object,说明String[] 的直接父类是 Object而不是Object[]

    由代码可知,String[]的直接父类就是Object而不是Object[]。可是Object[]的引用明明可以指向String[]类型的对象。那么他们的继承关系有点像这样:

    7c9919e680f0098aa4aed81d49b68179.png

    这样的话就违背了Java单继承的原则。String[]不可能即继承Object,又继承Object[]。上面的类图肯定是错误的。那么只能这样解释:数组类直接继承了Object,关于Object[]类型的引用能够指向String[]类型的对象,这种情况只能是Java语法之中的一个特例,并不是严格意义上的继承。也就是说,String[]不继承自Object[],但是我可以允许你向上转型到Object[],这种特性是赋予你的一项特权。

    其实这种关系可以这样表述:如果有两个类A和B,如果B继承(extends)了A,那么A[]类型的引用就可以指向B[]类型的对象。如下代码所示:

    public static class Father {

    }

    public static class Son extends Father {

    }

    //6   下面成立吗?  Father是Son的直接父类

    Son[] sons = new Son[3];

    Father[] fa = sons;  //成立

    //7     那么Son[] 的直接父类是Father[] 还是  Object[] 或者是Object?

    System.out.println(sons.getClass().getSuperclass().getName());

    //打印结果为java.lang.Object,说明Son[]的直接父类是Object

    上面的结论可以扩展到二维数组和多维数组:

    Son[][] sonss = new Son[2][4];

    Father[][] fathers = sonss;

    上面的代码可以这样理解:

    将Father[][]数组看成是一维数组, 这是个数组中的元素为Father[],将Son[][]数组看成是一维数组, 这是个数组中的元素为Son[],因为Father[]类型的引用可以指向Son[]类型的对象,所以,根据上面的结论,Father[][]的引用可以指向Son[][]类型的对象。

    数组的这种用法不能作用于基本类型数据:

    int[] aa = new int[4];

    //Object[] objaa = aa;  //错误的,不能通过编译

    这是错误的, 因为int不是引用类型,Object不是int的父类,在这里自动装箱不起作用。但是这种方式是可以的:

    Object[] objss = {"aaa", 1, 2.5};

    这种情况下自动装箱可以工作,也就是说,Object数组中可以存放任何值,包括基本数据类型。

    Java为什么会为数组提供这样一种语法特性呢?也就是说这种语法有什么作用?编写过Android中Sqlite数据库操作程序的同学可能发现过这种现象,用一个Object[]引用接收所有的数组对象,在编译SQL语句时,为SQL语句中的占位符提供对应的值。

    db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new Object[]{person.name, person.age});

    所以这种特性主要是用于方法中参数的传递。如果不传递数组,而是依次传递各个值,会使方法参数列表变得冗长。如果使用具体的数组类型,如String[],那么就限定了类型,失去了灵活性。所以传递数组类型是一种比较好的方式。但是如果没有上面的数组特性(如果有两个类A和B,如果B继承(extends)了A,那么A[]类型的引用就可以指向B[]类型的对象),那么数组类型就只能通过Object类型接收,这样就无法在方法内部访问或遍历数组中的各个元素。如下代码:

    private static void test3() {

    String[] a = new String[3];

    doArray(a);

    }

    private static void doArray(Object[] objs){

    }

    private static void doArray1(Object obj){

    //不能用Object接收数组,因为这样无法对数组的元素进行访问

    // obj[1]  //错误

    //如果在方法内部对obj转型到数组,存在类型转换异常的风险

    // Object[] objs = (Object[]) obj;

    }

    private static void doArray2(String[] strs){

    //如果适用特定类型的数组,就限制了类型,失去灵活性和通用性

    }

    private static void doArray3(String name, int age, String id, float account){

    //如果不适用数组而是依次传递参数,会使参数列表变得冗长,难以阅读

    }

    到此为止,数组的特性就总结完了。上文中加粗的部分为重要结论。下面贴出整个源码:

    源码

    package com.pansoft.zhangjg.testarray;

    public class ArrayTest {

    /**

    * @param args

    */

    public static void main(String[] args) {

    test1();

    test2();

    test3();

    }

    /**

    * 数组具有这种特性:

    * 如果有两个类A和B,如果B继承(extends)了A,那么A[]类型的引用就可以指向B[]类型的对象

    * 测试数组的特殊特性对参数传递的便利性

    */

    private static void test3() {

    String[] a = new String[3];

    doArray(a);

    }

    private static void doArray(Object[] objs){

    }

    private static void doArray1(Object obj){

    //不能用Object接收数组,因为这样无法对数组的元素进行访问

    // obj[1]  //错误

    //如果在方法内部对obj转型到数组,存在类型转换异常的风险

    // Object[] objs = (Object[]) obj;

    }

    private static void doArray2(String[] strs){

    //如果适用特定类型的数组,就限制了类型,失去灵活性和通用性

    }

    private static void doArray3(String name, int age, String id, float account){

    //如果不适用数组而是依次传递参数,会使参数列表变得冗长,难以阅读

    }

    /**

    * 测试数组的集成关系, 并且他的继承关系是否和数组中元素的类型有关

    */

    private static void test2() {

    //1     在test1()中已经测试得到以下结论: 数组也是对象, 数组的顶层父类是Object, 所以可以向上转型

    int[] a = new int[8];

    Object obj = a ; //数组的父类也是Object,可以将a向上转型到Object

    //2     那么能向下转型吗?

    int[] b = (int[])obj;  //可以进行向下转型

    //3     能使用instanceof关键字判定吗?

    if(obj instanceof int[]){  //可以用instanceof关键字进行类型判定

    System.out.println("obj的真实类型是int[]");

    }

    //4     下面代码成立吗?

    String[] s = new String[5];

    Object[] obja = s;   //成立,说明可以用Object[]的引用来接收String[]的对象

    //5     那么String[] 的直接父类是Object[] 还是 Object?

    System.out.println(s.getClass().getSuperclass().getName());

    //打印结果为java.lang.Object,说明String[] 的直接父类是 Object而不是Object[]

    //6   下面成立吗?  Father是Son的直接父类

    Son[] sons = new Son[3];

    Father[] fa = sons;  //成立

    //7     那么Son[] 的直接父类是Father[] 还是  Object[] 或者是Object?

    System.out.println(sons.getClass().getSuperclass().getName());

    //打印结果为java.lang.Object,说明Son[]的直接父类是Object

    /**

    * 做一下总结, 如果A是B的父类, 那么A[] 类型的引用可以指向 B[]类型的变量

    * 但是B[]的直接父类是Object, 所有数组的父类都是Object

    */

    //8     上面的结论可以扩展到二维数组

    Son[][] sonss = new Son[2][4];

    Father[][] fathers = sonss;

    //将Father[][]数组看成是一维数组, 这是个数组中的元素为Father[]

    //将Son[][]数组看成是一维数组, 这是个数组中的元素为Son[]

    //因为Father[]类型的引用可以指向Son[]类型的对象

    //所以,根据上面的结论,Father[][]的引用可以指向Son[][]类型的对象

    /**

    * 扩展结论:

    * 因为Object是所有引用类型的父类

    * 所以Object[]的引用可以指向任何引用数据类型的数组的对象. 如:

    * Object[] objs = new String[1];

    * Object[] objs = new Son[1];

    *

    */

    //9     下面的代码成立吗?

    int[] aa = new int[4];

    //Object[] objaa = aa;  //错误的,不能通过编译

    //这是错误的, 因为Object不是int的父类,在这里自动装箱不起作用

    //10    这样可以吗?

    Object[] objss = {"aaa", 1, 2.5};//成立

    }

    /**

    * 测试在java语言中,数组是不是对象

    * 如果是对象, 那么他的类型是什么?

    */

    private static void test1() {

    int[] a = new int[4];

    //a.length;  //对属性的引用不能当成语句

    int len = a.length;  //数组中保存一个字段, 表示数组的长度

    //以下方法说明数组可以调用方法,java中的数组是对象.这些方法是Object中的方法,所以可以肯定,数组的最顶层父类也是Object

    a.clone();

    a.toString();

    /**

    * java是强类型的语言,一个对象总会有一个特定的类型,例如 Person p = new Person();

    * 对象p(确切的说是引用)的类型是Person类, 这个Person类是我们自己编写的

    * 那么数组的类型是什么呢? 下面使用反射的方式进行验证

    */

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

    System.out.println(a1.getClass().getName());

    //打印出的数组类的名字为[I

    String[] s = new String[2];

    System.out.println(s.getClass().getName());

    //打印出的数组类的名字为  [Ljava.lang.String;

    String[][] ss = new String[2][3];

    System.out.println(ss.getClass().getName());

    //打印出的数组类的名字为    [[Ljava.lang.String;

    /**

    * 所以,数组也是有类型的,只不过这个类型不是有程序员自己定义的类, 也不是jdk里面

    * 的类, 而是虚拟机在运行时专门创建的类

    * 类型的命名规则是:

    *      每一维度用一个[表示;

    *      [后面是数组中元素的类型(包括基本数据类型和引用数据类型)

    *

    * 在java语言层面上,s是数组,也是一个对象,那么他的类型应该是String[],

    * 但是在JVM中,他的类型为[java.lang.String

    *

    * 顺便说一句普通的类在JVM里的类型为 包名+类名, 也就是全限定名

    */

    }

    public static class Father {

    }

    public static class Son extends Father {

    }

    }

    转: http://blog.csdn.net/zhangjg_blog/article/details/16116613

    展开全文
  • numpy数组(ndarray)属性

    千次阅读 2019-07-04 14:29:32
    numpy数组属性 详细信息请查询菜鸟笔记,欢迎转载! NumPy 数组的维数称为秩(rank),一维数组的秩为 1,二维数组的秩为 2,以此类推。 NumPy中,每一个线性的数组称为是一个轴(axis),也就是维度(dimensions)...
  • 下列不属于数据分析应用场景的是____________ A. 产品销量分析 B. 码头货物吞吐量预测 C. 计算机硬盘使用寿命预测 D. 某人一生的命运预测 答案 :D 下列不属于Python优势的是____________ A. 语法简洁,程序开发...
  • 下面小编就为大家带来一篇JS 判断某变量是否为某数组中的一个值的3种方法(总结)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 3.1 length属性 3.2 in运算符 3.3 for...in循环和数组的遍历 3.4数组的push()和pop()方法 4 数组的空位 4.1 使用delete命令删除一个值,会形成空位。 1 数组的定义 数组(array)是按次序排列...
  • 数组

    2021-03-10 00:56:13
    数组(Array)是有序的元素序列。[1]若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为...
  • 最近遇到了一道多条件排序题,类似于“something有A,B,C三个属性,先比较A,A条件相同时再比较B,B条件相同时再比较C,排序输出”的形式。这类题目用C/C++解决起来会很顺手,可以用结构体,结合sort和compare,就能...
  • 概念: 索引数组 ==== >>>$arr = []; 关联数组 ====>>> $arr = [ 'orange'=>1,'apple'=>'good' ];...在tp5之后,索引数组不能直接转关联数组,必要通过isset进行判断,然后才能给...
  • 数组的概念一个数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。数组中各元素的类型相同,通过下标的方式来访问数组中的元素,下标从0开始。由此得出,数组具有....
  • 如何判断一个对象是数组

    千次阅读 多人点赞 2020-10-09 10:55:43
    文章目录一、typeof方法二、Instanceof与constructor属性1.Instanceof2.constructor属性注意三、Object.prototype.toString.call()方法四、Array.isArray()总结 一、typeof方法 当涉及到检测数据的问题时,我们首先...
  • js数组常用方法,易错点总结。数组独立拷贝;数组相等的判定;
  • Java数组详解

    2021-03-08 18:37:35
    Java数组详解数组详解1、数组概述数组是相同类型数据的有序集合每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们2、数组声明和创建①数组声明形式dataType[] arrayRefVar; //首选的方法dataType...
  • js判断是否是数组的方法

    万次阅读 2018-09-11 17:11:52
    要注意,instanceof Array 只适用于与数组初始化在相同上下文中才有效,且能跨iframe 2.Array.isArray() Array.isArray([1,2,3]); 3.constructor constructor 在其对应对象的原型下面,是自...
  • 数组是javascript必可少的一项,今天让我们来总结一下数组操作的一些常用方法。 数组数组中常用方法 数组是对象类型的,属于特殊的对象 let ary = [12, 23, 34, 45] console.log(typeof Ary) // =>"object...
  • Java中的数组类型

    千次阅读 2020-08-02 21:12:12
    Java中的数组从运行机制上是没有多维的,但是Java中支持多维结构的语法,下面我们就来谈一下Java中的一位数组个多维数组 一.一维数组 1.数组的理解 数组(Array),是多个相同类型数据按一定顺序排列 的集合,并使用一...
  • slice 不会修改原数组,只会返回一个浅复制了原数组中的元素的一个新数组,如何理解slice方法的浅拷贝呢?
  • 一维数组转化为二维数组 使用场景举例:接口返回一个数组对象,展示时每行固定显示n个,则可将返回的数组转成二维数组[[...n], [...n]...]的形式循环展示。 分析:我们将一维数组,截取设定的长度,放入的一个新...
  • 目录一、前置知识二、初识 Numpy NumPy 是数据分析的三大剑客之一,主要用于数组计算、矩阵运算和科学计算。...下面让我们揭开 NumPy 的神秘面纱,开启 NumPy 之旅!本文学完之后,笔者还会提供相应的
  • 在前端面试中,我们经常会被问道,如何判断一个对象是不是数组类型,下面就这一点展开详细的描述,并总结一下共有几种方法。1.我们首先回顾一下typeof操作符的用法操作符可以用来检测给定变量的数据类型,返回的值有...
  • 数组竟然是对象

    千次阅读 2015-12-15 20:14:30
    起源事件起源是论坛里的一篇帖子,关于数组的.lenth多次调用是否会影响效率,回帖中发现有人说数组是类,调用类的.lenth属性就是看一下值,速度不会慢,云云。然后我就非常同意的问人家“数组是对象?”,其实有点...
  • 具有length属性 按索引方式存储数据 没有数组中方法 var fakeArray = { length: 3, "0": "first", "1": "second", "2": "third" }; for (var i = 0; i < fakeArray.length; i++) { c...
  • java定义一个对象数组

    千次阅读 2021-04-10 10:50:12
    java怎么定义一个动态数组,Java初学者入门应该掌握的30个概念,java定义一个对象数组,java一维数组定义摘要: java 是面向对象程序设计语言, 对象数组作为 javase 中的基础...Java 中数组的声明一维数组的声明: 在 ...
  • JS几种数组遍历方式总结

    千次阅读 2021-01-17 16:26:57
    JS数组遍历的几种方式S数组遍历的几种方式JS数组遍历,基本就是for,forin,foreach,forof,map等等一些方法,以下介绍几种本文分析用到的数组遍历方式以及进行性能分析对比第一种:普通for循环代码如下:for(j = 0;...
  • c中怎么输出数组的值

    2021-05-22 12:36:57
    如果有过用其它语言编程的经历,那么想必会熟悉数组的概念。...因为 Visual Basic对每一个索引值都分配空间,所以不要切实际声明一个太大的数组。注意:这一部分讨论的数组是程序中声明的变量...
  • 数组是分配在栈中的

    千次阅读 2018-07-03 18:02:00
    关于JAVA堆,下面说法错误的是()? 正确答案: C 你的答案: B (错误) 所有类的实例和数组都是在堆上分配内存的 堆内存由存活和死亡的对象,空闲碎片区组成 数组是分配在栈中的 对象所占的堆内存是由自动内存管理...
  • Golang数组和切片

    2022-04-06 16:30:35
    Golang中的「数组」和「切片」都是存储同一数据类型的容器,只不过Golang中的数组长度是固定的,而切片的长度是可变化的。我们日常应用中还是切片的占比还是比较大的,本篇文章我们来详细探讨下这两种数据类型 ...
  • python实现判断数组是否包含指定元素的方法本文实例讲述了python实现判断数组是否包含指定元素的方法。分享给大家供大家参考。具体如下:python判断数组是否包含指定的元素的方法,直接使用in即可,python真是简单...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 140,138
精华内容 56,055
关键字:

下面不属于数组属性的是