精华内容
下载资源
问答
  • 数组的两种创建方式
    千次阅读
    2018-08-28 22:04:25

    1. 通过构造函数创建数组

    • 数组:一组有序的数据
    • 数组元素:数组中存储的每个数据,都可以叫数组的元素,比如:存储了3个数据,数组中3个元素
    • 数组长度:就是数组的元素的个数,比如有3个元素,就说,这个数组的长度是3
    • 数组索引(下标):用来存储或者访问数组中的数据的,索引从0开始,到长度减1结束
    • 数组的索引和数组的长度的关系:长度减1就是最大的索引值

    var 数组名=new Array();

    //定义了一个空 的数组
    var array1 = new Array();
    
    //定义了一个长度为6的数组
    var array2 = new Array(6);
    
    // 输出数组的每个值都是 undefined
    console.log(array2);
    
    
    //可以直接定义数组的具体值
    var array3 = new Array(2018, 04, 10, 2016, 11, 22);
    
    console.log(array3) // [2018, 04, 10, 2016, 11, 22];
    
    // 设置数组中某个位置的值
    
    array3[0] = 520;
    
    console.log(array3) // [520, 04, 10, 2016, 11, 22];
    
    // 获取数组中某个位置的值
    
    console.log(array3[1]) // 04
    
    

     

    2. 通过字面量的方式创建数组

    var 数组名=[];
    var array=[];

    // 定义空数组
    var array=[];
    
    var arr=[520, 04, 09, 07, 27, 04, 10];

     

    更多相关内容
  • JavaScript对象之数组(一)

    千次阅读 2020-03-19 15:50:49
    创建数组的基本方式有两种: 1、使用Array构造函数         语法:new Array()         小括号()说明:     ...

    Array数组(1)


    如何创建数组

    创建数组的基本方式有两种:

    1、使用Array构造函数
            语法:new Array()
            小括号()说明:
            (1)预先知道数组要保存的项目数量
            (2)向Array构造函数中传递数组应包含项
    2、使用数组字面量表示法
             由一对包含数组的方括号[ ]表示,多个数组项之间以逗号隔开

    数组元素的读写

        读取和设置值时,使用方括号[ ]并提供相应的索引

    说明:

        索引是从0开始的正整数


    选择练习1

    关于数组的描述,下列说法正确的是? (选择两项)

    A 数组可以用来保存一组不同类型的数据
    B 数组的length属性可以获得数组的长度
    C 数组的索引是从1开始的正整数
    D 使用()获取数组的索引

    正确答案: A,B
    参考解析:本题考察的是数组的概念和运用,正确选项为AB;数组可以用来保存一组不同类型的数据,数组的length属性可以获得数组的长度,数组的索引是从0开始的正整数,使用[ ]获取数组的索引。

    选择练习2

    创建数组的基本方式有两种,下列创建数组的方式错误的是?(选择一项)

    A var arr=new Array(1);
    B var arr=new array( );
    C var arr=[ ];
    D var arr=[ 1,2,“3”];

    正确答案: B
    参考解析:
    本题考察的是数组的创建方式,选择写法错误的,应选择B;
    第一种方式是使用new Array()构造函数,第二种是直接使用包含数组项的[ ]来表示

    选择练习3

    下面这段代码运行结果是?(选择一项)

    var arr=new Array(3);
    arr[0]=1;
    arr[1]=2;
    arr[2]=3;
    arr[3]=4;
    console.log(arr.length);
    console.log(arr[4]);
    

    A 控制台输出3和4
    B 控制台输出4和4
    C 控制台输出4和undefined
    D 控制台输出3和undefined

    正确答案: C
    参考解析:
    本题考察的是数组的读写,正确选项为C;
    数组的构造函数中虽然表明有3个项,但是我们还是可以后面继续添加项,所以这个数组的长度为4。但是这个数组的索引最大是3,索引为4的项没有定义,所以是undefined。

    选择练习4

    下面这段代码运行结果是?(选择一项)

    <script>
    	var arr=[1,2,3,4,5];
    	arr[0]=0;
    	arr[5]=0;
    	console.log(arr);
    </script>
    

    A [0, 2, 3, 4, 5, 0]
    B [1, 2, 3, 4, 5]
    C [0, 1, 2, 3, 4, 5, 0]
    D [0, 1, 2, 3, 4, 5,]

    正确答案: A
    参考解析:正确选项为A;数组的索引是从0开始,数组可以通过索引的形式为数组添加项,也可以通过索引的方式去修改当前数组的项。

    选择练习5

    下面这段代码运行结果是?(选择一项)

    var arr=new Array(1,"hello",true);
    arr[2]=false;
    arr[3]=null;
    arr[4]=undefined;
    console.log(arr);
    

    A 控制台输出[1,“hello”,true]
    B 控制台输出[1,“hello”,false]
    C 控制台输出[1,“hello”,false,null,undefined]
    D 控制台输出[1,“hello”,true,null,undefined]

    正确答案: C
    参考解析:本题考察的是数组的读写,正确选项为C;数组可以通过索引的形式为数组添加项,也可以通过索引的方式去修改当前数组的项,而且数组里的数据可以是所有的数据类型。

    编程练习

    小伙伴们,学习了数组的创建和应用,那么接下来,根据效果图,用new的方式创建一个数组,并将这个数组以及数组的长度输出在页面中,一起来试试吧!
    效果图如下:
    效果图

    任务

    第一步:用new的方法创建一个数组,数组里面有3个数据,分别是《三国演义》,《红楼梦》,《西游记》
    第二步:用索引的方式给这个数组添加一个《水浒传》
    第三步:控制台输出这个数组并输出数组的长度

    参考代码

    <!DOCTYPE html>
    <html>
    	<head>
    		<meta charset="UTF-8">
    		<title>创建数组</title>
    	</head>
    	<body>
    		<script>
    			var arr=new Array("《三国演义》","《红楼梦》","《西游记》");
    			arr[3]="《水浒传》"
    			console.log(arr);
    			console.log(arr.length);
    		</script>
    	</body>
    </html>
    
    
    展开全文
  • Javascript 数组创建

    2019-12-30 15:04:03
    //创建数组的三种方式 var arr = []; var arr = new Array(); var arr = new Object([]);//一般不用 数组是将一组无序的数据以有序的方式进行排列。 数组是一个引用列表,列表的特点:有顺序、只有值、紧密、速度慢...

    数组的创建有三种方式:

    1. 字面量创建
    2. 构造函数方式创建
    3. 根据对象创建数组(一般不用)
    //创建数组的三种方式
    var arr = [];
    var arr = new Array();
    var arr = new Object([]);//一般不用
    

    数组是将一组无序的数据以有序的方式进行排列。
    数组是一个引用列表,列表的特点:有顺序、只有值、紧密、速度慢。
    数组是依赖于对象创建的,它的索引值在用的时候会转成字符串。

    字面量创建方式

    var arr = [3,2,3,4];
    //arr是数组 1是索引值(下标) arr[1]是元素(下标变量),arr[1]是一个变量
    console.log(arr[0]);//3
    //数组是依赖于对象创建的,它的索引值在用的时候会转成字符串。
    console.log(arr["1"]);//2
    
    //可以修改下标变量的结果
    arr[1]=10;
    console.log(arr[1]);//10
    
    //给第4项添加了7
    arr[4]=7;
    console.log(arr);//[3,2,3,4,7]
    
    //给第7项添加了9 数组的紧密性,如果中间空余,就会自动补充空元素
    arr[7]=9;
    console.log(arr);
    //火狐下显示 [ 3, 2, 3, 4, undefined, undefined, undefined, 9 ]
    //chrom下显示[3, 2, 3, 4, empty × 3, 9]
    

    数组只有值的存储,只能遍历数组才能获取值是否存在

    var a=[1,2,3,4,5];
    for(var i=0;i<5;i++){
    	console.log(arr[i]);
    }
    

    遍历内容较多,当添加删除元素时,因为数组的紧密性,这个数组就必须向后或者向前挪,速度变慢,尤其是在前面插入和删除。

    var a =[1,2,3,4];
    //当在第2位添加一个元素8时,第2位的2先往第3位挪动,此时第3位是有元素的,第3位再住第4位挪......
    

    当插入 arr [ -1] =10 时,不会改变数组的长度

    • 数组长度:表示当前数组的索引下标的数量,或者是索引下标的最大值加1,当添加的不是索引数据(从0开始),就不会累计在长度中,而作为对象的 key 和 value 来增加内容。
    var arr=[1,2,3,4,5];
    arr[-1]=10;
    console.log(arr);//打印出的结果如下图
    arr[arr.length]=10;//在数组的尾部添加一个新元素
    //每次添加元素后,长度会发生变化,length会变化的,因此下面这句不会修改数据的最后一个元素,而是添加了一个新元素。
    arr[arr.length]=11;
    //如果直接设置数组的长度,长度大于原来数组的长度时,添加空元素,让长度等于设置的长度
    arr.length=10;
    //如果长度比原来少一个,就会删除最尾部一个元素,以下两种写法相同
    arr.length=arr.length-1;
    arr.length--;
    //length=0时,表示清空数组
    arr.length=0;
    //如果直接让数组等于空,会造成数组的引用地址发生变化,原来的数组会永远留在堆中,造成内存泄露
    arr=[];
    //数组的长度不能为负值
    arr.length=-2;//报错
    //如果给的不是数值,会隐式转换为数值,如果值是NaN,就会报错
    arr.length=true;//相当于arr.length=1;
    

    打印出的结果如下图:
    在这里插入图片描述
    优先设置数组的长度
    数组内的元素类型要统一。

    构造函数创建方式

    var arr=new Array(1,2,3,4,5);//构造函数创建,构造函数实例化对象
    var arr=Array(1,2,3,4,5);//字符串转数组类型
    console.log(arr);
    

    Array () 比 new Array () ,创建要慢。

    • 数组通过构造函数创建时,如果只有一个参数,并且参数为正整数,那么这个数就是数组的长度,而不作为数组的新元素。
    • 如果是数字,但不是正整数,如-1,0.4,都会报错。
    • 如果不是数字,则作为数组的第一个元素添加。
    • 如果是多个参数,则直接作为数组的元素添加进去。
    var arr=new Array(5);
    console.log(arr);//声明了一个长度为5的空数组
    var arr = Array(5);
    console.log(arr);//同上,声明了一个长度为5的空数组
    var arr = new Array("4");
    console.log(arr);//["4"]
    var arr = new Array(3,4);
    console.log(arr);//[3,4]
    

    根据对象创建数组

    var arr = new Object([]);
    
    展开全文
  • 无法创建t的通用数组 在这篇文章中,我们将介绍一篇全面的文章,其中介绍了创建通用数组的问题。 Java编程语言于2004年9月在Java 5.0“ Tiger”发行版中添加了泛型。 泛型或类型参数化系统在提供类型安全性的同时...

    无法创建t的通用数组

    在这篇文章中,我们将介绍一篇全面的文章,其中介绍了创建通用数组的问题。 Java编程语言于2004年9月在Java 5.0“ Tiger”发行版中添加了泛型。 泛型或类型参数化系统在提供类型安全性的同时扩展了Java现有的类型系统。

    1.简介

    Java具有Collections Framework,它提供了用于Java软件开发的通用数据结构库。 集合框架缺少一种数据结构-数组。 但是,Java Collections Framework具有类型化参数化ArrayList.java和Vector.java数据结构。 两种数据结构都使用一维动态数组,该数组使用java.lang.Object的基础数组。

    Java提供了一个内置数组,该内置数组是自1995年以来的Java 1.0以来语言规范中所包含的对象。作为对象,内置数组在Java代码中声明并实例化为特定类型。 内置数组是对象的容器,对象的数量和长度是固定的,可能是多个维度。

    但是,使用泛型的编译时类型安全性尚未完全实现。 特别是内置数组对象。

    2.通用数组

    问题是当泛型与Java中的内置数组实体一起使用时。 考虑下面的Java类TestArray1.java,它在单个泛型类型参数E周围声明了两个泛型数组。Java类源代码为:

    class TestArray1 {
      public E[] array = new E[10];
    }//end class TestArray1

    TestArray1.java的源代码仅是声明性的,不使用数组。 编写了通用数组的两个用例:一个用于通用数组作为类属性,另一个用于在类的静态(即非实例)方法中使用通用数组。

    2.1编译时的一般错误

    编译时,编译器报告以下错误:

    Error: TestArray1.java.                                                             
          Line 3 At 22: generic array creation                                            
            public E[] array = new E[10];                                                 
                               ^

    报告了一种错误:通用数组创建。 此错误直接对应于通用数组的用例。

    协方差

    在Java中,数组是协变的,或对特定类型使用通用的类型专用化,例如对集合的集合。 但是,通用类型参数不是协变的。 Goetz解释说:“ Collections类使用一个丑陋的技巧来解决此问题……” [Goet 2019]

    因此,要将内置数组与Java泛型或泛型类型参数E一起使用,该数组必须为java.lang.Object类型,这是Java中的超大型类型。 一切都是一个java.lang.Object,这是丑陋的把戏。

    对象数组

    然而,使用对象数组的缺点是泛型必须将数据结构或变量绑定到特定类型。 对象类型的数据结构可以混合和匹配任何类型,并且需要类型转换才能转换为原始类型。 在这种情况下,Java中的泛型没有用处-这是核心问题。

    问题的解决方案或答案很简单-一个通用的Java数组类。 这样的类不在Java集合框架中,因此可以创建它。

    3. Java数组类

    Java Array类类似于Java集合框架中的其他数据结构,它是一个数据结构。 最初编写的实现是为了简单起见,并且不实现任何特定的接口或扩展任何超类。 目标是获得功能和有用的数组作为要构建的Array.java类。 通用类型参数Array.java类的框架为:

    class Array {
        Array(final int... dim);
        void init(final E elem);                                                             
        void init(final E[] elem);
        E get(final int...idx);
        void add(final E elem, final int... idx);					      	             
      }

    本质上,您可以构造任意级别的数组,然后构造任意大小的维度

    然后,该数组具有方法init()来将数组初始化为默认值或前哨初始值。 最后,数组具有两种主要方法,一种是在数组中的特定位置添加一个元素,另一个添加一个元素。 实例化或创建,初始化整个数组以及访问元素的基本功能。

    3.1数组类属性

    Java数组类具有几个属性,这些属性定义Array.java类的实例。 通用类型参数Array.java类的属性为:

    class Array {
        int size;                                                                             
        int dim[];                                                                            
        int rank;	                                                                             
        Object data[];                                                                    
        E elem;                                                                           
      }

    Array.java类属性是作为对象的内置数组的数据,该数组的边界,例如大小,等级,尺寸。 最后,还有一个元素,即初始化元素。

    3.2使用Varargs的等级和维度

    Java编程语言在2004年9月发行的Java 5.0“ Tiger”中添加了变量号或参数或自变量,命名为Java变量自变量,或更简单地说是varargs。此特殊功能允许构造函数或方法采用不同数量的参数,因此泛化参数,而不必仅仅为参数数量而复制构造函数或方法。

    Array类的一般化使用此特定的Java功能:varargs,或用于创建和访问Array.java类中的元素的变量参数。 这允许任何等级(维数),也允许任何非负整数的任何数字维。

    Varargs还允许等级为一般等级,因此Array.java类的等级(至少在理论上……)没有上限。 因此,可变参数允许在定义和使用通用Array.java类时进行整体概括。

    使用Varargs的构造函数

    Array.java构造函数的源代码说明了如何使用varargs作为维,以使用Array.java类创建通用数组对象。 等级和维度是通用的,因此任何维度范围的数组都可以排名。 Array.java构造函数的源代码为:

    Array(final int... dims) {                                                           
        this.rank = dims.length;                                                           
        this.dim  = new int[rank];                                                         
        int size  = 1;                                                                     
      
        //compute size of 1-dim internal array                                             
        for (int x = 0; x < dims.length; x++) {                                             
          size = size * dims[x];                                                           
          dim[x] = dims[x];                                                                 
        }//end for                                                                                                                                                      
      
        //create internal "flat" array                                                                                                            
        this.data = new Object[size];                                                  
        this.size = size;                                                                   
      }//end constructor

    varargs是作为基本int传递的可变参数,它们是变量dims中的整数数组。 根据暗淡程度,可以计算和创建数组边界的尺寸以及整个内部“平面”数组。 如果没有可变参数,则需要针对每个维度的不同维度的构造函数。 由于有限数量的构造函数用于等级,所以Array.java通用数组类将受到限制,而对于varargs而言则不那么普遍。

    带Varargs的访问器

    通过get和set方法访问通用数组中的元素。 这些是访问或访问方法。 与属性getter和setter方法不同,对于通用数组类,维度索引指定元素。

    使用varargs,可以概括访问任何等级或维度的访问方法。 对照通用数组的边界和等级检查维度索引以进行访问。

    读取访问者获取

    getter方法是读取访问器,它从数组读取或复制一个值。 Array.java的get访问器方法的源代码是:

    E get(final int... idx) {                                                            
        return (E) this.data[this.getIndex(idx)];                                      
      }//end get

    写访问器集

    setter方法是写访问器,它将值写入或复制到数组中。 Array.java set访问器方法的源代码是:

    void set(final E elem, final int... idx) {                                           
        this.data[this.getIndex(idx)] = elem;                                          
      }//end set

    为简单起见,辅助方法getIndex()进行了计算单个维度索引并检查数组索引边界的实际“繁重工作”。

    辅助方法

    在通用Array.java类中,三个辅助方法或辅助方法进行了实际处理。 一种方法,getIndex()从多个索引维度计算单个索引,其他两种方法isValidDim()和isValidIndex()验证所计算的索引或给定的索引没有超出数组的边界。 辅助方法的接口源代码为:

    class Array {
        int getIndex(final int... idx);
        boolean isValidDim(final int... idx);						       
        boolean isValidIndex(final int idx);					      	             
      }//end class Array

    繁重的工作获得元素索引

    getIndex()方法是Array.java类的核心功能。 getIndex()方法计算元素的内部一维线性或“平面”数组中的索引。 从编译器理论(这暗示了该理论,但更深入的解释超出了解释的范围),数组可以通过行主索引或列主索引来建立索引。 [Aho 2007]

    对于Array.java类,它是无关紧要的,只要函数对于数组实例的维边界的给定索引是一致的即可。 getIndex()方法的源代码是:

    int getIndex(final int... idx){                                                          
        isValidDims(idx);                                                                  
        int index = 0;                                                                     
        for(int x = 0; x < idx.length; x++) {                                             
          int i = idx[x];                                                                    
          for(int y = x + 1; y < idx.length; y++) {                                         
            i = i * dim[y];                                                                    
          }//end for                                                                                                                                                   
          index = index + i;                                                                 
        }//end for                                                                                                                                                        
        return index;                                                                          
      }//end getIndex

    getIndex()方法的源代码在实际计算内部线性数组中的一维索引之前,先验证索引的维度。

    索引验证

    有两种验证索引的方法。 一种是验证多维索引,另一种是验证单个索引。 验证一维索引的源代码为:

    void isValidIndex(final int idx){                                                        
        if(idx = this.size) throw new RuntimeException("Index Overflow Error!");             
      }//end isValidIndex

    isValidIndex()仅检查索引在数学上是否在零到内部数组整体大小的范围内。 如果索引不在该范围内,则会引发运行时未经检查的异常。 验证多维索引的源代码为:

    void isValidDims(final int... idx) {                                                   
        if(idx.length != this.dim.length) throw new RuntimeException("Rank Error");       
          for(int x = 0; x = dim[x]) throw new RuntimeException(“Index Overflow Error");         
            if(idx[x] < 0) throw new RuntimeException(“Index Underflow Error”);                            
          }//end for                                                                                                                                                    
      }//end isValidDims

    isValidDims()仅遍历每个维度参数,并检查索引的等级是否与数组的等级参数相同。 如果数组的等级和索引不相等,则会抛出运行时未经检查的异常RuntimeException。

    3.3其他非Varargs方法

    其他方法是非可变参数,它们不使用任何参数作为getter访问器方法,也可以采用单个参数。 这两种方法是:

    1. 查询数组参数
    2. 独特的阵列功能

    查询数组

    查询数组参数可以使用getter访问方法或使用参数来访问数组的参数。 该数组用于查询等级,整体大小,上部尺寸以及等级内特定索引处的尺寸。 用于查询Array.java类的数组方法的接口是:

    class Array {
        int getDim(final int dim);
        int[] getDims();
        int getRank();
        int size();					      	                                   
      }//end class Array

    独特的数组类功能

    独特的数组类功能是一个构造函数和两个提供独特功能的方法。 这两种方法是访问并转换为Array类实例的线性数组。 另一个功能是一个构造函数,该构造函数允许复制或复制Array类的实例。 Array.java类的功能是:

    class Array {
        Array(final Array array);
        E getAt(final int idx);
        Object[] toArray();							      
      }

    存取器为线性阵列

    getAt()方法允许访问数组元素,就像Array类实例是一维的“扁平”线性数组一样。 检查整数索引的有效性,并使用内部一维数组在有效位置返回元素。 作为线性数组访问的源代码为:

    E getAt(final int index) {                                                             
        this.isValidIndex(index); 				                                      
        return (E) this.data[index];                                                   
      }//end getAt

    转换为线性对象数组

    toArray()方法转换Array类实例,或者访问内部的一维数组并将其作为Object数组返回。 toArray()方法返回内部线性数组的浅表副本,而不是深表副本。 用于访问线性Object数组的getter访问器源代码为:

    Object[] toArray() {                                                                    
        return this.data;                                                              
      }//end toArray

    复制构造函数

    复制构造函数允许复制Array类实例,但将其复制为现有Array类实例的“深层”副本。 复制的数组和副本具有相同的类型参数,尺寸,等级和元素。 复制构造函数的源代码为:

    Array(final Array orig) {                                                              
        this.rank = orig.rank;                                                                       
        this.dim  = orig.dim;                                                                 
        this.size = orig.size;                                                               
        this.elem = (E) orig.elem;                                                    
        this.data = new Object[this.size];		                                    
        System.arraycopy(orig.data, 0, this.data, 0, this.size);                     
      }//end constructor copy

    System.arraycopy()复制原始文件,并为深度复制创建一个新的Object数组。 各种Array类实例参数被复制到深层副本中。

    4.使用通用数组类

    使用Java通用数组Array.java在源代码中通过两个用法示例进行了说明:

    1. 气泡排序算法
    2. 乘法表

    这两个示例都通过演示来说明如何使用通用数组类方法围绕数组创建,初始化,访问,查询和实现功能,但不使用内置Java数组。 源代码说明了源代码片段的输出。

    4.1气泡排序

    冒泡排序是一种基本的简单排序算法,但是非常适合说明Array.java通用数组类的用法。 冒泡排序是通过以下通用Java数组实现的:

    Array list = new Array(9).init(new Integer[]{3,5,7,4,8,0,2,1,6});  
      System.out.println(Arrays.toString(list.toArray()));                                  
            			        			                                                                                   
      boolean swapFlag = true;                                                               
      while(swapFlag) {                                                                       
        swapFlag = false;                                                                    
        for(int x=0;x 0) {                                     
            Integer temp = list.get(x);                                                       
            list.set( list.get(x+1), x);                                                      
            list.set( temp, (x+1));                                                         
            swapFlag = true;                                                                  
          }//end if                                                                                                                                                         
        }//end for                                                                                                                                                          
      }//end while                                                                                                                                                            
            			        			                                     
      System.out.println(Arrays.toString(list.toArray()));

    运行时,使用通用Java数组进行冒泡排序的输出为:

    [3, 5, 7, 4, 8, 0, 2, 1, 6]                                                              
    [0, 1, 2, 3, 4, 5, 6, 7, 8]

    4.2乘法表

    Java通用数组的一个基本示例性应用程序是创建一个简单的整数表(从1到10)。这需要二维整数数组。 创建乘法表后,将验证恒等式和可交换性的数学属性。 通用Java数组的这种用法的源代码为:

    Array multiplyTable = new Array(10,10).init(0);                    
      for(int x=0;x<multiplyTable.getDim(0);x++){                                            
        for(int y=0;y<multiplyTable.getDim(1);y++){                                            
          multiplyTable.set(x*y, x,y);		                                           
        }//end for                                                                                                                                                       
      }//end for                                                                                                                                                            
                                                                                		
      //check 1*n = n                                                                                                                                         
      for(int x=0;x<multiplyTable.getDim(0);x++){                                           
        if(multiplyTable.get(1,x) != x)                                                     
          throw new RuntimeException("Identity property doesn't hold!”);                     
        if(multiplyTable.get(x,1) != x)                                                    
          throw new RuntimeException("Identity property doesn't hold!”);                     
      }//end for   
                                                                          	 		        			                                                            
      //check m*n = n*m                                                                                                                                              
      for(int x=0;x<multiplyTable.getDim(0);x++){                                               
        for(int y=0;y<multiplyTable.getDim(1);y++){                                             
          if(multiplyTable.get(x,y) != multiplyTable.get(y,x) )                               
            throw new RuntimeException("Commutative property doesn't hold!");	                 
        }//end for                                                                                                                                                         
      }//end for

    没有输出,因为乘法的恒等式和交换数学属性是真实的,因此是有效的。 但这说明了二维通用数组的使用。 对于其他更高的尺寸,其他应用也是可能的。

    5.结论

    最初的问题证明了使用内置数组实体的参数化类型或通用数组的问题。 使用相同的代码片段,但替换通用数组Array.java,源代码为:

    class TestArray2 {                                                                                                                                                                                                                   
        public Array array = new Array(10);                                                                                                                                                                                              
      }//end class TestArray2

    编译时,没有报告的错误。 数据结构Array.java实现了原始问题的解决方案。

    Java中的类型参数化或泛型允许使用类型安全的类,但是在泛型类型参数化系统的设计中需要权衡取舍。 因此,Java中的泛型具有一些与内置Java数组实体有关的缺陷。 不幸的是,Java Collections Framework无法通过提供数组数据结构来解决该问题。

    解决方案在Java语言和通用类型参数化内。 只需将通用Array类设计为用Java编写的一流对象即可。 从表面上看,它似乎是现有Java实体(数组)的冗余副本。

    这不是复制; 设计Java Array类将创建一个通用的类型安全的数据结构,该结构可以替代内置Java数组实体。 折衷方案是在没有运算符重载的情况下,语法在数组访问和操作方面不太明确,但与在对象实例上调用方法一致。

    6.参考

    • [Aho 2007] Aho,Alfred V.,Lam,Monica S.,Sethi,Ravi和Ullman,Jeffrey D.编译器:原理,技术和工具,第二版。 皮尔逊教育公司(Pearson Education,Inc.),纽约,纽约,2007年,第381至382页。
    • [Goet 2019] Goetz,Brian。 “ Java理论与实践:泛型陷阱”,2005年1月25日。https ://www.ibm.com/developerworks/java/library/j-jtp01255/index.html,于2019年9月28日访问。

    7.下载源代码

    下载
    您可以在此处下载本文的完整源代码: 创建通用数组的问题

    翻译自: https://www.javacodegeeks.com/the-problem-with-creating-generic-arrays.html

    无法创建t的通用数组

    展开全文
  • numpy创建数组

    2018-04-02 10:03:41
    1、创建数组数组的创建方法有几种,最常见的就是使用array()函数,参数为单层或嵌套列表&gt;&gt;c = np.array([[1,2,3],[4,5,6]])&gt;&gt;carray([[1,2,3], [4,5,6]])除了列表,array()函数还可以...
  • 【填空题】若已有数组说明“char s[];”,则创建 20 个字符的数组的语句是s... (5.0分)【单选题】下列创建数组的语句中正确的是(3.0分)【单选题】下面哪个选项正确声明一个字符型数组(2.0分)【单选题】下面哪条语句定...
  • 【单选题】下列关于运算符优先级的描述中,错误的是 。【判断题】Java 语言中定义符号常量使用final关键字。( )【判断题】捕获异常时try语句后面通常跟有一个或多个catch()方法用来处理try块内生成的异常事件。( )...
  • 第三章 JavaScript 数组

    千次阅读 2020-04-30 15:56:03
    创建数组 数组的基本操作 二维数组的创建与遍历 【案例】二维数组转置 数组排序 数组栈方法 数组检索方法 数组转字符串 数组其他方法 【案例】猴子选大王 【案例】省份城市的三级联动 &&:习题+答案 链接:...
  • java数组练习题目

    2021-03-05 13:32:39
    java数组练习题目 1 一 填空题 1) 数组的元素通过 来访问,数组 Array 的长度为 。 2) 数组复制时,“=“将一个数组的 传递给另一个数组。 3) 没有显式引用变量的数组称为 数组。 4) JVM 将数组存储在 ( 堆或栈) 中...
  • Java数组练习题(带答案) PDF 下载

    千次阅读 2021-04-22 18:29:09
    一 填空题1)数组的元素通过 下标 来访问,数组Array的长度为 Array.length 。2)数组复制时,"="将一个数组的 引用 传递给另一个数组。3)JVM将数组存储在 栈 (堆或栈)中。4)数组的二分查找法运用的前提条件是数组已经...
  • 用New操作可以创建多维数组,new类型名T[下标表达式1][下表表达式2]...。数组的个数是除最左边一位外各位下表表达式的乘积。 如:float(*fp)[25][10]; fp=newfloat[10][25][10];//用new操作产生了一个指向25*10的...
  • 下列情况可以使用数组: 1,在大量实际含义相同或者相近的数据需要存储在程序中 2,需要大量的命名 3.大量数据在程序的各个模块中如何传递 静态创建 :其内部的数据就已经有了初始值 语法: 数据类型[] 数组名={数据...
  • Java-数组试题

    2022-01-23 22:50:19
    1. 下列关于数组的说法正确的是:(A) A. 在Java中数组的长度是可变的 B. 数组中存储的数据的类型是相同的 C. 数组在进行扩容操作的时候源数组的地址不发生改变 D. int[] arr = new int[3]; arr = new int[10];是...
  • 关于Python的元组类型,以下选项中描述错误的是:(?)使用弯曲正应力公式必须满足的条件有()。A:产生纯弯曲的梁B:定义惯性矩I所依托的轴与弯矩M矢量的方向平行C:荷载作用面同时又是梁的纵向对称面的梁D:实体型截面梁E:...
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么?二、使用步骤1....示例:pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。 二、
  • Java中的集合类包括ArrayList、LinkedList、HashMap等,下列关于集合类描述错误的是(C) A.ArrayList和LinkedList均实现了List接口 B.ArrayList的访问速度比LinkedList快 C.随机添加和删除元素时,ArrayList的表现...
  • 依据现有数据创建数组方式包括(a)通过array()函数进行创建;(b)通过asarray()函数进行创建;(c)通过fromfunction()函数进行创建。具体内容如下 (a)通过array()函数进行创建。 array(object, dtype=None, ...
  •  shape:通过元组的形式返回数组每一维度元素的个数。  dtype:返回数组的元素类型   ndim属性  给出数组的维数,或数组轴的个数:     size属性  给出数组元素的总元素个数:     itemsize...
  • 下列代码的输出结果是?()publicclassTest{publicstaticvoidmain(String[]args){intsize=10;int[]array=newint[size];size=25;Sys...明天就要考试了 求大神 做下面的Java题一、选择题1.下列代码的输出结果是?( )...
  • 这是最常见的数组类型,绝大多数编程语言都有数字索引数组PHP 数字索引数组一般表示数组元素在数组中的位置,它由数字组成,下标从 0 开始,数字索引数组默认索引值就是从数字 0 开始的,不需要特别指定,PHP 会自动...
  • C语言初阶作业题-数组

    千次阅读 2020-11-19 15:30:27
    1.关于一维数组初始化,下面哪个定义是错误的?( ) A.int arr[10] = {1,2,3,4,5,6}; B.int arr[] = {1,2,3,4,5,6}; C.int arr[] = (1,2,3,4,5,6); D.int arr[10] = {0}; 答案解析: A:正确,10个int的一段连续...
  • java数组练习题

    2020-04-03 11:05:41
    下列数组声明的语法格式不正确的是() A. int[ ] array;   B. int array[ ];   C. char[ ];   D. String[ ] strArray; C 已知一个长度为10的数组b,数组b的第三个元素表示为? A. b[3]   B. b(3)   C. b[2]...
  • Java_数组练习答案.doc

    2021-04-17 07:55:18
    Java_数组练习答案填空题数组的元素通过 下标 来访问,数组Array的长度为 Array.length。数组复制时,“=”将一个数组的 引用 传递给另一个数组。没有显式引用变量的数组称为 匿名 数组。JVM将数组存储在 堆 (堆或栈...
  • 概念: 索引数组 ==== >>>$arr = []; 关联数组 ====>>> $arr = [ 'orange'=>1,'apple'=>'good' ]; 1.在tp5之前的tp3.2,我们知道索引数组转关联数组,是直接可以转成功的,因为php是弱语言类型....
  • Python创建类似Matlab中的cell数组

    千次阅读 2020-07-27 10:26:19
    到时候使用的时候也要写 poseSmile_cell[i,0] poseSmile_cell[i+1,0] 这个样子,而不是类似matlab那样直接写成了poseSmile_cell[i], poseSmile_cell[i+1]这个样子, 这是我自己犯的愚蠢的错误!!!
  • Java 数组转 List 的 4 种方式

    千次阅读 2021-03-23 10:52:40
    目录前言【一】最常见方式(未必最佳)【二】数组转为List后,支持增删改查的方式【三】通过集合工具类Collections.addAll()方法(最高效)问题解答总结 前言 本文介绍Java中数组转为List三种情况的优劣对比,以及...
  • 每日10道JAVA题(20180621)

    千次阅读 2018-06-21 10:33:29
    10.下面哪个语句是创建数组的正确语句?( ) A.float f[][] = new float[6][6]; B.float []f[] = new float[6][6]; C.float f[][] = new float[][6]; D.float [][]f = new float[6][6]; E.float [][]f = new float[6]...
  • 【学习C++】创建动态二维数组

    万次阅读 多人点赞 2018-01-19 22:09:12
    3、使用vector创建一个二维数组 [cpp]   view plain   copy int  n=10,m=2;  //   vector int > > swp(n); //表示二维数组有 4行 后面两个> >中间的空格...
  • 1. 关于一维数组初始化,下面哪个定义是错误的?( ) A.int arr[10] = {1,2,3,4,5,6}; B.int arr[] = {1,2,3,4,5,6}; C.int arr[] = (1,2,3,4,5,6); D.int arr[10] = {0}; 答案解析: A:正确,10个int的...
  • JavaScript定型数组详解

    千次阅读 2021-03-21 19:17:14
    定型数组创建 定型数组是另一种形式的ArrayBuffer视图。虽然概念上与DataView接近,但定型数组的区别在于,它特定于一种ElementType且遵循系统原生的字节序。...创建定型数组方式包括读取已有的缓冲、使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,768
精华内容 23,907
关键字:

下列创建数组的方式错误的是