精华内容
下载资源
问答
  • 一维数组声明语句错误
    千次阅读
    2021-02-18 20:50:59

    所谓数组的指针,即指数组的起始地址,数组元素的指针是指数组元素的地址。
    1.一维数组的地址

    在C语言中,数组名是个不占内存的地址常量,它代表整个数组的存储首地址。
    一维数组元素a[i]的地址可以写成表达式&a[i]或a+i,&a[i]是用下标形式表示的地址,a+i是用指针形式表示的地址,二者结果相同。元素a[i]的地址等于数组首地址向后偏移若干字节,偏移的字节数等于a[i]与首地址之间间隔元素的数目乘以一个元素所占存储单元的字节数。
    那么,*(a+i)表示a+i地址中的内容,就是a[i]的值,这就是通过地址常量数组名引用一维数组。
    2.一维数组指针的定义
    定义一个指向数组的指针变量的方法,与定义指向简单变量的指针变量的方法相同。例如:
    int a[10]={1,2,3,4,5,6,7,8,9,10}; /定义a为包含10个整型数据的数组/
    int *p; /定义p为指向整型变量的指针变量/
    定义了一个整型数组a和一个指向整型变量的指针变量p。这时指针变量p并没有指向任何对象,只有当数组a的起始地址赋值给指针变量p时,指针p才表示指向数组a,称指针p为指向数组a的指针。指向过程可以通过下面两种方法实现:
    (1)用数组名做首地址。形式为:
    p=a;
    表示将数组a的起始地址赋值给指针p,而不是将数组a的所有元素赋值给指针p。

    数组a的起始地址赋值给指针,也可以在指针定义的同时进行。例如:
    int a[30];
    int *p=a; /*指针的初始化*/
    在定义指针变量p的同时,将数组a的起始地址赋值给指针变量p,而不是赋值给指针p指向的变量。
    (2)用数组第0个元素地址做首地址。形式为:
    p=&a[0];
    数组名a与数组元素a[0]的地址相同,都是数组的起始地址,因此也可以将&a[0]赋值给指针p。
    3.利用指针引用一维数组元素
    如果指针变量p指向数组a的第一个元素(即第0号元素),即p=a,则
    (1)p+i和a+i就是数组元素a[i]的地址,即它们指向数组a的第i+1个元素,即i号元素。
    (2)*(p+i)或*(a+i)就是p+i或a+i所指向的数组元素,即a[i];
    (3)指向数组元素的指针变量也可以带下标,如p[i]与*(p+i)等价。所以,a[i]、*(a+i)、p[i]、*(p+i)四种表示方法全部等价。
    (4)指针变量可以通过本身值的改变来实现对不同地址的操作,既可以使用p++。因为数组名表示数组的起始地址,所以数组名也可以称为指针,但是数组名是一个特殊的指针,它是指针常量,其值在程序整个运行过程中都不能被改变,只代表数组的起始地址。所以,如果a是一个数组名,它是一个指针常量,像“a++”或者“a=a+2”这些语句都是错误的。

    综上所述,把指针与一维数组的联系归纳为下表(针对int a[10],*p=a)

    表达式含义
    &a[i],a+i,p+i引用数组元素a[i]的地址
    a[i]、*(a+i)、p[i]、*(p+i)引用数组元素a[i]
    p++、p=p+1表示p指向下一数组元素,即a[1]
    *p++、*(p++)先取p所指向的存储单元的内容*p,再使p指向下一个存储单元
    *++p、*(++p)先使指针p指向下一个存储单元,然后取改变后的指针p所指向的存储单元内容*p
    (*p)++取指针p所指的存储单元内容作为该表达式的结果值,然后使p所指对象的值加1,即*p=*p+1;指针p的内容不变

    例:
    从键盘输入10个数,利用指针法输入、输出数组。

    #include<stdio.h>
    void main()
    {
    	int	i,*p,a[10];
    	p=a;
    	for(i=0;i<10;i++)
    		scanf("%d",p++);
    	printf("\n");
    	p=a;
    	for(i=0;i<10;i++)
    		printf("a[%d]=%d\n",i,*p++);
    }
    

    4.指向二维数组的指针

    定义一个二维数组:
    int a[3][4];

    二维数组a的各种表示形式及其含义

    表示形式含义
    a数组a的起始地址,也是数组第0行的首地址
    a+i、&a[i]第i行的起始地址
    *(a+i)、a[i]第i行第0列元素的起始地址
    *(a+i)+j、a[i]+j,&a[i][j]第i行第j列元素的起始地址
    *( *(a+i)+j)、*(a[i]+j)、a[i] [j]第i行第j列元素的值

    注意:基于一维数组有a[0]和*(a+0)等价,a[1]和*(a+1)等价,a[2]和*(a+2)等价,因此第i行第j列地址也可以表示为*(a+i)+j,即&a[i][j]=a[i]+j=*(a+i)+j。
    利用指向二维数组元素的指针变量,可以完成二维数组数据的操作处理。
    (1)定义与二维数组相同类型的指针变量;
    (2)在指针变量与要处理的数组元素之间建立关联;
    (3)使用指针的运算就可以访问到任何一个数组元素,完成操作处理。

    例1:
    利用指针变量及指针变量的自增运算,输出二维数组所有元素的值。

    #include“stdio.h”
    void main()
    {
    		int 	a[3][3]={{0,1,2},{3,4,5},{6,7,8}};
    		int	*p,*q;
    		p=a[0];
    		q=&a[2][2];
    		while(p<=q)
    			{ 
    					printf("%d   ",*p);
    					p++;
    		    }
    		  printf("\n");
    }
    

    例2:

    利用数组指针求给定nxn矩阵的转置矩阵,并计算对角线元素之和。
    分析:

    数组指针是指向数组的指针变量,也叫行指针变量。

    如有数组指针变量p和二维数组a[3][4],p=a或p=&a[0]说明p指向了数组a的第0行,p+1指向了数组的第一行,p+i指向了数组的第i行,也说明了p+i等价于&a[i]。
    *(p+i)等价于a[i]或*(a+i),*((p+i)+j)等价于*(a[i]+j)、*((a+i)+j)、a[i][j]。

    要将一个矩阵转置,只要将这一个矩阵的上三角矩阵与其关于主对角线对称的下三角阵交换即可,也就是将a[i][j]和a[j][i]交换。

    源程序:

    #include<stdio.h>
    #define N 4
    void mian()
    {
    	int a[N][N],(*p)[N];
    	int i,jjt,s=0;
    	printf("input a:\");
    	for(i=0;i<N;i++)
    	{ 
    			printf("input the %dth row:\n",i+1);
    			for(j=0;j<N;j++)
    					scanf("%d",&a[i][j]);
    	}
    	p=a;
    	for(i=0;i<N;i++)
    	{
    		s+=*(*(p+i)+i);				/*累加对角线上的元素*/
    		for(j=i+1;j<N;j++)			/*交换a[i][j]和a[j][i]*/
    			{
    				t=*(*(p+i)+j);
    				*(*(p+i)+j)=*(*(p+j)+i);
    				*(*(p+j)+i)=t;
    			}
    	}
    	for(i=0;i<N;i++)						/*输出转置后的矩阵*/
    	{
    		for(j=0;j<N;j++)
    			printf("%4d",*(*(p+i)+j));
    		printf("\n");
    	}
    	printf("s=%d\n",s)
    }
    
    更多相关内容
  • 声明一维数组时常见错误

    千次阅读 2019-01-28 15:07:10
    /// 声明和初始化时易出现的错误 /// &lt;/summary&gt; /// &lt;param name="args"&gt;&lt;/param&gt; static void Main(string[] args) { int[] array...
    /// <summary>
            /// 声明和初始化时易出现的错误
            /// </summary>
            /// <param name="args"></param>
            static void Main(string[] args)
            {
                int[] array =new int[5]{0,1};
            }
    

    会出现这种错误信息

    原因是声明和初始化一维数组的语句是错误的,代码“int[5]”告诉编译器数组长度是5,但是只有给其中两个元素赋初始值

    声明数组

    static void Main(string[] args)
            {
                //声明数组并初始化
                int[] arry = new int[5] { 6, 1, 2, 3, 4 };
                int[] arr1 = new int[] { 0, 1, 2, 3, 4 };//省略数组长度
                int[] arr2 ={ 0, 1, 2, 3, 4 }; //省略 new 关键字
                Console.WriteLine("数组 array 的元素个数是{0}",arry.Length);
                Console.WriteLine("数组 array 的元素个数是{0}", arr1.Length);
                Console.WriteLine("数组 array 的元素个数是{0}", arr2.Length);
    

    可以通过 “数组名.Length” 的形式来获得数组的长度
    在这里插入图片描述

    展开全文
  • 在本篇文章里小编给大家整理了关于java一维数组及练习题的相关知识点和实例代码,有需要的朋友们跟着学习下。
  • 数组(Array)是在内存中连续存储的具有相同类型的组数据的集合。 数组组相同类型元素的集合。*这些元素在内存中依次连续挨着存放。 数组中,若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成...

    数组

    数组(Array)是在内存中连续存储的具有相同类型的一组数据的集合。
    数组是一组相同类型元素的集合。这些元素在内存中依次连续挨着存放。

    数组中,若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标
    在这里插入图片描述

    注意:
    1,数组的下标从0开始(包括0)连续计算。
    2,数组中的各元素的存储是有先后顺序的,它们在内存中按照这个先后顺序连续存放在一起。
    3,数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如,a[0]表示名字为a的数组中的第一个元素,a[1]代表数组a的第二个元素,以此类推。
    4,数组中的所有元素都具有相同类型。数组中的元素存储在一个连续性的内存块中,并通过索引来访问。最低的地址对应第一个元素,最高的地址对应最后一个元素。
    5,数组元素并非只能是基本数据类型,还可以是结构、枚举或类。

    一维数组

    一维数组的创建和初始化

    一维数组是最简单的数组,其逻辑结构是线性表。要使用一维数组,需经过定义、初始化和应用等过程。

    一维数组的定义

    在 C 中要声明一个数组,需要指定元素的类型和元素的数量,一维数组定义的语法规则为:
    类型说明符 数组名[常量表达式];
    例如:

    	char arr1[3];//数组类型为char,数组名为arr1,数组中一共有3个元素。
    	int arr2[5];
    	double arr3[8];
    	int arr4[3+7];
    

    在上面的例子中,定义了一个数组名为arr1的char类型数组,该数组中可以容纳3个char类型的元素。
    注意:数组的创建定义中,[ ]内要给一个常量(或者常量表达式)才可以,不能使用变量。

    一维数组的初始化

    数组的初始化是指,在创建数组的同时给数组的内容一些合理的初始值(初始化)。

    完全初始化

    定义数组时给所有元素赋初值,这叫“完全初始化”。

    	char arr1[3] = {'a','d','f'};
    	int arr2[5] = {1, 2, 3, 4, 5};
    	double arr3[2+3] = {1.0, 2.0, 3.0, 4.0, 5.0};
    	char arr4[5] = "abcde";
    

    注意:数组{ }中元素的个数不能大于数组声明时[ ]中常量的个数。如果定义的数组的长度比花括号中所提供的初值的个数少,也是语法错误,如int arr[2] = {1,2,3,4};,这样写是错误的。

    如果定义数组时就给数组中所有元素赋初值,那么就可以不指定数组的长度,因为此时元素的个数已经确定了。编程时我们经常都会使用这种写法,因为方便,既不会出问题,也不用自己计算有几个元素,系统会自动分配空间。例如:

    	int arr1[] = {1, 2, 3, 4, 5}; //相当于int arr1[5] = {1,2,3,4,5}; 
    	char arr2[] = "asdf";
    

    这种写法和上面的写法一样,只不过数组[ ]中的元素个数等于后面{ }的元素个数,编程时自动给数组分配内存。
    注意:省略[ ]中数字的写法只适用于在定义数组时就初始化时。如果定义数组时不初始化,那么省略数组长度就是语法错误。例如:int arr[];这种写法是错误的。编译器会提示你没有指定数组的长度。

    不完全初始化

    可以只给一部分元素赋值,这叫“不完全初始化”。
    如果在定义和初始化数组时,[ ]中的数字大于数组{ }中的元素个数,则后面还没初始化的元素值默认全为0。比如:

    int arr1[5] = {1, 2, 3};//只初始化了3个元素
    int arr2[5] ={0};
    

    上面的代码中arr1中的全部元素为:1,2,3,0,0;arr2中全部元素为:0,0,0,0,0。
    定义的数组 a 有 5 个元素,但花括号内只提供两个初值,这表示只给前面两个元素 a[0]、a[1] 、a[2]初始化,而后面三个元素都没有被初始化。不完全初始化时,没有被初始化的元素自动为 0。
    注意:“不完全初始化”和“完全不初始化”不一样。如果“完全不初始化”,即只定义“int a[5];”而不初始化,那么各个元素的值就不是0了,所有元素都是随机值,也称为:垃圾值。
    不可以写成int a[5]={};。这是完全不初始化,如果大括号中什么都不写,那就是极其严重的语法错误。
    大括号中最少要写一个数。比如int a[5]={0};,这是不完全初始化,这时就是给数组“清零”,此时数组中每个元素都是零。

    一维数组的使用

    我之前详细写了操作符的有关内容,感兴趣的朋友可以看这:C语言 操作符详解(一)C语言 操作符详解(二)

    对于数组的使用需要借助一个操作符:[ ],下标引用操作符。它其实就是数组访问的操作符。

    数组必须先定义,然后使用。C 语言规定,只能逐个引用数组元素,而不能一次引用整个数组。数组的元素只能一个一个的输出。数组元素的表示形式为:
    数组名[下标]

    注意:定义数组时用到的 “数组名[常量表达式]” 和引用数组元素时用到的 “数组名[下标]” 是有区别的,定义数组时的常量表达式表示的是数组的长度,而引用数组元素时的下标表示的是元素的编号。
    例如:

    int num = 0;
    int arr[5] = {1, 2};//定义长度为5的数组arr
    num = arr[0];//引用数组arr中下标为0的元素a[0]赋值给num
    

    一维数组的使用中,很多时候都需要借助for循环。

    一维数组的使用代码示例

    #include<stdio.h>
    int main()
    {
    	int arr[10] = {0};//数组的不完全初始化
    	//用sizeof操作符计算数组元素的个数
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	//对数组的内容复赋值,数组是使用下标来访问的,下标从0开始。
    	int i = 0;//index做下标
    	for(i = 0; i < 10; i++)
    	{
    		//将数组的10个元素全部赋值为0~9
    		arr[i] = i;
    	}
    	//输出打印数组的全部内容
    	for(i = 0; i < 10; i++)
    	{
    		printf("%3d",arr[i]);
    	}
    	printf("\n");
    	printf("数组中元素的个数为:%d\n",sz);
    	return 0;
    }
    

    输出结果为:

      0  1  2  3  4  5  6  7  8  9
    数组中元素的个数为:10
    请按任意键继续. . .
    

    注意:
    1,数组是使用下标来访问的,数组的下标是从0开始的。
    2,数组的使用要小心月结访问,比如:int arr[5];那么我们只能访问 arr[0]~arr[4] 之间的5个元素,其它元素都是非法的,如,arr[5]是非法的。
    3,数组的大小可以通过单目操作符 sizeof 计算得到。

    一维数组在内存中的存储

    代码示例

    #include<stdio.h>
    int main()
    {
    	int arr[8] = {0};
    	int i = 0;
    	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    	{
    		printf("&arr[%d] = %p\n",i, &arr[i]);
    	}
    	return 0;
    }
    

    输出结果:

    &arr[0] = 005EFC2C
    &arr[1] = 005EFC30
    &arr[2] = 005EFC34
    &arr[3] = 005EFC38
    &arr[4] = 005EFC3C
    &arr[5] = 005EFC40
    &arr[6] = 005EFC44
    &arr[7] = 005EFC48
    请按任意键继续. . .
    

    观察输出结果,从中可以看出,随着数组下标的增长,元素的地址也在有规律的递增。
    结论,数组在内存中是连续存放的。
    在这里插入图片描述

    二维数组

    二维数组与一维数组相似,但是用法上要比一维数组复杂一点。后面的编程中,二维数组用得很少,因为二维数组的本质就是一维数组,只不过形式上是二维的。能用二维数组解决的问题用一维数组也能解决。

    二维数组的创建和初始化

    二维数组通常可以用来表示数学上的行列矩阵。即用二维数组的第一维表示行,第二维表示列;生活中凡是能抽象为对象及对象的若干同类型属性的问题,一般用二维数组来描述。

    二维数组的定义

    二维数组的语法规则为:
    类型说明符 数组名[第一维大小][第二维大小];

    其中,第一、二维的大小一般均为常量表达式。
    二维数组中的元素个数 等于 第一维大小 乘 第二维大小
    示例:

    	char arr1[3][4];//表示3行4列的char类型数组arr1
    	int arr2[5][6];
    	double arr3[8][4];
    	int arr4[3+7][2+4];
    

    第一维大小 表示第一维下标的长度,第一维大小 表示第二维下标的长度。
    从矩阵方面来理解的话,第一维大小 表示 行 下标的长度,第一维大小 表示 列 下标的长度。

    注意:下面这些定义形式都是错误的:

    	int arr5[][3];//错误。编译器无法确定所需空间
        int arr6[2][];//错误。缺少列下标,编译器无法确定所需空间
    

    二维数组的初始化

    	int arr1[2][3] = {1, 2, 3, 4, 5, 6};
    	int arr2[3][4] = {{1, 2},{3, 4}};
    	int arr3[][5] = {{1, 2, 3},{4, 5}};//表示这是一个2行5列的int型数组arr3
    	char arr4[][5] = {"abct","dgf"};
    

    1, 分行给二维数组赋初值

    int arr[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};//3行4列
    

    2,将所有数据写在一个花括号内,按数组排列的顺序对各元素赋初值

    int arr[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};//表示3行4列的12个元素
    

    3,只对部分元素赋初值

    int arr[3][4] = {{1, 2, 3}, {5}, {9}};//不完全初始化,表示3行4列
    

    它的作用是对第一行的前两个元素赋值、第二行和第三行的第一个元素赋值。其余元素自动为 0。这个二维数组初始化后数组各元素为:

              1  2  3  0
              5  0  0  0
              9  0  0  0 
    

    4, 如果在定义数组时就对全部元素赋初值,即完全初始化,则第一维的长度可以不指定,但第二维的长度不能省。

    int arr[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    

    等价于:

    int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    

    系统会根据数据总数和第二维的长度算出第一维的长度。但这种省略的写法几乎不用,因为可读性差。
    但是如果 只指定第一维的长度,不指定第二维的长度, 这样会发生错误,二维数组不允许这样的初始化方式。

    5,二维数组“清零”,里面每一个元素都是零

     int a[3][4]={0};
    

    二维数组的使用

    二维数组的使用也是通过下标的方式。一维数组的使用中,“数组的元素只能一个一个输出”,二维数组也不例外。在一维数组中是用一个 for 循环进行输出,而二维数组元素的输出要使用两个 for 循环嵌套。

    代码示例

    #include<stdio.h>
    int main()
    {
    	int arr[3][4] = {{1,2,3},4,5,6,7,8,9,10,11};
    	int i = 0;//i为行循环变量,用来控制行
    	int j = 0;//j为列循环变量,用来控制列
    	for (i = 0; i < 3; i ++)
    	{
    		for(j = 0; j < 4; j ++)
    		{
    			printf("  %2d",arr[i][j]);
    		}
    		printf("\n");//每一行结束时,用来换行
    	}
    	return 0;
    }
    

    输出结果:

       1   2   3   0
       4   5   6   7
       8   9  10  11
    请按任意键继续. . .
    

    二维数组的打印输出中,有两个for循环,第一个for循环用来控制行,第二个for循环用来控制列。

    二维数组在内存中的存储

    二维数组在内存中是连续存储的,二维数组的底层是按一维数组存的。

    代码示例

    #include<stdio.h>
    int main()
    {
    	int arr[3][4];
    	int i,j;
    	for (i = 0; i < 3; i ++)
    	{
    		for (j = 0; j < 4; j ++)
    		{
    			printf("arr[%d][%d] = %p  ",i, j, &arr[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }
    

    输出结果:

    arr[0][0] = 007DF7EC  arr[0][1] = 007DF7F0  arr[0][2] = 007DF7F4  arr[0][3] = 007DF7F8
    arr[1][0] = 007DF7FC  arr[1][1] = 007DF800  arr[1][2] = 007DF804  arr[1][3] = 007DF808
    arr[2][0] = 007DF80C  arr[2][1] = 007DF810  arr[2][2] = 007DF814  arr[2][3] = 007DF818
    请按任意键继续. . .
    

    从代码的输出结果和下图中我们可以看出,二维数组的底层存储是按一维数组连续存储的。

    在这里插入图片描述

    展开全文
  • 数组与定义 ...数组声明 包括:数组名,数据类型,[] 二、为数组分配空间 必要,否则会出现错误 三、数组各元素的赋值 注意:数组的各元素必须与声明的数据类型完全相同 四、数组的使用 ...

    数组与定义

    数组是用来存储一组相同类型数据的数据结构,数组在初始化完毕后,Java会为数组在内存中分配一段连续的内存空间。

    在数组开辟空间之后,数组的大小就会被固定,长度不会再发生改变,即使数组没有被存入任何数据,数组依旧会占有开辟空间大小的空间。

    数组的声明与使用

    数组的声明

    数组的声明使用总共分为四个步骤
    一、数组的声明      包括:数组名,数据类型,[]
    二、为数组分配空间   必要,否则会出现错误
    三、数组各元素的赋值  注意:数组的各元素必须与声明的数据类型完全相同
    四、数组的使用

    数组的声明与分配空间是可以在一起进行的,如:

    //合在一起
    int [] arr1 = new int [3];
    int arr2 [] = new int [5];
    //分开写
    int [] arr3;
    arr3 = new int [3];

    但是根据某公司的java文档规范,[]必须要跟在数据类型后面。。。

    如果在为数组分配空间时没有分配空间,数组不一定会出现逻辑错误,但是在编译时会出现编译错误

    不管是哪一种声明方式,在进行了声明数组,并且分配空间之后,数组即使没有被赋值也拥有初始值,初始值根据声明数组的数据类型有所不同

    数组元素类型默认初始值
    byte、short、int、long0
    float、double0.0
    char'\u0000'
    booleanfalse
    引用数据类型null

    当数组被赋值的元素比较少,而且方便赋值的话,有时会把赋值操作和定义数组操作一起完成,被称之为数组初始化。语法格式如下:

    数据类型[]数组名 = {值1,值2,值3......}
    或者
    数据类型[]数组名 = new 数据类型[]{值1,值2,值3......}

    注意1:后一种定义方式,在new 数据类型的[]中一定不要加入数字,否则会被认为不是一条语句。

    注意2:如果采用这样的数组初始化的方式声明数组,一定不要将上述代码拆成两段,这样依旧会提示错误:不能在这里赋值。

    //错误示范
    int[] arr1 = new arr[3];
    arr1= {1,2,3};

     

    数组的使用

    在使用数组时,我们使用数组的下标来准确的定位到数组中的每个元素          数组名[下标值]。

    数组的下标从0开始,0是数组的第一个元素,1是数组第二个元素。

    [数组长度]可以通过   数组.length  属性来获取数组的长度。

    arr1[0] = 1;

    数组的遍历

    有了数组的下标和数组的长度,我们就可以让数组和for循环结合,使数组进行动态存储和快速遍历的应用。

    使用Scanner和for循环输入数组:

        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.print("请输入数组长度:");
            int num = sc.nextInt();
            int[] arr1 = new int[num];
            for (int i = 0;i<arr1.length;i++){
                System.out.print("请输入数组元素:");
                arr1[i]= sc.nextInt();
            }
        }

    此时我们可以使用for循环来遍历数组,也可以使用增强for循环来输出数组。

            //遍历输出数组
            for (int i = 0;i< arr1.length;i++){
                System.out.print(arr1[i]+" ");
            }
    
            //增强for
            for (int i:arr1){
                System.out.print(i+" ");
            }

    输出结果为:

    数组添加

    数组的添加要求遍历数组,使用if来找出想要添加的位置,从末尾开始依次向后移动一个下标,最后再把要加入的元素添加进去。

    注意在一开始移动末尾元素时要考虑数组越界问题。

    数组修改

    数组修改则简单的多,只需要遍历数组,找出需要修改的值,将修改的元素赋值给原先元素即可。

    注意要考虑数组内可能不存在索要查找的元素。

    数组删除

    数组删除要求遍历数组,找到需要删除的元素,将要删除元素的后一个下表的元素赋值给当前元素,并且之后的元素依次(从前向后)向前移动一个下标即可,将最后一位设置为空。

    注意: arr1.length返回的值是数组的长度  是数组的   最后一个下标+1,注意在for循环中不要出现越界问题。

    二维数组

    语法结构

    数据类型 数组名[][]
    或者数据类型[][]数组名
    
    如:
    int [][]score;
    score = new int[5][50]
    或者
    int [][] scores = new int [5][50]

    二维数组本质上还是一维数组,数组的每一个元素内存放的元素都为一维数组。

    二维数组的使用

    初始化二维数组:

    int[][]scores = new int [][]{{1,2,3,4,5},{1,2,3},{1}};
    或者
    int scores[][] = {{1,2,3,4,5},{1,2,3},{1}}

    二维数组的遍历与累加

    int [][]array = new int [][]{{1,2},{1,2,3},{1,2}};
    int sum;
    for(int i = o;i<array.length;i++){
        for(int j=0;j<array[i].length;j++){
            total += array[i][j];    
        }
    }
    

    Arrays类的使用

    arrays类是jdk提供给,用于操作数组的工具类,可以提供排序,复制,比较,填充,查询等功能

    常用方法如下:

    equals(arr1,arr2)boolean比较数组是否相等
    sort(array)void对数组进行升序排列
    toString(array)String将数组转换为字符串
    fill(array,val)void把数组的所有元素都复值为val
    copyOf(array,length)与array类型一致把数组复制成一个长为length的新数组
    binarySearch(array,val)int查询元素值val在数组的下标

     

    int [] arr1= {1,2,3};
    int [] arr2={1,2,3};
    int []arr3 = {4,2,1};
    System.out.println(Arrays.equals(arr1,arr2)); //true
    System.out.println(Arrays.equals(arr1,arr3));  //false
    Arrays.sort(arr3); //{1,2,4}
    System.out.println(Arrays.toString(arr1));//[1,2,3]
    Arrays.fill(arr2,10);//{10,10,10}
    int [] arr4 = Arrays.copyOf(arr2,2);//{10,10}
    int [] arr5 = Arrays.copyOf(arr2,5);//{10,10,10,0,0}
    //使用binarySearch()之前必须进行sort排序
    System.out.println(Arrays.binarySearch(arr3,4));//2  注意:这里的下标指排序之后的下标
    

     

    展开全文
  • 数组数组是大部分编程语言所支持的数据结构,Java也支持数组,Java的数组种引用类型的变量,Java程序通过数组引用变量来操作数组,包括获取数组的长度,访问数组的值等。数组的基本概念数组是用于存储多个数据,...
  • 当数组中每个元素都只带有一个下标时,这种数组就是“一维数组”。一维数组(one-dimensional array)实质上是一组相同类型数据的线性集合,是数组中最简单的一种数组。...声明一维数组的语法格式为: type[] arr...
  • 数组用来表示一组数据的集合。使用数组,可以方便地定义一个名字(数组名)来表示大批量数据,并能够通过循环批处理大量...(1)一维数组是由元素类型、数组名和长度(数组包含的元素个数)组成的构造类型。 in...
  • 《编译技术》上机 实验一:词法语法分析器的设计与实现,生成抽象语法树。此处完成补充 一维数组赋值 的操作
  • 一维数组声明,创建,应用操作,及一维数组的冒泡排序。 二维数组的声明,创建
  • C语言入门系列之6.一维和二维数组

    千次阅读 多人点赞 2020-04-27 10:18:31
    在C语言中使用数组必须先进行定义,一维数组声明格式为类型说明符 数组名 [常量表达式];,不允许对数组的大小作动态定义;形式为数组名[下标];给数组赋值包括赋值语句赋值、初始化赋值和动态赋值3种方式。二维数组...
  • 一维数组实质上是一组相同类型数据的线性集合,是数组中最...声明一维数组的语法格式为: 数据类型数组名[]; //声明数组 或者 数据类型[]数组名; //声明数组 以上两种格式都可以声明一个数组,其中的数据类...
  • 小结了一维数组和二维数组的创建与初始化、使用、存储、指针访问和几个小点
  • Java数组(一维数组

    2021-03-04 19:58:27
    数组是在程序设计中为了处理方便,把具有相同类型的若干变量按有序的形式组织起来的种形式。这些按序排列的同类数据元素的集合称为数组数组中的每个数据称为数组元素,数组的元素是有序的。 数组的概念 数组是...
  • 一维数组创建的几种方法

    千次阅读 2018-04-07 22:14:10
    数组可以说是对于每种语言学习中的最基础的数据结构之,几乎是在所有项目中都会涉及到数组的使用,接下来就详细介绍一下数组声明、创建和初始化以及实例代码解析,以Java语言描述 声明 数据类型 数组名称[]...
  • 1. 理解为何要引入数组 2. 了解数组的分类 3. 掌握一维数组遍历 4. 掌握求一维数组最值 5. 掌握一维数组排序
  • Presentation on theme: "第7章 数组 本章要求: 1、掌握C语言数组在内存中的存储形式 2、掌握一维数组和二维数组的定义及使用 3、掌握使用数组的方法"— Presentation transcript:第7章 数组 本章要求: 1、掌握...
  • 1.2 一维数组的定义、赋值和初始化

    千次阅读 2020-09-21 14:33:38
    当数组中每个元素都只带有一个下标时,这种数组就是“一维数组”。一维数组(one-dimensional array)实质上是一组相同类型数据的线性集合...声明一维数组的语法格式为: type[] arrayName; // 数据类型[] 数组名; 或
  • Oracle存储过程 一维数组 二维数组 (范例) /* 在PL/SQL中是没有数组(Array)概念的。但是如果程序员想用Array的话,就得变通一下,用TYPE 和Table of Record来代替多维数组,一样挺好用的。 emp_type 就好象一个...
  • 用指针访问二维数组

    2021-05-21 10:32:28
    在日常做题的过程中,发现了个关于通过指针访问二维数组的问题题目如下:**若有以下语句:**int a[4][5],(*p)[5];p=a;`下面哪个选项表示a数组中的元素?`A. p+1B. * (p+3)C. * (p+1)+3D. ( p+2)`正确答案为D,我...
  • 一维数组简介及三种排序方法

    千次阅读 2019-07-27 19:36:04
    无须声明单个变量,例如:number0, number1,…,number99, 只要声明一数组变量 numbers,并且用 numbers[0], numbers[1],…, numbers[99]来表示单个变量。 数组创建: 声明一数组变量、创建数组、然后将数组引用...
  • PL0扩展一维数组array

    千次阅读 多人点赞 2019-12-11 22:24:34
    PL0语言数组变量类型文法可定义为: Var <数组变量名> ’(‘<下界>,<上界>’)’ 其中<下界>,<上界>是常量名或无符号数 引用格式可为:C(1),c(a),C(a+b),C(b+C(1)) 头文件修改: ...
  • 是对一维数组进行赋值,而a是二维数组无法使用一维数组的赋值方法,所以程序会报错。该代码的正确方法应该是:int a[][] = new int[3][2];a[0][0]=1;a[0][1]=6;扩展资料java定义二维数组的方法:1、动态初始化数据...
  • 释义 数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按无序的形式组织起来的一种形式。...一维数组声明 两种声明格式 元素类型[] 变量名称 示例:int[] intArray; 元素类型 变量名称[] 示例:int intA...
  • C++ 一维数组

    千次阅读 2019-12-16 20:36:05
    声明(创建)一维数组及规则 引用数组元素 数组排序 冒泡排序法 数组的基本概念 先来说一下一维数组的定义:一维数组即为下标只有一个的数组,一维数组也是最简单的数组 数组也就是一组按照顺序排列在一起且...
  • 一维/二维数组的几种初始化方法

    千次阅读 2020-08-03 20:54:18
    一维数组的初始化方法 方式一:静态初始化 数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成,不能分开两个语句写 举例: 定义存储1,2,3,4,5整数的数组容器 int[] arr = {1,2,3,...
  • C++中使用new动态声明维数组的方式

    千次阅读 多人点赞 2020-07-24 22:46:00
    C++中动态二维数组声明方式 在C/C++中定义动态数组时我们都很熟悉使用的是 new 关键字,基本语法如下: typeName *arrayName = new typeName[arraySize]; 比如若想通过输入的 n 来创建个数组大小为 n 的 int 型...
  • 声明二维数组与一维数组一样,使用Dim语句声明二维数组。例如,语句Dim myArray(3,7) AsInteger声明了一个名为myArray的包含4行8列共32个元素的二维整型数组,如图1所示。 图1也可以使用以下语句,使myArray数组的...
  • C++语言篇 第五章 一维数组

    千次阅读 2020-08-02 20:51:25
    第一节 一维数组 数组就是一组相同类型的变量,它们往往都是为了表示同一批对象的统一属性,如一个班级所有同学的身高、全球所有国家的人口数等。 数组可以是一维的,也可以是二维或多维的。 数组: 是一组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,136
精华内容 12,854
关键字:

一维数组声明语句错误