精华内容
下载资源
问答
  • 一个程序,定义一个数组,用for语句输入10个实数存入这个数组,然后按逆序重新存放后再输出 int[] shuzu = new int[10]; string str = textBox1.Text; string[] ST = str.Split('\n'); for (i...

                编一个程序,定义一个数组,用for语句输入10个实数存入这个数组,然后按逆序重新存放后再输出

                int[] shuzu = new int[10];
                string str = textBox1.Text;
                string[] ST = str.Split('\n');
                for (int i = 0; i < ST.Length; i++)
                {
                    shuzu[i] = Convert.ToInt32(ST[i]);
                }
                for (int j = shuzu.Length; j > 0; j--)
                {
                    textBox2.Text += shuzu[j - 1] + "\r\n";
                }

    展开全文
  • 使用typedef语句定义数组类型

    千次阅读 2016-11-11 14:57:03
    1. 一维数组类型的定义格式 typedef []; 例如: (1) typedef int vector...第一条语句定义一个元素类型为int,含有10个元素的数组类型vector,若不使用typedef保留字,则就变成了数组定义,它只定义了一个元素类
    1. 一维数组类型的定义格式
    typedef <元素类型关键字><数组类型名>[<常量表达式>];
    例如:
    (1) typedef int vector[10];
    (2) typedef char strings[80];
    (3) typedef short int array[N];
    第一条语句定义了一个元素类型为int,含有10个元素的数组类型vector,若不使用typedef保留字,则就变成了数组定义,它只定义了一个元素类型为int、含有10个元素的数组vector。这两种定义有着本质的区别,若定义的是数组vector,系统将为它分配有保存10个整数的存储单元,共40个字节的存储空间;若定义的是数组类型vector,系统只是把该类型的有关信息登记下来,待以后利用该类型定义对象时使用,具体地说,就是把vector的元素类型int,类型长度10,类型名vec等登记下来,待以后定义vector类型的对象时使用。
    第二条语句定义了一个元素类型为char,含有80个元素的数组类型strings,以后可以直接使用strings类型定义数组对象,每个数组对象的元素为char型,数组长度(即元素个数)为80。
    第三条语句定义了一个元素类型为short int的含有N个元素(N为已定义的符号常量)的数组类型array,以后利用它可以直接定义该类型的对象,它是一个含有N个短整型元素的数组。
    下面是利用上述类型定义对象的一些例子。
    (1) vector v1,v2;
    (2) strings s1,s2="define type";
    (3) array a={25,36,19,48,44,50};  //假定常量N≥6
    第一条语句定义了vector类型的两个对象v1和v2,每个对象都是vector类型的一个数组,每个数组由10个整型元素所组成。
    第二条语句定义了strings类型的三个对象s1,s2和s3,并且对s3进行了初始化,每个对象都是含有80个字符空间的数组。
    第三条语句定义了一个array类型的对象a,它是一个含有N个短整型元素的数组,该语句同时对数组a进行了初始化,使得a[0]~a[5]的元素值依次为25,36,19,48,44和50。
    2. 二维数组类型的定义格式
    typedef <元素类型关键字><数组类型名>[<常量表达式1>][<常量表达式2>];
    例如:
    (1) typedef int matrix[5][5];
    (2) typedef char nameTable[10][NN];
    (3) typedef double DD[M+1][N+1];
    第一条语句定义了含有5行5列共25个int型元素的数组类型matrix
    第二条语句定义了10行NN列共10*NN个char型元素的数组类型nameTable
    第三条语句定义了含有M+1行N+1列共(M+1)*(N+1)个double类型元素的数组类型DD。
    利用这三个二维数组类型可以直接定义出相应的二维数组。如:
    (1) matrix mx={{0}};
    (2) nameTable nt={""};  //或使用等同的{{'\0'}}初始化
    (3) DD dd={{0.0}};
    第一条语句定义了二维整型数组类型matrix的一个对象mx,该对象是一个5*5的二维整型数组,每个元素均被初始化为0
    第二条语句定义了二维字符数组类型nameTable 的一个二维字符数组nt,该数组中的每个元素均被初始化为空字符
    第三条语句定义了二维双精度数组类型DD的一个数组dd,它的每个元素均被初始化为0.0。
    在typedef语句中,<元素类型关键字>可以是C++语言中预定义的任何一种数据类型,也可以是用户在前面已定义的任何一种数据类型,所以通过该语句定义的类型同样可以用在其后的typedef语句中。如:
    (1) typedef vector vectorSet[20];
    (2) vectorSet vs;
    第一条语句定义了元素类型为vector,元素个数为20的一个数组类型vectorSet
    第二条语句定义了数据类型为vectorSet的一个对象vs,该对象包含有20个类型为vector的元素,每个元素又包含有10个int类型的元素,所以整个数组共包含有20行10列共200个整数元素,它等同于对vs的如下定义:
    int vs[20][10];
    利用typedef语句同样可以定义更高维的数组类型,这里就不进行讨论了。
    3. 对已有类型定义别名
    利用typedef语句不仅能够定义数组类型,而且能够对已有类型定义出另一个类型名,以此作为原类型的一个别名。如:
    (1) typedef int inData;
    (2) typedef char chData;
    (3) typedef char* chPointer;
    第一条语句对int类型定义了一个别名inData
    第二条语句对char类型定义了一个别名chData
    第三条语句对char*类型(它是字符指针类型)定义了一个别名chPointer。
    以后使用inData,chData和chPointer就如同分别使用int,char和char*一样,定义出相应的对象。如:
    (1) inData x,y;
    (2) inData a[5]={1,2,3,4,5};
    (3) chData b1,b2='a';
    (4) chData c[10]="char data";
    (5) chPointer p=0;
    第一条语句定义了inData(即int)型的两个变量x和y
    第二条语句定义了元素类型为int的一维数组a[5]并进行了初始化
    第三条语句定义了chData(即char)型的两个变量b1和b2,并把b2初始化为’a’
    第四条语句定义了一个字符数组c[10]并初始化为”char data”
    第五条语句定义了一个字符指针变量p,并初始化为0(即NULL)。
    展开全文
  • fortran 数组定义语句

    万次阅读 2013-01-24 10:22:09
    •该定义形式通过类型说明来显式声明数组的数据类型,并通过下标下界和下标上界来规定数组中某维的范围。下标下界和下标上界共同组成了维说明符。当维说明符省略下标下界时,默认所在维的下标从1开始。如下代码都...

    9.1.1 定义形式一


    •第一种数组定义形式的语法格式如下所示。
    •类型说明[::] 数组名([下标下界:]下标上界[,…])[,…]
    •该定义形式通过类型说明来显式声明数组的数据类型,并通过下标下界和下标上界来规定数组中某一维的范围。下标下界和下标上界共同组成了维说明符。当维说明符省略下标下界时,默认所在维的下标从1开始。如下代码都是合法的数组定义。
    •REAL :: A(1:2,2:4)
    •INTEGER B(10)

     

    9.1.2 定义形式二


    •第二种数组定义形式的语法格式如下所示。
    •DIMENSION [::] 数组名([下标下界:]下标上界[,…])[,…]
    •[类型说明[::] 数组名[,…]]
    •该定义形式通过DIMENSION语句来进行数组的定义,通过下标下界和下标上界来规定数组中某一维的范围。在第二行通过类型说明来显式声明数组的数据类型。当省略类型说明时,采用默认的“I-N”规则来对数组的数据类型进行定义。如下代码合法的对数组进行了定义。
    •DIMENSION :: A(10), B(2:11)
    •INTEGER :: A

     

    9.1.3 定义形式三


    •第三种数组定义形式的语法格式如下所示。
    •DIMENSION([下标下界:]下标上界[,…]) [::] 数组名[,…]
    •[类型说明[::] 数组名[,…]]
    •该定义形式通过DIMENSION语句直接说明了数组的维数和维的范围。这种形式定义的数组全部具有相同的维数和大小。如下代码表示了如何采用上述形式进行数组的定义。
    •DIMENSION(10, 4:10) :: A, B, N
    •INTEGER :: A
    •REAL(8) :: N

     

    9.1.4 定义形式四

     

    •第四种数组定义形式的语法格式如下所示。
    •[类型说明,]DIMENSION [::] 数组名([下标下界:]下标上界[,…])[,…]
    •[类型说明,]DIMENSION([下标下界:]下标上界[,…]) [::] 数组名[,…]
    •该定义形式可以说是前三种定义形式的综合形式。通过在DIMENSION语句前引入类型说明来显式的说明数组的数据类型。下列代码演示了此种形式的数组定义。
    •REAL, DIMENSION :: I(10), M(10,5)
    •INTEGER, DIMENSION(10) :: A, C

     

    9.3.2 数组存储结构的应用


    •目前的计算机硬件体系结构决定了在读取大批量数据时,如果这一批数据都位于临近的内存中时,读取操作会执行得较快。在编写程序时,如果想要提高执行效率,就应该对数据在计算中的保存方式和读取方式有一定的了解。只有了解了数据在计算内的存储结构,才能在编写程序的时候做到有的放矢。这样编写出来的程序在数据的存取效率上才能较高。
    •需要注意的是,尽管Fortran中的数组是按“列元素优先”的规则进行存储的,但是C语言中的数组则是按照“行元素优先”的原则进行存储,并且C语言中数组的下标下界固定是从0开始的。在编写相关的程序时,应该注意到这一差别。Fortran语言中,使用DO循环进行高效率数组操作的代码写法可能在C语言中恰恰是最低效的。比如下面的程序段在Fortran中能够得到较好的执行效率:
    •DO J = 1, 5
    •DO I = 1,3
    •Sum = Sum+ A(I, J)
    •ENDDO

     

    9.4.7 延迟形状数组


    •延迟形状(Deferred-shape)数组是Fortran 90/95标准中才开始引入的特殊类型数组,这种类型的数组在声明时并不制定数组的维界,具体的维界需要在程序执行过程中才能确定。延迟形状数组的典型代表就是数组指针和可分配数组。
    •声明延迟形状数组时,数组的秩由冒号“:”来确定,但每一维的长度是未知的。数组的维界和形状在程序执行过程中给延迟形状数组分配存储空间之后才能决定。可分配数组可以通过ALLOCATABLE语句、DIMENSION语句、TARGET语句或在类型声明中使用ALLOCATABLE属性来进行说明;而数组指针则由POINT语句或在类型声明中使用POINTER属性来进行说明。数组指针的边界和形状通过指针赋值语句指向目标之后进行确定,或者通过ALLOCATE语句直接进行指针的空间分配;而可分配数组的边界和形状则只能通过ALLOCATABEL语句来进行指定。

    动态数组

    为了更有效的利用计算机中的内存,Fortran 90/95标准中正是引入了可分配数组的概念。通过ALLOCATE语句可以动态的创建可分配数组,使内存和对象可以在程序开始运行之后才建立起相互联系。

     

    9.6 数组赋值


    •当数组配置好内存空间后,可以通过赋值语句或是数组构造器为数组中的元素进行赋值。Fortran语言中,数组的赋值可以通过赋值语句、DATA语句和数组构造器这三种手段来进行。

     

    9.6.2 数组构造器


    •数组构造器是由括号和斜线对之间的一系列数值组成,其一般形式为:
    •数组名= (/取值列表/)
    •其中,取值列表可以是标量,隐式DO循环或者任意秩的数组。取值列表中所有数值的类型都应该相同,数值之间以逗号分隔。如果取值列表中出现了数组,则它的值是按“列元素优先”的规则来赋给目标数组变量。数组构造器的标识“(/”和“/)”在书写时要注意,括弧和撇号之间不能有空格。下面来看一些实例。
    •MN = (/1, 3, 5, 7, 9/) ! 标量表示
    •AB = (/B(2,1:5),B(3:7,7:9)/)! 数组表示
    •CC = (/(I, I=1,4)/)! 隐DO循环
    •DE = (/10,A(2:7),(I,I=1,4),7/)! 混合表示

     

     

    展开全文
  • Java中数组定义与使用()

    万次阅读 多人点赞 2018-09-01 00:05:13
    如果说现在要求你定义100整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ... i100; 但是这儿时候如果按照此类方式定义就会非常麻烦,...

    数组的基本概念

    如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下:

    int i1, i2, i3, ... i100;
    

    但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你要编写System.out.println()语句100次。

    其实所谓的数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型,那么既然是引用数据类型,这里面实际又会牵扯到内存分配,而数组的定义语法有如下两类。

    • 数组动态初始化:
      • 声明并开辟数组:
        • 数据类型 [] 数组名称 = new 数据类型[长度];
        • 数据类型 [] 数组名称 = new 数据类型[长度];
      • 分布进行数组空间开辟(实例化)
        | Tables | Are |
        | ------------- |:-------------?
        | 声明数组: | 数组类型 数组名称[] = null; | | | 数组类型 [] 数组名称 =null; | | 开辟数组空间: | 数组名称 =new` 数组类型[长度]; |

    那么当数组开辟空间之后,就可以采用如下的方式的操作:

    • 数组的访问通过索引完成,即:“数组名称[索引]”,但是需要注意的是,数组的索引从0开始,所以索引的范围就是0 ~ 数组长度-1,例如开辟了3个空间的数组,所以可以使用的索引是:0,1,2,如果此时访问的时候超过了数组的索引范围,会产生java.lang.ArrayIndexOutOfBoundsException 异常信息;
    • 当我们数组采用动态初始化开辟空间后,数组里面的每一个元素都是该数组对应数据类型的默认值;
    • 数组本身是一个有序的集合操作,所以对于数组的内容操作往往会采用循环的模式完成,数组是一个有限的数据集合,所以应该使用 for 循环。
    • Java 中提供有一种动态取得数组长度的方式:数组名称.length;

    范例: 定义一个int型数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    

    数组本身除了声明并开辟空间之外还有另外一种开辟模式。

    范例: 采用分步的模式开辟数组空间

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null; 
    		data = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    

    但是千万要记住,数组属于引用数据类型,所以在数组使用之前一定要开辟控件(实例化),如果使用了没有开辟空间的数组,则一定会出现 NullPointerException 异常信息:

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null; 
    		System.out.println(data[x]);
    	}
    }
    

    这一原则和之前讲解的对象是完全相同的。

    数组在开发之中一定会使用,但是像上面的操作很少。在以后的实际开发之中,会更多的使用数组概念,而直接使用,99%情况下都只是做一个 for 循环输出。

    数组引用传递

    既然数组属于引用数据类型,那么也一定可以发生引用传递。在这之前首先来研究一下数组的空间开辟。

    范例: 观察一道程序

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    	}
    }
    

    新建数组变量

    那么既然说到了引用数据类型了,就一定可以发生引用传递,而现在的引用传递的本质也一定是:同一块堆内存空间可以被不同的栈内存所指向。

    范例: 定义一个程序

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		int temp[] = null; //声明对象
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    		temp = data;  //int temp[] = data;
    		temp[0] = 99;
    		for(int i = 0; i < temp.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }
    

    这里写图片描述

    引用传递分析都是一个套路。同一块堆内存被不同的栈内存所指向。

    数组静态初始化

    在之前所进行的数组定义都有一个明显特点:数组先开辟内存空间,而后再使用索引进行内容的设置,实际上这种做法都叫做动态初始化,而如果希望数组在定义的时候可以同时出现设置内容,那么就可以采用静态初始化完成。

    数组的静态初始化一共分为以下两种类型:

    Tables Are
    简化格式: 数据类型 数组名称 = {值, 值,…}
    完整格式: 数据类型 数组名称 = new 数据类型[] {值, 值,…}

    范例: 采用静态初始化定义数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = {1, 2, 4, 545, 11, 32, 13131, 4444};
    		for(int i = 0; i < data.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }
    

    在开发之中,对于静态数组的初始化强烈建议使用完整语法模式,这样可以轻松地使用匿名数组这一概念。

    public class ArrayDemo {
    	public static void main(String args[]) {
    		System.out.println(new int[] {1, 2, 4, 545, 11, 32, 13131, 4444}.length);
    	}
    }
    

    以后使用静态方式定义数组的时候一定要写上完整格式。

    数组最大的缺陷:长度固定。

    二维数组

    在之前所使用的数组发现只需要一个索引就可以进行访问,那么这样的数组实际上非常像一个数据行的概念。

    索引 0 1 2 3 4 5 6 7 8
    内容 12 23 44 56 90 445 49 99 1010

    现在痛过一个索引就可以取得唯一的一个记录。所以这样的数组可以简单理解为一维数组,而二维数组本质上指的是行列集合,也如果要确定某一个数据需要行索引和列索引来进行定位。

    索引 0 1 2 3 4 5 6 7 8
    0 12 23 44 56 90 445 49 99 1010
    1 2 3 41 56 9 45 49 99 10

    如果要想确定一个数据则数据使用的结构是“数组名称[行索引][列索引]”,所以这样的结构就是一个表的结构。

    那么对二维数组的定义有两种声明形式:

    • 数组的动态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数];
    • 数组的静态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数]{{值, 值,…}, {值, 值,…},…};

    数组的数组就是二维数组。

    范例: 定义一个二维数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		//此时的数组并不是一个等列数组
    		int data[][] = new int[][] {
    			{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
    		//如果在进行输出的时候一定要使用双重循环,
    		//外部的循环控制输出的行数,而内部的循环控制输出列数
    		for(int i = 0; i < data.length; i++) {
    			for(int j = 0; j < data[i].length; j++) {
    				System.out.print("data[" + i + "][" + j + "]=" + data[i][j] + "、");
    			}
    			System.out.println();
    		}
    	}
    }
    

    由于输出麻烦,所以可以忽略了,在进行开发之中,出现二位数组的几率并不高。

    展开全文
  • Java语言,定义数组并且实现键盘输入一个数组,怎么实现的,啊?
  • 数组的嵌套是怎么定义的?为什么dim语句里插入一个dim语句就报错了,那么vb编程控件中用的方法是什么啊?
  • 数组嵌套头数组的类型定义可以和之后的每个数组都不同么?单独数组的类型的定义用什么语句?怎么单独定义头数组类型?
  • 你好,请教一下: typedef struct {ElemType data; int cur; }compoent,SLinkList{MAXSIZE}; 代码的作用是什么?
  • 定义一个数组,进行数组中元素的倒置 Java选择排序法、冒泡排序法、JDK排序法 一、利用for循环遍历互换元素位置 //利用for循环遍历互换元素位置 public class TestArrayDump { public static void main(String[] ...
  • python定义数组-python数组定义

    千次阅读 2020-11-11 14:18:09
    转自:https://blog.csdn.net/minsenwu/article/details/7872679Python中没有数组的数据结构,但列表很像数组,如:a=[0,1,2],这时a[0]=0, a[1]=1, a[[2]=2,但引出一个问题,即如果数组a想定义为0到999怎么办?...
  • 【C#】编一个程序,定义一个有10个元素的一维数组a1 题目描述:编一个程序,定义一个有10个元素的一维数组a2 源码详解3 实现效果 1 题目描述:编一个程序,定义一个有10个元素的一维数组a 题目描述:编一个程序,...
  • 其中SPLIT_TYPE为自定义的字符串型数组/集合类型名称  
  • typedef 定义数组

    千次阅读 2017-04-13 19:55:04
    使用typedef语句定义数组类型  1. 维数组类型的定义格式  typedef [];  例如:  (1) typedef int vector[10];  (2) typedef char strings[80];  (3) typedef short int array[N];  第条语句定义了...
  • //定义一个数组;100个元素;   { int a[100],b; for (b = 0;b  {  a[b] = b;  } for (b = 0; b  {  CCLOG("%d",a[b]);  }   }
  • (C++)动态数组及二维数组定义方法 动态数组 动态二维数组 动态数组:是指在声明时没有确定数组大小的数组,即忽略圆括号中的下标;当要用它时,可随时用ReDim语句重新指出数组的大小。使用动态数组的优点是...
  • C语言数组定义

    千次阅读 2016-11-03 22:21:41
    一维数组定义方式  在C语言中使用数组必须先进行定义。一维数组定义方式为:  类型说明符 数组名 [常量表达式];  其中,类型说明符是任一种基本数据类型或构造数据类型...对于同一个数组,其所有元素的数据类
  • (一)分析以下需求,并用代码...4.定义一个方法传入一个int类型数组,输出这个数组中只出现一次的数字及个数 public class 类名 { public static void main(String[] args) { //键盘录入10个整数存入数组中 S...
  • 数组嵌套和二维数组有什么不同,为什么二维数组可以使用dim语句,但是子数组嵌套就不能定义?子数组嵌套有redim语句对应的么?
  • scala定义数组

    千次阅读 2019-02-14 09:29:44
    数组定义 定义有固定元素的数组 val arr = Array(1,2,3,4) 定义定长数组 val arr = new Array[Int](10) //声明定长数组要注意啊:1.关键字new。2.声明数据类型。3.声明长度。 变长数组(ArrayBuffer) ...
  • 定义一个数组来存储10个学生的成绩,输出60分以上的分数 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, ...
  • 数组定义方式

    万次阅读 2016-08-11 20:14:26
    数组定义方式 在C语言中使用数组必须先进行定义数组定义方式为:  类型说明符 数组名 [常量表达式]; 其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义数组标识符。方括号...
  • 定义一个数组来存储10个学生的成绩,计算并输出学生的平均成绩。 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-...
  • vb 如何定义一个未知大小一维数组? 2012-12-09 10:33 酷依航 | 分类:VB | 浏览1941次我是这样定义 dim a(100) as string,但是经常性出现下标越界,又不想定义的范围太大,就想问下可不可以定义一个自适应的一维...
  • redim语句修改数组的嵌套定义的时候,前面的扩充了容量会影响后面的数组么?使用redim语句会造成内存的重新分配么?
  • 一、定义数组的方法: 1. var arr=[]; 2: var arr=new arrary(); 3: //split() 方法用于把一个字符串分割成字符串数组。 var s=("1,2,3").split(','); 结果:["1","2","3"] 二、获得数组内元素的个数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 459,763
精华内容 183,905
关键字:

一个语句只能定义一个数组