精华内容
下载资源
问答
  • 一维数组的正确引用
    千次阅读
    2020-12-30 16:30:24

    二维数组元素指针引用

    1.定义
    2.数组指针和指针数组的区别

    1.二维数组可以理解为是一个一维数组,不过每个数组元素又是一个一维数组
    int a[2][3]={{1,2,3},{4,5,6}};
    可以理解为,二维数组只有两个元素,即a[0]和a[1],只不过元素类型为一维数组
    指向二维数组的指针(行指针)
    格式:类型 (*指针名) [N]
    N为数组的第二维长度

    2.二维数组指针与指针型数组的区别

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

    int *p0[3] = a;    //错误,将一个二维数组赋给指针型数组
    
    int(*p1)[3] = a;   //正确
    

    数组指针(也称行指针)
    定义 int (*p)[n];
    ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个整型数据的长度。

    如要将**二维数组**赋给一指针,应这样赋值:
    int a[3][4];
    int (*p)[4]; //该语句是定义一个数组指针,指向含4个元素的一维数组。
     p=a;        //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]
     p++;       //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][  ]
    

    比如要表示数组中i行j列一个元素:

    *(p[i]+j)*(*(p+i)+j)(*(p+i))[j]、p[i][j]
    

    优先级:()>[]>*
    出处:
    https://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html

    3.实现一个3*4阶矩阵转置 指针为形参

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include<stdlib.h>
    //定义一个3行4列的二维数组arr。
    //定义一个函数func()完成矩阵转置,以数组指针作为参数。
    //在func()函数内部,使用for循环完成矩阵转置
    void func(int(*pa)[4], int(*pb)[3], int x, int y)
    {
        int i, j;
        /*-------------------------begin------------------*/
        for(i=0;i<x;i++)
           for(j=0;j<y;j++){      	
           	 *(pb[j]+i)=*(pa[i]+j);
           	 // *(*(pb+j)+i)=*(*(pa+i)+j);
           	 // pb[j][i]=pa[i][j];
           	 // (*(pb+j))[i]=(*(pa+i))[j];
    	   }
        /*--------------------------end-------------------*/
        printf("转置:\n");
        for (i = 0; i < y; i++)
        {
            for (j = 0; j < x; j++)
            {
                printf("%d\t", pb[i][j]);
            }
            printf("\n");
        }
    }
    int main()
    {
        int i, j;
        int arr[3][4], brr[4][3];
        printf("输入二维数组的元素:\n");
        for (i = 0; i < 3; i++)
        {
            for (j = 0; j < 4; j++)
            {
                scanf("%d", &arr[i][j]);
            }
        }
        func(arr,brr,3,4);
        return 0;
    }
    
    
    
    

    在这里插入图片描述
    另有:

    数组元素访问 方法总结

    更多相关内容
  • 前面给大家介绍了一下什么是java数组,下面要接着给大家介绍的就是java一维数组定的定义以及创建一维数组方面的知识。数组当中的每个元素都只带有一个下标的时候,这样的数组就是一维数组一维数组实质上来说就是一...

    前面给大家介绍了一下什么是java数组,下面要接着给大家介绍的就是java一维数组定的定义以及创建一维数组方面的知识。

    数组当中的每个元素都只带有一个下标的时候,这样的数组就是一维数组,一维数组实质上来说就是一组相同类型数据的线性集合,是数组当中,最简单的一种数组。

    数组是引用数据类型,引用数据类型在使用之前一定要做两件事情:声明和初始化。

    下面的话就来重点的介绍一维数组的创建方面的知识。

    创建一维数组

    为了在程序当中使用一个数组,必须要声明一个引用这个数组的变量,并且指明整个变量可以引用的数组类型。

    下面的话就是声明一维数组的语法格式:type[] arrayName;    // 数据类型[] 数组名;

    或者:type arrayName[];    // 数据类型 数组名[];

    可以看出,数组的声明有两种形式:

    1、中括号”[]“跟在元素数据类型之后;

    2、中括号”[]“跟在变量名之后;

    对于上面的2种语法格式来讲的话,java更推荐采用第一种声明格式。

    第一种格式

    684e08c0c53e92c9c9f72e329e94a6bf.png,定义一个变量,在这当中变量名为arrayName,变量类型我type[]。

    前面的话已经说明了type[]

    确实是一种新类型,和type类型完全不同(例如int类型是基本类型,但int[]是引用类型),所以的话,这样的方式很容易理解,也符合定义变量的语法。

    第二种格式

    14166bb4fee955a311aa4d15a56c4e7a.png可读性就很差,看起来的话就好像定义了一个类型为type的变量,而变量名是arrayName[],这和真实的含义比较就差得很远。

    上面的两种格式都能够声明一个数组,在这当中,数据类型既可以是基本数据类型,也可以是引用数据类型。

    数组名能够是任意合法的变量名,声明数组就是要告诉计算机该数组中数据的类型是什么。

    例如:int[] score;    // 存储学生的成绩,类型为整型

    double[] price;    // 存储商品的价格,类型为浮点型

    String[] name;    // 存储商品名称,类型为字符串型

    在声明数组的时候,不需要去规定数组的长度,例:int score[10];    // 这是错误的

    注意一下在声明数组变量时千万不要漏写[]。

    以上就是对于java一维数组定义和创建一维数组知识的一些简单介绍了,更多相关java基础知识,请继续来奇Q工具网进行了解吧。

    推荐阅读:

    展开全文
  • 一维数组、二维数组】 作者:zhenyi 专栏:Java基础 简介:java基础专栏文章,适合java基础的学习和巩固 文章所用文件,可与作者联系获取!如果对您有帮助,点个关注吧,持续更新中,谢谢支持。如果有问题或...

    【java基础:4.一维数组、二维数组】 

    作者:zhenyi

    专栏:Java基础

    简介:java基础专栏文章,适合java基础的学习和巩固

    文章所用文件,可与作者联系获取!如果对您有帮助,点个关注吧,持续更新中,谢谢支持。如果有问题或错误,欢迎指出私信与我联系,谢谢。

    目录

    一、数组介绍

    二、一维数组

    1. 一维数组的声明和初始化

     2.数组元素的默认初始化值

    3.例题

    三、多维数组

    1.二维数组

    2.二维数组[][]:数组中的数组  

     3.二维数组的使用

    4. 数组元素的默认初始化值 

    四、数组中涉及到的常见算法

    1. java.util.Arrays:操作数组的工具类,里面定义了很多操作数组的方法

    2.求数值型数组中元素的最大值、最小值、平均数、总和等 

    3. 数组的复制、反转、查找(线性查找、二分法查找)

    4.数组的冒泡排序的实现

    5.数组的快速排序的实现

    6.数组异常处理


    一、数组介绍

    数组(Array),是多个相同类型数据一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一管理。

    数组的常见概念

    (1)数组名

    (2)下标(或索引)

    (3)元素

    (4)数组的长度

     数组的特点:
     1)数组是有序排列的
     2)数组属于引用数据类型的变量。数组的元素,既可以是基本数据类型,也可以是引用数据类型
     3)创建数组对象会在内存中开辟一整块连续的空间
     4)数组的长度一旦确定,就不能修改。 
      

    数组的分类:
     ① 按照维数:一维数组、二维数组、。。。
     ② 按照数组元素的类型:基本数据类型元素的数组、引用数据类型元素的数组

    二、一维数组

    1. 一维数组的声明和初始化

    声明方式

    type var[] type[] var

    例如:

    int a[];

    int[] a1;

    double b[];

    String[] c; //引用类型变量数组

    •  Java语言中声明数组时不能指定其长度(数组中元素的数), 例如: int a[5]; //非法

    动态初始化:数组声明且为数组元素分配空间与赋值的操作分开进行

    int arr=new int[3];
    arr[0]=3;
    arr[1]=9;
    arr[2]=8;
    
    
    String names[];
    names =new String[3];
    names[0]="张三";
    names[1]="李四";
    names[2]="王二";
    

    静态初始化:在定义数组的同时就为数组元素分配空间并赋值。

    int arr[]=new int[]{3,9,8}
    //或
    int[] arr={3,9,8};
    
    String naems[]={
    "张三","李四","王二"
    }

    数组元素的引用

    定义并用运算符new为之分配空间后,才可以引用数组中的每个元素;

    (1)数组元素的引用方式:数组名[数组元素下标]

    (2)数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];

    (3)数组元素下标从0开始;长度为n的数组合法下标取值范围: 0 —>n-1int a[]=new

    int[3]; 可引用的数组元素为a[0]a[1]a[2]

    (4)每个数组都有一个属性length指明它的长度,例如:a.length 指明数组a的长度(元素个数)

    (5)数组一旦初始化,其长度是不可变的

    public class ArrayTest {
    	
    	public static void main(String[] args) {
    		
    		//1. 一维数组的声明和初始化
    		int num;//声明
    		num = 10;//初始化
    		int id = 1001;//声明 + 初始化
    		
    		int[] ids;//声明
    		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
    		ids = new int[]{1001,1002,1003,1004};
    		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
    		String[] names = new String[5];
    		
    		//错误的写法:
    //		int[] arr1 = new int[];
    //		int[5] arr2 = new int[5];
    //		int[] arr3 = new int[3]{1,2,3};
    		
    		//也是正确的写法:
    		int[] arr4 = {1,2,3,4,5};//类型推断
    		
    		//总结:数组一旦初始化完成,其长度就确定了。
    		
    		//2.如何调用数组的指定位置的元素:通过角标的方式调用。
    		//数组的角标(或索引)从0开始的,到数组的长度-1结束。
    		names[0] = "王铭";
    		names[1] = "王赫";
    		names[2] = "张学良";
    		names[3] = "孙居龙";
    		names[4] = "王宏志";//charAt(0)
    //		names[5] = "周扬";
    		
    		//3.如何获取数组的长度。
    		//属性:length
    		System.out.println(names.length);//5
    		System.out.println(ids.length);
    		
    		//4.如何遍历数组
    		/*System.out.println(names[0]);
    		System.out.println(names[1]);
    		System.out.println(names[2]);
    		System.out.println(names[3]);
    		System.out.println(names[4]);*/
    		
    		for(int i = 0;i < names.length;i++){
    			System.out.println(names[i]);
    		}
    		
    		
    	}
    
    }

     2.数组元素的默认初始化值

    数组是引用类型,它的元素相当于类的成员变量,因此数组一经分配空间,其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如:

    public class Test {

    public static void main(String argv[]){

    int a[]= new int[5];

    System.out.println(a[3]); //a[3]的默认值为0

    }

    }

     (1)对于基本数据类型而言,默认初始化值各有不同

    (2)对于引用数据类型而言,默认初始化值为null(注意与0不同!)  

     数组元素的默认初始化代码实现:

    public class Projectsix {
        public static void main(String[] args) {
            //5.数组元素的默认初始化值
            int[] arr = new int[4];
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
            System.out.println("**********");
    
            short[] arr1 = new short[4];
            for (int i = 0; i < arr1.length; i++) {
                System.out.println(arr1[i]);
            }
            System.out.println("**********");
            float[] arr2 = new float[5];
            for (int i = 0; i < arr2.length; i++) {
                System.out.println(arr2[i]);
            }
    
            System.out.println("**********");
            char[] arr3 = new char[4];
            for (int i = 0; i < arr3.length; i++) {
                System.out.println("----" + arr3[i] + "****");
            }
    
            if (arr3[0] == 0) {
                System.out.println("你好!");
            }
    
            System.out.println("**********");
            boolean[] arr4 = new boolean[5];
            System.out.println(arr4[0]);
    
            System.out.println("**********");
            String[] arr5 = new String[5];
            System.out.println(arr5[0]);
            if (arr5[0] == null) {
                System.out.println("北京天气不错!");
            }
        }
    }
    

    3.例题

            升景坊单间短期出租4个月,550/月(水电煤公摊,网费35/月),空调、卫生间、厨房齐全。 屋内均是IT行业人士,喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人,爱干净、安静。

    public class Projectsix {
        public static void main(String[] args) {
            int[] arr=new int[]{8,2,1,0,3};
            int[] index=new int[]{2,0,3,2,4,0,1,3,2,3,3};
            String tel="";
            for (int i=0;i< index.length;i++){
                tel += arr[index[i]];
            }
            System.out.println("联系方式"+tel);
        }
    }
    

    三、多维数组

    1.二维数组

    理解:
     对于二维数组的理解,我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
     其实,从数组底层的运行机制来看,其实没有多维数组。

    2.二维数组[][]:数组中的数组
      

    格式1(动态初始化)int[][] arr = new int[3][2];

    定义了名称为arr的二维数组

    二维数组中有3个一维数组

    每一个一维数组中有2个元素

    一维数组的名称分别为arr[0], arr[1], arr[2]

    给第一个一维数组1脚标位赋值为78写法是:arr[0][1] = 78;

    格式2(动态初始化)int[][] arr = new int[3][];

    二维数组中有3个一维数组。

    每个一维数组都是默认初始化值null (注意:区别于格式1

    可以对这个三个一维数组分别进行初始化

    arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

    注:

    int[][]arr = new int[][3]; //非法

    格式3(静态初始化)int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

    定义一个名称为arr的二维数组,二维数组中有三个一维数组

    每一个一维数组中具体元素也都已初始化

    第一个一维数组 arr[0] = {3,8,2};

    第二个一维数组 arr[1] = {2,7};

    第三个一维数组 arr[2] = {9,0,1,6};

    第三个一维数组的长度表示方式:arr[2].length;

     注意特殊写法情况:int[] x,y[]; x是一维数组,y是二维数组。

    Java中多维数组必都是规则矩阵形式

     3.二维数组的使用


     ① 二维数组的声明和初始化
     ② 如何调用数组的指定位置的元素
     ③ 如何获取数组的长度
     ④ 如何遍历数组

    public class Textone {
        public static void main(String[] args) {
            //1.二维数组的声明和初始化
            int[] arr = new int[]{1,2,3};//一维数组
            //静态初始化
            int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
            //动态初始化1
            String[][] arr2 = new String[3][2];
            //动态初始化2
            String[][] arr3 = new String[3][];
            //错误的情况 
    //		String[][] arr4 = new String[][4];
    //		String[4][3] arr5 = new String[][];
    //		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
    
            //也是正确的写法:
            int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
            int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
    
            //2.如何调用数组的指定位置的元素
            System.out.println(arr1[0][1]);//2
            System.out.println(arr2[1][1]);//null
    
            arr3[1] = new String[4];
            System.out.println(arr3[1][0]);
    
            //3.获取数组的长度
            System.out.println(arr4.length);//3
            System.out.println(arr4[0].length);//3
            System.out.println(arr4[1].length);//4
    
            //4.如何遍历二维数组
            for(int i = 0;i < arr4.length;i++){
    
                for(int j = 0;j < arr4[i].length;j++){
                    System.out.print(arr4[i][j] + "  ");
                }
                System.out.println();
            }
        }
    }
    

    二维数组的使用:
     规定:二维数组分为外层数组的元素,内层数组的元素
              int[][] arr = new int[4][3];
              外层元素:arr[0],arr[1]等
              内层元素:arr[0][0],arr[1][2]等

    4. 数组元素的默认初始化值 


        针对于初始化方式一:比如:int[][] arr = new int[4][3];
           外层元素的初始化值为:地址值
           内层元素的初始化值为:与一维数组初始化情况相同
           
        针对于初始化方式二:比如:int[][] arr = new int[4][];
            外层元素的初始化值为:null
           内层元素的初始化值为:不能调用,否则报错。
        

    public class Textone {
        public static void main(String[] args) {
    
            int[][] arr = new int[4][3];
            System.out.println(arr[0]);//[I@15db9742
            System.out.println(arr[0][0]);//0
    
    //		System.out.println(arr);//[[I@6d06d69c
    
            System.out.println("*****************");
            float[][] arr1 = new float[4][3];
            System.out.println(arr1[0]);//地址值
            System.out.println(arr1[0][0]);//0.0
    
            System.out.println("*****************");
    
            String[][] arr2 = new String[4][2];
            System.out.println(arr2[1]);//地址值
            System.out.println(arr2[1][1]);//null
    
            System.out.println("*****************");
            double[][] arr3 = new double[4][];
            System.out.println(arr3[1]);//null
    //		System.out.println(arr3[1][0]);//报错
    
        }
    }
    

    四、数组中涉及到的常见算法

    1. java.util.Arrays:操作数组的工具类,里面定义了很多操作数组的方法

    public class ArraysTest {
    	public static void main(String[] args) {
    		
    		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
    		int[] arr1 = new int[]{1,2,3,4};
    		int[] arr2 = new int[]{1,3,2,4};
    		boolean isEquals = Arrays.equals(arr1, arr2);
    		System.out.println(isEquals);
    		
    		//2.String toString(int[] a):输出数组信息。
    		System.out.println(Arrays.toString(arr1));
    		
    			
    		//3.void fill(int[] a,int val):将指定值填充到数组之中。
    		Arrays.fill(arr1,10);
    		System.out.println(Arrays.toString(arr1));
    		
    
    		//4.void sort(int[] a):对数组进行排序。
    		Arrays.sort(arr2);
    		System.out.println(Arrays.toString(arr2));
    		
    		//5.int binarySearch(int[] a,int key)
    		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
    		int index = Arrays.binarySearch(arr3, 210);
    		if(index >= 0){
    			System.out.println(index);
    		}else{
    			System.out.println("未找到");
    		}
    		
    		
    	}
    }
    

    2.求数值型数组中元素的最大值、最小值、平均数、总和等
     

             定义一个int型的一维数组,包含10个元素,分别赋一些随机整数,然后求出所有元素的最大值,最小值,和值,平均值,并输出出来。    

    要求:所有随机数都是两位数。

    
    public class Textone {
        public static void main(String[] args) {
    
            int[] arr = new int[10];
    
            for(int i = 0;i < arr.length;i++){
                arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
            }
    
            //遍历
            for(int i = 0;i < arr.length;i++){
                System.out.print(arr[i] + "\t");
            }
            System.out.println();
    
            //求数组元素的最大值
            int maxValue = arr[0];
            for(int i = 1;i < arr.length;i++){
                if(maxValue < arr[i]){
                    maxValue = arr[i];
                }
            }
            System.out.println("最大值为:" + maxValue);
    
            //求数组元素的最小值
            int minValue = arr[0];
            for(int i = 1;i < arr.length;i++){
                if(minValue > arr[i]){
                    minValue = arr[i];
                }
            }
            System.out.println("最小值为:" + minValue);
            //求数组元素的总和
            int sum = 0;
            for(int i = 0;i < arr.length;i++){
                sum += arr[i];
            }
            System.out.println("总和为:" + sum);
            //求数组元素的平均数
            int avgValue = sum / arr.length;
            System.out.println("平均数为:" + avgValue);
    
        }
    }
    

    3. 数组的复制、反转、查找(线性查找、二分法查找)

    public class ArrayTest2 {
    	
    	public static void main(String[] args) {
    		
    		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
    		
    		
    		//数组的复制(区别于数组变量的赋值:arr1 = arr)
    		String[] arr1 = new String[arr.length];
    		for(int i = 0;i < arr1.length;i++){
    			arr1[i] = arr[i];
    		}
    		
    		//数组的反转
    		//方法一:
    //		for(int i = 0;i < arr.length / 2;i++){
    //			String temp = arr[i];
    //			arr[i] = arr[arr.length - i -1];
    //			arr[arr.length - i -1] = temp;
    //		}
    		
    		//方法二:
    //		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
    //			String temp = arr[i];
    //			arr[i] = arr[j];
    //			arr[j] = temp;
    //		}
    		
    		//遍历
    		for(int i = 0;i < arr.length;i++){
    			System.out.print(arr[i] + "\t");
    		}
    		
    		System.out.println();
    		//查找(或搜索)
    		//线性查找:
    		String dest = "BB";
    		dest = "CC";
    		
    		boolean isFlag = true;
    		
    		for(int i = 0;i < arr.length;i++){
    			
    			if(dest.equals(arr[i])){
    				System.out.println("找到了指定的元素,位置为:" + i);
    				isFlag = false;
    				break;
    			}
    			
    		}
    		if(isFlag){
    			System.out.println("很遗憾,没有找到的啦!");
    			
    		}
    		//二分法查找:(熟悉)
    		//前提:所要查找的数组必须有序。
    		int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
    		
    		int dest1 = -34;
    		dest1 = 35;
    		int head = 0;//初始的首索引
    		int end = arr2.length - 1;//初始的末索引
    		boolean isFlag1 = true;
    		while(head <= end){
    			
    			int middle = (head + end)/2;
    			
    			if(dest1 == arr2[middle]){
    				System.out.println("找到了指定的元素,位置为:" + middle);
    				isFlag1 = false;
    				break;
    			}else if(arr2[middle] > dest1){
    				end = middle - 1;
    			}else{//arr2[middle] < dest1
    				head = middle + 1;
    			}
    
    			
    		}
    		
    		if(isFlag1){
    			System.out.println("很遗憾,没有找到的啦!");
    		}
    		
    		
    	}
    }
    

    4.数组的冒泡排序的实现

    
    public class Textone {
        public static void main(String[] args) {
    
            int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
    
            //冒泡排序
            for(int i = 0;i < arr.length - 1;i++){
    
                for(int j = 0;j < arr.length - 1 - i;j++){
    
                    if(arr[j] > arr[j + 1]){
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
    
                }
    
            }
    
    
    
    
            for(int i = 0;i < arr.length;i++){
                System.out.print(arr[i] + "\t");
            }
        }
    }
    

    5,数组的快速排序的实现

    public class QuickSort {
    	private static void swap(int[] data, int i, int j) {
    		int temp = data[i];
    		data[i] = data[j];
    		data[j] = temp;
    	}
    
    	private static void subSort(int[] data, int start, int end) {
    		if (start < end) {
    			int base = data[start];
    			int low = start;
    			int high = end + 1;
    			while (true) {
    				while (low < end && data[++low] - base <= 0)
    					;
    				while (high > start && data[--high] - base >= 0)
    					;
    				if (low < high) {
    					swap(data, low, high);
    				} else {
    					break;
    				}
    			}
    			swap(data, start, high);
    			
    			subSort(data, start, high - 1);//递归调用
    			subSort(data, high + 1, end);
    		}
    	}
    	public static void quickSort(int[] data){
    		subSort(data,0,data.length-1);
    	}
    	
    	
    	public static void main(String[] args) {
    		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
    		System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
    		quickSort(data);
    		System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
    	}
    }
    

    6.数组异常处理

     数组中的常见异常:
     1. 数组角标越界的异常:ArrayIndexOutOfBoundsExcetion
     2. 空指针异常:NullPointerException

    public class ArrayExceptionTest {
    	public static void main(String[] args) {
    		
    		//1. 数组角标越界的异常:ArrayIndexOutOfBoundsExcetion
    		int[] arr = new int[]{1,2,3,4,5};
    		
    //		for(int i = 0;i <= arr.length;i++){
    //			System.out.println(arr[i]);
    //		}
    		
    //		System.out.println(arr[-2]);
    		
    //		System.out.println("hello");
    		
    		//2.2. 空指针异常:NullPointerException
    		//情况一:
    //		int[] arr1 = new int[]{1,2,3};
    //		arr1 = null;
    //		System.out.println(arr1[0]);
    		
    		//情况二:
    //		int[][] arr2 = new int[4][];
    //		System.out.println(arr2[0][0]);
    		
    		//情况三:
    		String[] arr3 = new String[]{"AA","BB","CC"};
    		arr3[0] = null;
    		System.out.println(arr3[0].toString());
    	}
    }
    

    如果对您有帮助,点个关注吧,持续更新中,谢谢支持。如果有问题或错误,欢迎指出与我联系,谢谢。

    展开全文
  • 数组用来表示一组数据的集合。使用数组,可以方便地定义一个名字(数组名)来表示大批量数据,并能够通过循环批处理大量...(1)一维数组是由元素类型、数组名和长度(数组包含的元素个数)组成的构造类型。 in...

    数组用来表示一组数据的集合。使用数组,可以方便地定义一个名字(数组名)来表示大批量数据,并能够通过循环批处理大量数据。

    一、定义

    数组就是一组相同类型数据的集合。

    一维数组的定义形式为:

    元素类型  数组名  [常量表达式(数组包含的元素个数)]; 

    int A[10];
    int B[10], C[15]; //多个数组定义
    int E[10], m, n, F[15]; //数组和变量混合在一起定义

    (1)一维数组是由元素类型、数组名和长度(数组包含的元素个数)组成的构造类型。

    int A[10], B[20]; // 元素是整型
    double F1[8], F2[10]; //元素是双精度浮点型
    char S1[80], S2[80]; //元素是字符型
    

    (2)数组名必须符合C++标识符规则。

    (3)常量表达式表示数组中元素的个数,称为数组长度。常量表达式的值必须为正整数且大于等于1

    (4)数组一经定义,数组长度就始终不变。

       如:

    int n;
    cin>>n;
    int a[n];  //错误!
    
    

    二、内存形式

    C++规定数组元素是连续存放的,即在内存中一个元素紧跟着一个元素线性排列

     三、一维数组的初始化

    可以在一维数组定义时对它进行初始化,初始化的语法形式如下:

    元素类型  数组名 [常量表达式]={初值列表};

    int A[5]={1,2,3,4,5} , B[3]={7,8,9};
    //一维数组初始化

    (1)初值列表提供的元素个数不能超过数组长度,但可以小于数组长度。如果初值个数小于数组长度,则只初始化前面的数组元素, 剩余元素初始化为0。例如:

    int A[5]={1,8,9};
    

    (2)在提供了初值列表的前提下,数组定义时可以不用指定数组长度,编译器会根据初值个数自动确定数组的长度。例如:

    int A[]={1,8,9};

    可以用下面的表达式计算出数组A的长度:

     

    (3)若数组未进行初始化,静态数组的元素均初始化为0;在函数体内定义的动态数组,其元素没有初始化,为一个随机值。 

    static int A[10]; //静态数组,默认各元素的值为0
    int A[10]; //动态数组,各元素的值为随机数
    

    四、一维数组的引用 

    数组必须先定义后使用,且只能逐个引用数组元素的值而不能一次引用整个数组全部元素的值。

    数组元素引用是通过下标得到的,一般形式为:

    数组名 [下标表达式]

     (1)注意下标的表示形式

    ►下标表达式可以是常量、变量、表达式,但必须是正整数,不允许为负。

    数组元素下标总是从0开始。

    int A[5]={1,2,3,4,5}, x,i=3;
    x = A[2] ;  //常量
    A[i]++;     //变量
    A[1+2]=10;  //表达式
    

    (2)下标值不能超过数组长度,否则导致数组下标越界的严重错误。例如: 

    int A[5]={1,2,3,4,5};
    A[5]=10; //错误,没有A[5]元素
    

     

     (3)整个数组不允许进行赋值运算、算术运算等操作,只有元素才可以,例如:

    int A[10], B[10], C[10];
    A = B; //错误
    A = B + C; //错误
    A[0] = B[0]; //正确,数组元素赋值
    A[2] = B[2]+C[2]; //正确,数组元素赋值
    

    从数组的内存形式来看,数组元素的下标是有序递增的,这个特点使得可以利用循环来批量处理数组元素。

    如:

    对数组中的所有元素进行输入输出。 

     #include <iostream>
     using namespace std;
     int main() //一维数组的输入输出
     {
     int i, A[100]; 
     for(i=0;i<100;i++) cin>>A[i];
     for(i=100-1;i>=0;i--) cout<<A[i]<<" ";
     return 0;
     } 

    将一个一维数组的元素赋给另一个等长的一维数组。

     #include <iostream>
     int main()
     {
     int A[5]={1,2,3,4,5} , B[5] , i;
     for (i=0; i<5; i++)
     B[i] = A[i]; //元素一一复制
     return 0;
     } 

    展开全文
  • C语言二维数组及指针引用

    千次阅读 2022-04-11 15:40:58
    文章目录C语言二维数组及指针引用1.二维数组的定义与表示2.用指针引用维数组元素 C语言二维数组及指针引用 1.二维数组的定义与表示 二维数组是形如: 表示个int类型,三行四列的数组 int a[3][4]={1,2,3,4,5,6,7...
  • C语言定义和引用维数组

    千次阅读 2021-01-08 18:13:48
    其基本概念与方法与一维数组相似,如: float pay[3][6]; 以上定义了一个float型的二维数组 第一维有3个元素,第二维有6个元素。每一维的长度分别用一对括号起来 二维数组定义的一般形式为 类型说明符 数组名 [常量...
  • #C语言 一维数组的定义和引用 A. 一维数组的定义与初始化 1.几个概念 数组名 数组长度 数组下标运算符 数组维数 数组的基类型 2. 定义格式 格式:类型 数组名[常量表达式] 如 int a[100] /一维数组 char str[200] PS...
  • 大家起来分析一下下面这段代码:$arr = array();$arr["abc"] = array("sex" => 100, "age" => 18);$arr["bcd"] = array("sex" => 200, "age" => 19);$arr["cde"] = array("sex" => 250, "age" =>...
  • 一维数组的创建和初始化1.1 数组的创建1.2 数组的初始化1.3 一维数组的使用1.4 一维数组在内存中的存储2. 二维数组的创建和初始化2.1 二维数组的创建2.2 二维数组的初始化2.3 二维数组的使用三级目录 1. 一维数组的...
  • 维数组引用总结

    千次阅读 2017-07-13 13:29:15
    今天在论坛上有朋友提问:声明函数如下void function(int** pInt),意图是想参数传递个二维数组。于是就定义了个二维数组,比如 int[1][1],然后调用函数。结果如何?当然是失败了,编译器提示:cannot ...
  • 一维数组的创建和初始化 数组的创建: 数组是一组相同类型元素的集合。数组的创建方式: type_t arr_name [const_n]; // type_t 指数组的元素类型 // arr_name 数组的名称 // const_n 这是一个常量表达式,用来...
  • 对于二维数组,省略只能省略第个方括号中的常量表达式 如上的初赋值语句等同于: int a[4][3] = {{1, 2, 3}, {4, 5}, {6}, {8}}; 第二种:int = c[][3] = {1, 2, 3, 4, 5}; 要计算第个空的方括号中的...
  • 一维数组:定义一维数组之后,即在内存中分配一段连续的地址空间,如C语言中,int num[5],在32位系统中,int占据4个字节,现假设num[0]的地址空间为0x00000004,那么num[1]的地址空间即为0x00000008 (0x00000004 + ...
  • 【总结】一维数组、二维数组的声明和初始化 1.一维数组的声明和初始化:  1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行  1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行    数组一旦...
  • 一维数组的简单引用

    2022-03-23 23:58:51
    一维数组的简单引用(-.-) #include<stdio.h> int main() { int i,a[6]; for(i=0;i<6;i++) a[i]=i*2; for(i=5;i>0;i--) printf("%3d\n",a[i]); return 0; } 运行结果为 10 8 6 4 2 0 要注意区分...
  • 常用的就是一维数组、二维数组。 一维数组 数组定义:数据就是相同数据元素的集合。 数组是一种引用数据类型。不属于基本数据类型。 (1) 如何定义(声明)一维数组? 声明格式:数据类型[] 数组名称; (2) ...
  • 【JAVA】 一维数组

    2022-05-07 23:36:34
    1.一维数组 2.数组练习 3.二维数组 1.一维数组 1.数组的定义:一个数组是由多个相同的数据类型元素组成的集合,这些元素在内存中顺序排列,是一段连续的空间,空间被所有元素平均分成多个小空间一一占用,每个...
  • C语言一维数组教案.doc学学 科科计算机科学与技术 课课 程程C 语言程序设计 课课 题题一维数组 课课 时时2 教学目标教学目标1、掌握一维数组的定义和引用 2、掌握一维数组的初始化方法 3、了解与一维数组有关的应用...
  • 指向具有M个元素的一维数组指针 定义格式如下: 类型 (*指针变量)[M]; //M为一整型常量 通常利用该指针变量,指向二维数组的行地址,其中M表示二维数组的列数。 例如:利用行指针变量,按行输出二维数组各元素值 ...
  • C语言一维数组教案

    2021-05-19 15:47:56
    1、学 科:计算机科学与技术课 程:C语言程序设计课 题:一维数组课 时:2教学目标:1、掌握一维数组的定义和引用2、掌握一维数组的初始化方法3、了解与一维数组有关的应用编程方法教学重点:一维数组的定义和引用、...
  • C++ 一维数组

    千次阅读 2019-12-16 20:36:05
    一维数组 数组的基本概念 声明(创建)一维数组及规则 引用数组元素 数组排序 冒泡排序法 数组的基本概念 先来说一下一维数组的定义:一维数组即为下标只有一个的数组,一维数组也是最简单的数组 数组也就是一...
  • 一、一维数组的定义与初始化 1.一维数组的定义 一维数组也称向量,它用以组织具有一维顺序关系的一组同类型的数据。 一维数组的定义方式: 数据类型 数组名[常量表达式] 类型说明符表示数组中所有元素的类型;...
  • 文章目录 一维数组与二维数组的声明 一维数组的声明: 二维数组的声明: 总结 数组的初始化 静态初始化 动态初始化 默认初始化 一维数组与二维数组的声明 一维数组的声明: int[] a; //只声明数组a,没有初始化 int...
  • C#一维数组的理解之前我们来看看什么是数组?...C#一维数组的概念一维数组在本质上是由同类数据构成的表一维数组可以如下例所示声明一个由 5 个整数组成的数组:int[] array = new int[5];此数组包...
  • 在C语言中,一维数组的定义方式为:类型说明符数组名——例: int array[10]; 含义:定义了一个数组,数组名为array,有10个元素,元素的类型均为整型。这10个元素名分别是:array[0]、array[1...
  • 【例6-1】一维数组

    2022-01-23 16:27:42
    (一)一维数组的定义 定义一维数组的一般格式:类型标识符 数组名[整型常量表达式]; (1)"类型标识符"用来指定数组中各个元素的类型。 (2)"数组名"为合法的用户标识符。 (3)"整型常量表达式"表示数组长度(元素个数)...
  • java数组:一维数组

    2021-02-09 14:46:58
    文章目录数组:Array1、数组相关基础知识2、数组的优缺点一维数组1、怎样声明一个一维数组2、怎样初始化一个一维数组呢?3、对一维数组中的元素访问4、 一维数组的遍历5、静态存储Object类6、动态初始化一维数组7、...
  • 《全国计算机二级C语言程序设计讲义__一维数组和二维数组.ppt》由会员分享,可在线阅读,更多相关《全国计算机二级C语言程序设计讲义__一维数组和二维数组.ppt(28页珍藏版)》请在人人文库网上搜索。1、第8课一维阵列...
  • C语言二维数组的定义和引用C语言二维数组的定义和引用7.1.1二维数组的定义前面介绍的数组只有一个下标,称为一维数组,其数组元素也称为单下标变量。在实际问题中有很多量是二维的或多维的,因此C语言允许构造多维...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,836
精华内容 16,334
热门标签
关键字:

一维数组的正确引用