精华内容
下载资源
问答
  • 数组是JavaScript提供的一个内部对象,它一个标准的集合,我们可以添加(push)、删除(shift)里面元素,我们还可以通过for循环遍历里面的元素。 那么除了数组我们在JavaScript里还可以有别的集合吗? 由于...
    Array【数组】和Object【对象】的特性比较 
    数组是JavaScript提供的一个内部对象,它是一个标准的集合,我们可以添加(push)、删除(shift)里面元素,我们还可以通过for循环遍历里面的元素。

    那么除了数组我们在JavaScript里还可以有别的集合吗?

    由于JavaScript的语言特性,我们可以向通用对象动态添加和删除属性。

    所以Object也可以看成是JS的一种特殊的集合。

    下面比较一下Array和Object的特性:



    Array:

    新建:var ary = new Array(); 或 var ary = [];

    增加:ary.push(value);

    删除:delete ary[n];

    遍历:for ( var i=0 ; i < ary.length ; ++i ) ary[i];



    Object:

    新建:var obj = new Object(); 或 var obj = {};

    增加:obj[key] = value; (key为string)

    删除:delete obj[key];

    遍历:for ( var key in obj ) obj[key];



    从上面的比较可以看出Object完全可以作为一个集合来使用。

    如果我们要在Array中检索出一个指定的值,我们需要遍历整个数组:

    var keyword = “keyword”;
    for ( var i=0 ; i < ary.length ; i++ ) {
      if ( ary[i] == keyword ) {
       // todo
      }
    }

    而我们在Object中检索一个指定的key的条目,只需要是要使用:

    var key = “key”;
    var value = obj[key];
    // todo

    Object的这个特性可以用来高效的检索Unique的字符串集合,遍历Array的时间复杂度是O(n),而遍历Object的时间复杂度是O(1)。

    虽然对于10000次集合的for检索代价也就几十ms,可是如果是1000*1000次检索或更多,使用Object的优势一下就体现出来了。

    对于集合的遍历效率(从高到低): var value = obj[key]; > for ( ; ; ) > for ( in ) 效率最差的就是for( in )了,如果集合过大,尽量不要使用for ( in )遍历。



    posted @ 2013-08-24 13:15 前端攻城师-CZF 阅读(6) 评论(0) 编辑
    JS数组操作
    shift():删除原数组第一项,并返回删除元素的值;如果数组为空则返回undefined

    var a = [1,2,3,4,5];
    var b = a.shift();
    //结果 a:[2,3,4,5] b:1

    unshift():将参数添加到原数组开头,并返回数组的长度

    var a = [1,2,3,4,5];
    var b = a.unshift(-2,-1);
    //结果 a:[-2,-1,1,2,3,4,5] b:7

    //注:在IE6.0下测试返回值总为undefined,FF2.0下测试返回值为7,所以这个方法的返回值不可靠,需要用返回值时可用splice代替本方法来使用。

    pop():删除原数组最后一项,并返回删除元素的值;如果数组为空则返回undefined

    var a = [1,2,3,4,5];
    var b = a.pop();
    //结果:a:[1,2,3,4] b:5

    push():将参数添加到原数组末尾,并返回数组的长度

    var a = [1,2,3,4,5];
    var b = a.push(6,7);
    //结果 a:[1,2,3,4,5,6,7] b:7

    concat():返回一个新数组,是将参数添加到原数组中构成的

    var a = [1,2,3,4,5];
    var b = a.concat(6,7);
    //结果 a:[1,2,3,4,5] b:[1,2,3,4,5,6,7]

    splice(start,deleteCount,val1,val2,...):从start位置开始删除deleteCount个元素,并从该位置起插入val1,val2,...

    var a = [1,2,3,4,5];
    var b = a.splice(2,2,7,8,9);
    //结果 a:[1,2,7,8,9,5] b:[3,4]

    var b = a.splice(0,1);
    //结果同shift

    a.splice(0,0,-2,-1); var b = a.length;
    //结果同unshift

    var b = a.splice(a.length-1,1);
    //结果同pop

    a.splice(a.length,0,6,7); var b = a.length;
    //结果同push

    reverse():将数组反序

    var a = [1,2,3,4,5];
    var b = a.reverse();
    //结果 a:[5,4,3,2,1] b:[5,4,3,2,1]

    sort(orderfunction):按指定的参数对数组进行排序

    var a = [1,2,3,4,5];
    var b = a.sort();
    //结果 a:[1,2,3,4,5] b:[1,2,3,4,5]

    slice(start,end):返回从原数组中指定开始下标到结束下标之间的项组成的新数组

    var a = [1,2,3,4,5];
    var b = a.slice(2,5);
    //结果 a:[1,2,3,4,5] b:[3,4,5]

    join(separator):将数组的元素组起一个字符串,以separator为分隔符,省略的话则用默认用逗号为分隔符

    var a = [1,2,3,4,5];
    var b = a.join("|");
    //结果 a:[1,2,3,4,5] b:"1|2|3|4|5"
    展开全文
  • Object数组

    千次阅读 2019-08-27 11:42:16
      正常来说,相比于泛型,数组类型一种协变类型,即如果类S类F的子类,那么,S[]类型的数组是F[]类型数组的子类,即从类型S[]转换到F[]隐式转换的,那么由于Object是所有类型的父类,因此任何数组转换到...

    1. 数组的协变性

      正常来说,相比于泛型,数组类型是一种协变类型,即如果类S是类F的子类,那么,S[]类型的数组是F[]类型数组的子类,也即从类型S[]转换到F[]是隐式转换的,那么由于Object是所有类型的父类,因此任何数组转换到Object数组都是一定成功的。
      关于Object数组转换到String数组有一个地方需要注意:

    2. Object数组与String数组的转换

    测试代码块2-1

    	Object[] string={"hehe","lii"};
    	String[] strings=(String[])string;
    

      运行时会报错:

    java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

      下面来测试一下通过{" str1",“str2”}创建的到底是一个String数组还是一个Object数组,因为如果创建的是一个String数组,那么string引用实际上指向的是一个String数组,那么强制转换肯定是会成功的。

    测试代码块2-2

    	Object[] string={"hehe","simida"};
    	if(string instanceof String[])
    	{
    		out.println("string实际上是字符串数组类型");
    	}
    	else
    	{
    		out.println("string实际上是Object数组类型");
    	}
    

    输出:

    string实际上是Object数组类型

      可以看出通过{" str1",“str2”}创建的是一个Object数组,但是Object数组中的每一个元素都实际上指向了一个String对象。这可以通过以下代码来进行验证:

    测试代码块2-3

    	Object[] string={"hehe","simida"};
    	for(int i=0;i<string.length;i++)
    	{
    		String string1=(String)string[i];
    		out.println(string1);
    	}
    

    输出:

    hehe
    simida

      但是这种数组还是一个Object数组,不是一个String数组。
      而如果通过以下方式创建Object数组,转换不会出错。

    测试代码块2-4

    	Object[] string=new String[]{"hehe","lii"};
        if(string instanceof String[])
        {
            out.println("string实际上是字符串数组类型");
        }
        else
        {
            out.println("string实际上是Object数组类型");
        }
        String[] strings=(String[])string;
    

    输出:

    out.println(“string实际上是字符串数组类型”);

      因为new String[] 方式创建的就是一个字符串数组。

    展开全文
  • Swift中数组是一种数据结构,用来存放多个形同类型的数据结构,数据在数组内的存放有序的,存进来的数据个读出来的顺序相同 Object-C 中数组能够存放任意类型的数据类型为... Object-C 数组有两种形式
    Swift中数组是一种数据结构,用来存放多个形同类型的数据结构,数据在数组内的存放是有序的,存进来的数据个读出来的顺序相同
    

    Object-C 中数组能够存放任意类型的数据类型为[AnyObject]

     

    Swift中数组有两种形式:

    可变数组:用var修饰,数组的内容及长度可以任意修改

    不可变数组:用let修饰,数组的内容及长度都不能修改

    Object-C 数组中也有两种形式

    不可变数组:let arr: NSArray = NSArray.init(objects: 10,”hello”,1.234)

    可变数组: let arr: NSMutableArray = NSMutableArray.init(capacity:0)

    将数组所有内容全部赋给另一个数组(用于表格、集合视图中)

    let arr = NSArray.init(array: arr1)

    let arr = NSArray.init(object: arr1)

    创建空数组(4种):

    let arr: [Int]  = [Int]()

    let arr: Array<String> = Array<String>()

    let arr: [Double] = Array()

    let arr: [Int] = []

    使用简单方法创建数组:

    var arr:[Int] = [1,2,3,4,5,6]

     

    指定元素个数和元素内容:

    var arr = Array<Int>(count :2,repeatedValue: 100)

    //[100,100]

    指定元素内容:

    var arr = Array(arrayLiteral:“Hello World”)

    判断数组中的元素是否为空

    if arr.isEmpty{

    print(“空”)

    }

     

    if arr.count == 0{

    print(“空”)

    }

    访问数组的元素

    根据下边查找:下标从0开始,最后一个元素下标 = 数组中的元素个数 - 1

    遍历数组中的所有元素:

    Swift:

    for i in arr{

    print(i)

    }

    for i in arr.count - 1{

    print(arr[i])

    }

    Objective -C

    for i in 0…arr.count - 1{

    print(arr[i])

    }

    for i in arr{

    print(i)

    }

    获取指定范围内的元素:

    print(arr[0…2])

    查找某个元素首次在数组中出现的位置:

    if arr.contains(“Hello”){

    print(arr.indexOf(“Hello”)!)

    }

    Objective - C:

    if arr.containsObject(“Hello”){

    print(arr.indexOfObject(“Hello”)) // 输出的是索引的地址

    }

    Objective - C  获取数组中第一个元素和最后一个元素

    print(arr.firstObject)

    print(arr.lastObject)

    向数组中添加内容:

     

    追加单个元素

    arr.append(“Swift”)

    Objective -C

    arr.addObject(“Swift”)

    追加整个数组

    arr.appendContensOf([1,2,3,4,54])

     

    Objective -C

    arr.addObject([1,2,3,4,54])

    使用加号追加新的内容

     

    arr += [1,2,3,4,45]

     

    向指定位置插入元素

     

    arr.insert(“swift”,atIndex: 1) //插入单个元素

    arr.insertContensOf([1,2,3,4], at : 0) //插入数组

    Objective-C

    arr.insertObject(“swift”,atIndex: 1)

    通过下标区间插入元素

     

    arr[0…2] = [1,”HELLO”,3]

    删除数组元素

    arr.removeFirst() //删除第一个元素

    arr.removeLast() //删除最后一个元素

    Swift

    arr.removeAtIndex(3) //删除指定索引的元素

    Objective-C

    arr.removeObjectAtIndex()

    Swift

    arr.removeRange(0…4) //删除一定范围内的元素

    Objective -C

    arr.removeObjectInRange(NSRange.init(location:0,length: 1))

    Swift

    arr.removeAll() //清空整个数组

    Objective -C

    arr.removeAllObjects

    Objective-C

    arr.removeLastObject //删除最后一个元素

    if arr.containsObject(“123”){ //删除指定元素,重复的会全部删除

    arr.removeObject(“123”)

    }

    修改数组中的内容

    arr[4] = “修改的内容” //修改指定下标的元素

    arr.replaceRange(0…3,with:[3]) //修改一定范围内的元素

    arr[0…3] = [1000,2000]

    Objective -C

    arr.replaceObjectAtIndex(0,withObject:”1234”)

     

    数组排序

    arr.sortInPlace //系统提供的排序函数,只能做升序

     

    冒泡排序:

     

    第一趟:0

        100,998,-10,50,1,30

        100,-10,998,50,1,30

        100,-10,50,998,1,30

        100,-10,50,1,998,30

        100,-10,50,1,30,998  ------ 998

     

    第二趟:1

        -10,100,50,1,30,998

        -10,50,100,1,30,998

        -10,50,1,100,30,998

        -10,50,1,30,100,998  -------100

     

    第三趟:2

        -10,50,1,30,100,998

        -10,1,50,30,100,998

        -10,1,30,50,100,998  -------50

     

    第四趟:3

        -10,1,30,50,100,998

        -10,1,30,50,100,998  -------30

     

    第五趟:4

        -10,1,30,50,100,998  -------1

    //冒泡排序外层控制趟数内层控制每一趟比较的次数

    for i in 0..<tmp_arr.count - 1{

    //比较的趟数=元素的个数-1

        for j in  0..<tmp_arr.count - i - 1 {

             if tmp_arr[j] < tmp_arr[j + 1] {

    //if 语句就是实现交换功能

    let tmp = tmp_arr[j]

      //交换两个数的大小 使用第三个变量做桥接

                tmp_arr[j] = tmp_arr[j + 1]

                tmp_arr[j + 1] = tmp

            }

        }

    }

    将数组中的元素用指定的字符进行拼接

    let arr1:NSArray = [1,2,3,”china”,98.0]

    let str1 = arr1.componentJoinedByString(“-”)

    //str1 = 1-2-3-china-98.0

    将字符串按照指定的字符串进行分割(分割的结果是一个数组)

    var arr2: NSArray = str1.componentSeparatedByString(“-”)

    交换数组中元素的显示位置

    arr.exchangeObjectAtIndex(0,withObjectAtIndex:2)

     

    例子:

    // 设计⼀个学生类,成员有姓名,年龄。 要求创建三个学生类对象,分别按年龄升序,名字降序进行排序

    class Student {

        var name: String

        var age: Int

        

        init(name: String,age: Int) {

            self.name = name

            self.age = age

        }

    }

    let stu1 = Student.init(name: "stu1", age: 10)

    let stu2 = Student.init(name: "stu2", age: 7)

    let stu3 = Student.init(name: "stu11", age: 20)

     

    let arrayStu = NSMutableArray.init(capacity: 0)

    arrayStu.addObject(stu1)

    arrayStu.addObject(stu2)

    arrayStu.addObject(stu3)

     

    for i in 0..<arrayStu.count - 1 {

     

        for j in 0..<arrayStu.count - 1 - i {

        

            var tmp1 = arrayStu[j] as! Student

            var tmp2 = arrayStu[j + 1] as! Student

            

            if tmp1.name < tmp2.name {

            

                arrayStu.exchangeObjectAtIndex(j, withObjectAtIndex: j + 1)

            }                

        }

    }

    展开全文
  • Java 数组的本质一个Java类,它通过new语句来实例化,但是这个new语句却不会实例化数组中的对象,我们对它的理解有些偏差...其实,引用数据类型的数组也会分配指定长度的内存空间,只不过这些内存空间用来保存

     Java 数组的本质是一个Java类,它是通过new语句来实例化,但是这个new语句却不会实例化数组中的对象,我们对它的理解有些偏差。

       对于基本类型的数组,在new语句创建数组实例时,会为该数组分配指定长度的内存空间,并把数组的每个元素的初始化为0。那么,引用类型的数组又是如何来创建和初始化这些内存空间的?其实,引用数据类型的数组也会分配指定长度的内存空间,只不过这些内存空间是用来保存引用的,而不是具体的值,它的初始化值为null

    Object[]obj=new Object[5];

    以上代码中,创建了一个Object数组,长度为5,这5个元素的值都是null,然后把创建好的数组实例的引用赋给obj变量。如果需要为这些元素分配具体的对象,则需要分别指定或用{}符号进行初始化,如下所示:

    Object[]obj=new Object[]{new Object(),null,null,null,new String("123")};//引用类型的数组

    obj[0]=new Object();//数组元素在赋对象引用

    obj[4]=new String("123");

    以上数组实例的内存构成,如图:


    总结:

    答案为否。其实是创建了一个数组实例,长度为5,每个数组元素的值均为null,并没有创建5Object对象。如果需要创建5Object对象,则需要为每个数组元素分别指定或用符号{}


    展开全文
  • 数组是JavaScript提供的一个内部对象,它一个标准的集合,我们可以添加(push)、删除(shift)里面元素,我们还可以通过for循环遍历...所以Object也可以看成JS的一种特殊的集合。 下面比较一下Array和Object的特...
  • 数组也是对象

    2019-09-03 08:54:43
    Object类是一个特殊的类,是所有类的...数组的父类也是Object,java中的数组是对象。java中数组的创建使用了关键字new,数据基本类型只有 boolean, byte, short, char, int, long, float, double 8种。 // Java pr...
  • int[][] a1=new int[3][6]; Object object=a1; Object[] objects=a1; System.out.println(object==objects); ... 这个该怎么解释,难道一个二维数组对象即使Object对象也是Object数组对象?
  • 数值数组Object数组的关系

    千次阅读 2013-01-19 12:35:16
    int等等的那些基本类型的父类都是Object,数组的父类也是Object,注意!!! int[]不能强制转换成Object[],因为int[]是Object对象,因此 int[][]才能转换成Object[] String[]则不一样,因为 String的父类就是...
  • 首先从错误提示看,明显意思是你给出ibatis的参数不对路,人家不认识,我也是被这个提示误导了 1.先来个小学的 //传入的参数只有数组/集合/迭代器的时候 public List findall(SqlMapClient sqlMap, String[]...
  • Java数组也是对象

    2019-09-02 21:03:33
      数组是相同类型数据的有序集合,并且有固定的长度,在内存中占据连续的空间。。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个...数组的父类也是Object,instanc...
  • 数组也是对象,对象从内建函数Object()实例的来的,Array()是从Object()扩展而来,数组Array()实例来的,
  • java中数组是对象吗?

    千次阅读 多人点赞 2018-08-27 19:40:51
    数组是对象哦。数组的父类也是Object,每个数组都实现了接口...但是由于数组也是Object的子类,我们可以打印出数据的类型名。 // Java program to display class of // int array type public class Test { pub...
  • 如何判断数组是数组

    2021-06-25 10:26:33
    constructor: 这样 a.constructor == Array直接判断当前对象的构造函数是不是数组也可以 toString:每一个继承自Object的对象都拥有toString的方法,其他数据类型toString都会返回字符串,只有object对象的toString...
  • 对于数组Object的一些关系

    千次阅读 2011-01-18 16:22:00
    int等等的那些基本类型的父类都是Object,数组的父类也是Object,注意!!!int[]不能强制转换成Object[],因为int[]是Object对象,因此 int[][]才能转换成Object[]String[]则不一样,因为 String的父类就是Object,...
  • 数组也是 Object 的子类对象,所以同样具有构造器,只是语法稍有不同 @FunctionalInterface public interface ArrayBuilder { //抽象方法,传入一个长度,返回一个int数组 ... 数组也是object的子类对象...
  • flex object 联合数组

    2018-01-12 16:55:26
    问题我要创建用名称元素作为索引的数组解决办法创建联合数组讨论用联合数组...联合数组在其他的语言叫做哈希表,在ActionScript 里它就是Object 类的一个实例,联合数组使用名称元素来代替数字下标,该名称被称为关键
  • 此问题的一个可行的答案是是检查该变量是不是object,并且检查该变量是否有数字长度(当为空array时长度可能为0)。 然而,参数对象【arguments object】(传给制定函数的所有参数),可能会适用于上述方法,...
  • 数组

    2021-05-02 13:33:54
    数组的父类是object。 2.数组实际上是一个容器,可以容纳多个元素。数组是数据的集合,是集合中最简单的一种类型。 3.数组可以存储基本数据类型数据,可以存储引用数据类型数据,但是在数组中存储引用数据类型时...
  • 数组竟然对象

    千次阅读 2015-12-15 20:14:30
    起源事件起源是论坛里的一篇帖子,关于数组的.lenth多次调用是否会影响效率,回帖中发现有人说数组是类,调用类的.lenth...经过论坛里同学给出了比较合理的反驳理由,就是下面这张图:已经比较直观地说明数组是Object
  • 关于java中数组也是对象的强悍解释

    千次阅读 2007-06-14 01:28:00
    Object[] objs = new Object[3];Object obj = objs;objs = (Object[])obj;另外,下文对java中的数组的本质做了一些探讨:http://dev.csdn.net/author/DeepNightTwo/afb7e220bdf5423ba656f84b6a183b44.html...
  • 数组数组的区别

    2021-04-11 15:49:46
    数组数组的区别 ...不同点:数组对象的类型是Array,类数组对象的类型是object就是说类数组原型是Object;类数组不具有数组所具有的方法,数组遍历可以用 for in和for循环,类数组只能用for循环遍历。 ...
  • 数组也是Object对象。 数组通过数组名加索引来使用数组的元素,索引从0开始。 声明数组 声明数组有两种格式: float boy[]; char[] girl; int cat[][]; double[][] pig; 那么数组b...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,379
精华内容 1,751
关键字:

数组也是object