精华内容
下载资源
问答
  • 2021-02-12 08:58:49

    java定义数组的方法有:1、【数组类型[] 数组名 = new 数组类型[数组长度]】;2、【数组类型[] 数组名 = {数组元素}】;3、【数组类型[] 数组名 = new 数组类型[] {数组元素}】。

    f9727375ddef0f25953b68b6768bfc78.png

    本文操作环境:windows10系统、java8版本、thinkpad t480电脑。

    (学习视频分享:java教学视频)

    详细介绍:

    定义数组的三种方法:

    1、数组类型[] 数组名=new 数组类型[数组长度];

    2、数组类型[] 数组名={数组0,数组1,数组2,数组3,。。。。};

    3、数组类型[] 数组名=new 数组类型[]{数组0,数组1,数组2,......};

    举例如下:public class WhatEver {

    public static void main(String[] args) {

    //第一种 例:

    String[] test1 = new String[6];

    test1[0] = “数组0”;

    test1[1] = “数组1”;

    //第二种 例:

    String[] test2 = {“数组0”,“数组1”,“数组2”,“。。。。”};

    //第三种 例:

    String[] test3 = new String[]{“数组0”,“数组1”,“数组2”,“。。。。”};

    }

    }

    更多相关内容
  • Java中,数组定义有三种方式,其基本语法格式如下:数组类型[] 数组名 = new 数组类型[数组长度]; 数组类型[] 数组名 = new 数组类型[]{数组元素0,数组元素...

    在Java中,数组的定义有三种方式,其基本语法格式如下:

    数组类型[] 数组名 = new 数组类型[数组长度];   
    数组类型[] 数组名 = new 数组类型[]{数组元素0,数组元素1,...};  
    数组类型[] 数组名 = {数组元素0,数组元素1,...};
    

    在上述三种定义数组的语法格式中,数组类型可以是前面小节中介绍的变量的数据类型,数组名就是定义的变量名。

    要符合标识符的规范,数组长度表示该数组中可容纳的数组元素的个数,而数组元素0、数组元素1就表示定义的数组中具体包含的数据。

    以上三种定义数组语法格式的实际使用示例如下:

    int[] ids = new int[100];   
    String[] names = new String[]{"张三","tom",...};  
    Object[] object = {"张三","tom",...};
    

    第一种方式定义了一个int[]数组类型的变量ids,使用new int[100]指定了该数组的长度(也就是元素的个数)为100,但并没有为数组中的元素赋值;

    第二种和第三种方式分别定义了一个String[]类型和Object[]类型的数组变量names和object,并都通过“=”右边的大括号“{}”为数组完成了初始化赋值。

    关于数组在内存中的存储方式,这里以上述定义数组的第一种方式为例,来进行具体说明。第一种数组定义的方式,相当于在内存中定义了100个int类型的变量,第一个变量的名称为ids[0],第二个变量的名称为ids[1]。

    以此类推,第100个变量的名称为ids[99],这些变量的初始值都是0。为了更好地理解数组的这种定义方式,可以将上面的一句代码分成两句来写。

    具体如下:

    int[] ids;      // 声明一个int[]类型的变量
    ids = new int[100]; // 创建一个长度为100的数组,并将数组地址赋值给数组类型的变量x
    

    接下来通过两张内存图来详细地说明数组在创建过程中内存的分配情况。

    第一行代码 int[] ids; 声明了一个变量ids,该变量的类型为int[],即一个int类型的数组。变量ids会占用一块内存单元,它没有被分配初始值。此时ids在内存中的状态如图1所示。

    第二行代码 ids = new int[100]; 创建了一个数组,并将数组的内存地址赋值给变量ids。在程序运行期间可以使用变量ids来引用数组,这时内存中的状态会发生变化,如图2所示。

    图2描述了变量ids引用数组的情况。该数组中有100个元素,初始值都为0。数组中的每个元素都有一个索引(也可称为角标),要想访问数组中的元素可以通过“数组名[角标]”的形式,即“ids[0]、…、ids[99]”。

    需要注意的是,数组中最小的索引是0,最大的索引是“数组的长度-1”。在Java中,为了方便获得数组的长度,提供了一个length属性,在程序中可以通过“数组名.length”的方式来获得数组的长度,即数组元素的个数。

    接下来通过一个完整的案例来演示如何定义数组以及访问数组中的元素,如文件1所示。

    文件1 Example18.java

         public class Example18 {
             public static void main(String[] args) {
                 // 1、第一种方式定义数组
                 int[] ids = new int[100];    
                 System.out.println("ids[0]="+ids[0]);   //访问数组第一个元素
                 System.out.println("ids[99]="+ids[99]);//访问数组最后一个元素
                 System.out.println("==============");
                 // 2、第二种方式定义数组
                 String[] names = new String[]{"张三","tom","jack"};  
                 System.out.println("names[0]="+names[0]);     //访问数组第一个元素
                 System.out.println("names[2]="+names[2]);     //访问数组最后一个元素
                 System.out.println("==============");
                 // 3、第三种方式定义数组
                 Object[] object = {"张三","tom","jack"};  
                 System.out.println("数组的长度为:"+object.length);//获取数组的长度
                 System.out.println("object[0]="+object[0]);  //访问数组第一个元素
                 System.out.println("object[2]="+object[2]);  //访问数组最后一个元素
             }
         }
    

    运行结果如图3所示:

    文件1中,分别声明了一个int[]类型、String[]类型和Object[]类型的数组,然后通过“数组名[角标]”的形式获取了数组的第一个和最后一个元素值,并打印到控制台上。从打印结果可以看出,第一种定义数组方式定义的int[]类型的数组中元素的初始值都为0。

    这是因为当数组被成功创建后,数组中元素会被自动赋予一个默认值,根据元素类型的不同,默认初始化的值也是不一样的;而第二种和第三种定义数组方式定义的数组都指定了初始值,所以打印出对应角标的元素值。

    Java中不同数据类型元素的初始值如下表所示:

    在使用数组时,如果不想使用这些默认初始值,可以显式地为这些元素赋值,当然也可以对定义数组时的指定初始值进行修改。接下来对上面的案例进行修改来学习一下如何为数组中的元素赋值和修改,如文件2所示。

    文件2 Example19.java

         public class Example19 {
             public static void main(String[] args) {
                 // 1、第一种方式定义数组
                 int[] ids = new int[100];    
                 System.out.println("ids[0]="+ids[0]);  //访问数组第一个元素
                 // 为数组指定元素进行初始化赋值
                 ids[0] = 2500;
                 System.out.println("ids[0]="+ids[0]); //再次访问数组第一个元素
                 System.out.println("==============");
                 // 2、第二种方式定义数组
                 String[] names = new String[]{"张三","tom","jack"};  
                 System.out.println("names[0]="+names[0]);   //访问数组第一个元素
                 // 为数组定义时指定的初始值进行修改
                 names[0] = "李四";
                 System.out.println("names[0]="+names[0]);   //再次访问数组第一个元素
                 System.out.println("==============");
                 // 3、第三种方式定义数组
                 Object[] object = {"张三","tom","jack"};  
                 System.out.println("object[0]="+object[0]); //访问数组第一个元素
                 // 为数组定义时指定的初始值进行修改
                 object[0] = "李四";
                 System.out.println("object[0]="+object[0]); //再次访问数组第一个元素
             }
         }
    

    运行结果如图4所示:

    文件2中,三种定义数组的方式都使用了“数组名[角标]=元素值”的形式对各数组中指定角标的元素进行了赋值和修改。

    从修改的代码以及程序运行结果可以看出,对数组中的元素进行赋值或修改操作所使用的方式一样,只是在使用“数组名[角标]=元素值”的形式对数组元素进行操作时,如果数组指定角标的元素只有默认初始值,那么就是对元素进行的赋值操作;如果数组指定角标的元素已经有了初始值,那么就是对元素进行的修改操作。

    注意:

    1.每个数组的索引都有一个范围,即0~length-1。在访问数组的元素时,索引不能超出这个范围,否则程序会报错,如文件3所示。

    文件3 Example20.java

         public class Example20 {
             public static void main(String[] args) {
                 int[] arr = new int[4];                     // 定义一个长度为4的数组
                 System.out.println("arr[4]=" + arr[4]); // 通过角标4访问数组元素
             }
         }
    

    运行结果如图3所示:

    从图5可以看出,程序运行后提示了“ArrayIndexOutOfBoundsException”即数组角标越界异常的错误。

    出现这个异常的原因是数组的长度为4,其索引范围为0~3,文件中的第4行代码使用索引4来访问元素时超出了数组的索引范围。所谓异常指程序中出现的错误,它会报告出错的异常类型、出错的行号以及出错的原因。

    2.在使用变量引用一个数组时,变量必须指向一个有效的数组对象,如果该变量的值为null,则意味着没有指向任何数组,此时通过该变量访问数组的元素会出现空指针异常,接下来通过一个案例来演示这种异常,如文件4所示。

    文件4 Example21.java

    public class Example21 {
    public static void main(String[] args) {
    int[] arr = new int[3]; // 定义一个长度为3的数组
                 arr[0] = 5;                  // 为数组的第一个元素赋值
                 System.out.println("arr[0]=" + arr[0]);    // 访问数组的元素
                 arr = null;                 // 将变量arr置为null
                 System.out.println("arr[0]=" + arr[0]);     // 再次访问数组的元素
             }
         }
    

    运行结果如图6所示:

    从图6可以看出,文件4中的第4、5行代码都能通过变量arr正常地操作数组,而在第6行代码将变量置为null后,在第7行代码再次访问数组时就出现了“java.lang.NullPointerException”的异常信息,即空指针异常。

    点赞 · 分享 · 转发

    帮助更多需要的人看到

    · 推荐阅读 ·

    这个「垃圾」问题也能冲上热搜?引得Java大牛在线怒怼...

    2021-04-22

    编程过来人的5点建议,听进去的人离「高薪」更近!

    2021-04-21

    不懂点「黑话」,别说你是混 IT 圈的!

    2021-04-20

    全球最厉害的14位程序员,说没听过简直离谱!

    2021-04-19

    腾讯35岁程序员被裁:存款700万+两套房,无病呻吟带着炫耀?

    2021-04-17

    点个在看,播妞爱你们呦

    展开全文
  • 使用Java定义数组

    千次阅读 多人点赞 2021-12-03 16:34:07
    一维数组和二维数组定义及使用

    目录

    1.数组的创建

    1.1语法

     1.2代码举例

    1.3数组的使用

    2.数组在方法的使用

     2.1基本用法

    2.2引用类型

    3. 数组作为方法的返回值

    3.1传址

     3.2返回一个新的数组

     4.二维数组

    4.1基本语法

     4.2遍历二维数组


    1.数组的创建

    1.1语法

    // 动态初始化
    数据类型 [] 数组名称 = new 数据类型 [] { 初始化数据 };
    // 静态初始化
    数据类型 [] 数组名称 = { 初始化数据 };

     1.2代码举例

    public class TestArray {
        public static void main(String[] args) {
            int [] array = {1,2,3,4,5};
            int [] array2 = new int[3];
            int [] array3 = new int[]{1,2,3};
           
        }
    
    }

    1.3数组的使用

    求数组长度

    public class TestArray {
        public static void main(String[] args) {
            int [] array = {1,2,3,4,5};
    
            System.out.println(array.length);//求数组的长度
            System.out.println(array[2]);//打印,下标从零开始
    
            array[2] = 8;
            System.out.println(array[2]);//给下标为3的数重新赋值
           
        }
    
    }

    遍历数组

    1.for循环,遍历数组
    2.for-each 是for循环的另一种使用方式, 能够更方便的完成对数组的遍历,可以避免循环条件和更新语句写错
    3.借助Java的操作数组的工具类 Arrays.toString  :将参数的数组  以字符串的形式进行输出
    public class TestArray {
        public static void main(String[] args) {
            int [] array = {1,2,3,4,5};
    
              int[] array = {1,2,3,4,5};
    
            //1、for循环
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i]+" ");//遍历数组,即打印数组中的数
            }
            System.out.println();//换行
    
            //2、for -each 
            for (int x: array ) {
                System.out.print(x+" ");
            }
            System.out.println();
    
            //3、字符串形式打印
            System.out.println(Arrays.toString(array));
           
        }
    
    }

    2.数组在方法的使用

     2.1基本用法

    使用方法来遍历数组

    int[] a 是函数的形参 , int[] array  是函数实参 .
    如果需要获取到数组长度 , 同样可以使用 a.length
    public class TestArray {
    
        private static void printf(int[] a) {
            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i]+" ");
            }
            System.out.println();
        }
    
        public static void main(String[] args) {
            int [] array = {1,2,3,4,5};
    
            printf(array);
           
        }
    
    }

    2.2引用类型

    将函数的实参传到方法中的形参,如果形参中某个元素改变,实参也会跟着改变

    如果在方法中new一个新的数组来接收,则地址会改变,如果我们要打印出来的话,是是不会影响到元数组的,即实参不会被影响

    public class TestArray {
    
         public static void func1(int[] array) {
            array = new int[]{3,4,5,2,8};//定义了一个新的数组,地址不一样,
                                          //所以改变不了原本实参的数组
    
        }
        public static void func2(int[] array) {
            array[0]=45;//使用的地址和原本是一样的,所以可以改变实参的数
        }
    
        public static void main(String[] args) {
            int[] array = {1,2,3,4,5};
            System.out.println("原数组:"+Arrays.toString(array));
    
            func1(array);
            System.out.println("定义新数组:"+Arrays.toString(array));
            
            func2(array);
            System.out.println("传形参数组:"+Arrays.toString(array));
        }
    
    }

     

    3. 数组作为方法的返回值

    3.1传址

    写一个数组,将数组的每一个元素加2;因为使用的是传址,在方法中加2时,原来的数组也会改变,这样就破坏了原来的数组。

    public class TestArray {
        public static void add(int[] array) {
        //每个数组元素加2
            for (int i =0; i < array.length; i++) {
                array[i] = array[i] + 2;
            }
        }
       //遍历数组
        public static void printArray(int[] array) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i]+" ");
            }
        }
        //主函数
        public static void main(String[] args) {
            int[] array = {1,2,3,4};
            add(array);
            printArray(array);
        }
    
    }

     

     3.2返回一个新的数组

     new一个新的数组,是引用了原来数组的元素,不是引用原来数组的地址,所以返回的时候知识将这个数组的首元素返回给函数的调用者,没有拷贝数组的内容,从而更高效。

    public class TestArray {
        //new新的数组,并且返回数组
        public static int[] form(int[] array) {
            int[] arr = new int[array.length];
            for (int i = 0; i < array.length; i++) {
                arr[i] = array[i] + 2;
            }
            return arr;
        }
        //遍历新的数组
        public static void print(int[] array) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i]+ " ");
            }
        }
        //主函数
        public static void main(String[] args) {
            int[] array = {1,2,3,4,5};
            int[] put = form(array);
            print(put);
        }
    
    }

     

     4.二维数组

    二维数组本质上也是一个一维数组,只不过每个元素又是一个一维数组

    4.1基本语法

    数据类型 [ ][ ] 数组名称 = new 数据类型 [ 行数 ][ 列数 ] { 初始化数据 };

     4.2遍历二维数组

    public class TestArray {
    
         public static int[][] Array(int[][] array1) {
            int[][] ret = new int[3][3];
            for (int i = 0; i < array1.length; i++) {
                for (int j = 0; j < array1[i].length; j++) {
                    ret[i][j] = array1[i][j];
                }
            }
            return ret;
        }
    
        public static void main(String[] args) {
            int[][] array1 = {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}};
            int[][] array2 = Array(array1);
            for (int i = 0; i < array1.length; i++) {
                for (int j = 0; j < array1[i].length; j++) {
                    System.out.print(array2[i][j]+" ");
                }
                System.out.println();
            }
        }
    }

      

    展开全文
  • java中如何定义数组呢?

    直接上代码和截图 

    public static void main(String[] args) {
    		// 定义数组的3种方式
    		// 第一种
    		String[] role = new String[3];
    		role[0] = "建宁公主";
    		role[1] = "双儿";
    		role[2] = "阿珂";
    		System.out.println(role[0] + "," + role[1] + "," + role[2]);
    
    		// 也可以把[]放在变量名后面,如下:
    		String role2[] = new String[4];
    		role2[0] = "苏荃";
    		role2[1] = "方怡";
    		role2[2] = "曾柔";
    		role2[3] = "沐剑屏";
    		System.out.println(role2[0] + "," + role2[1] + "," + role2[2] + "," + role2[3]);
    		
    		// 第二种
    		int[] score = {88, 66, 89, 73};
    		System.out.println(score[0] + "," + score[1] + "," + score[2] + "," + score[3]);
    		
    		int score2[] = {25, 39, 17, 92};
    		System.out.println(score2[0] + "," + score2[1] + "," + score2[2] + "," + score2[3]);
    
    		// 第三种
    		double[] ratings = new double[]{0.39, 0.76};
    		System.out.println(ratings[0] + "," + ratings[1]);
    		
    		double ratings2[] = new double[]{8.76, 12.93};
    		System.out.println(ratings2[0] + "," + ratings2[1]);
    	}

    运行结果如下:

    展开全文
  • 定义:所谓数组,就是一个有序的元素序列。若将有限个类型相同的元素变量集合命名,那么数组的名就是定义的名称。组成数组的各个变量就是数组的元素,用来区分数组的各个元素的数字编号成为下标 特点: 数组是相同...
  • 之前对Java中的数组一直是一知半解,特别是数组中的长度问题。今天对这个问题也算是小有理解,算是对java数组的有了更进一步的了解吧。不说了,先来例子再说:packagecom.test;publicclassTest{/***@paramargs*/...
  • Java数组定义的三种方式

    千次阅读 2021-04-15 14:13:19
    } } } 结果: java数组复制的两种方式java数组复制有两种方式: 一:System.arraycopy(原数组,开始copy的下标,存放copy内容的数组,开始存放的下标,需要copy的长度); 这个方法需要先创建一个空的存放cop ... ...
  • java定义数组的实现方法(与VB的ReDim相像),需要的朋友可以参考一下
  • Java数组的三种定义方法

    千次阅读 2019-04-30 23:43:59
    Java数组的三种定义方法1.第一种适合不用初始化的数组数组特别长的时候,不初始化,值都是默认值。2.第二种定义适合直接初始化数组3.第三种匿名数组适合直接给方法传入参数时使用 1.第一种适合不用初始化的数组。...
  • 数组是可以在内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问,数组下标从0开始。 优点: 1、按照索引查询元素速度快 2、按照索引遍历数组方便 缺点: 1、数组的大小...
  • 定义数组的时候直接给数组赋值 二、格式 // 完整格式 数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3...}; double [] scores = new double[]{89.9,99.6,45.6,44.0}; int [] ages = new int[]{12,24,35} //...
  • java创建数组时定义数组的长度

    千次阅读 2019-11-21 15:59:22
    直接看案例: Double[] d = new Double[6]; 这里定义了一个double类型的数组,定义数组的长度为6
  • 这时就只能改变数组里的数值而不能改变它的长度了.Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言...
  • JAVA数组定义

    千次阅读 2021-02-12 13:15:23
    JAVA一维数组一,注意不可添加数组元素不可改变数组长度一个数组中的说有元素...2先定义数组长度再添加元素类型[] 数组名 = new 类型[长度];int[] arr=[2];arr[0]=1;arr[1]=2;与此方法类似的int[] arr;arr=new in...
  • Java数组定义与使用

    千次阅读 2022-03-22 15:02:11
    Java数组定义与使用
  • 数组定义 数组:可以存储多个相同数据类型元素的容器 1.数据类型[ ] 数组名=new 数据类型[元素个数/数组长度] int[] arr=new int[3]; // 指定长度 数组类型 名称=初始化; // 定义变量 数组定义分为声明和初始化...
  • Java 定义数组的三种方式,int...x动态参数列表

    万次阅读 多人点赞 2019-03-16 18:04:36
    以 int型 的数组为例,说说三种定义方式
  • Java数组定义与使用

    千次阅读 2021-02-26 13:30:55
    格式数据类型[] 数组名=new 数据类型[元素个数]"数据类型"表示该数组中可以存放哪一类型的数据"[]" 表示当前变量的数据类型为数组类型"元素个数" 限制了当前数组中可以存放的数据个数创建数组时,java系统自动设置...
  • Java数组定义与使用

    千次阅读 2021-09-26 14:46:21
    Java定义数组的语法有两种:    type arrayName[];    type[] arrayName;type 为Java中的任意数据类型,包括基本类型和组合类型,arrayName为数组名,必须是一个合法的标识符,[ ] 指明...
  • Java数组定义与使用(一)

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

    万次阅读 多人点赞 2017-11-16 08:55:15
    三种定义数组的格式如下:int[] arr1=new int[10]; int[] arr2={1,2,3,6}; int[] arr3=new int[]{1,2,3,4,5,6,7,22}; 注意:数组的length是一个属性,而字符串的length()是一个方法了!!!虽然都是求的他们各自的...
  • java数组怎么定义java数组定义方法

    千次阅读 2022-04-20 16:24:58
    有时候我们在学习java编程的时候,想定义数组,但是不知道怎么处理,或者忘记了,java数组怎么定义?本篇来简单回答一下这个问题。 本教程操作环境:windows7系统、java10版,DELL G3电脑。 1、说明 数组是同类...
  • Java数组定义方式有哪几种

    千次阅读 2019-09-09 17:30:27
    今天动力节点java培训机构小编为大家分享Java数组定义方式有哪几种,希望通过此文,大家能够熟知java数组定义方式,下面就是小编一起看看Java数组定义方式有哪几种呢? Java数组定义方式一  动态方式...
  • java数组的三种定义方式

    万次阅读 2018-07-03 20:46:13
    public class WhatEver { public static void main(String[] args) { //第一种 例: String[] test1 = new String[6]; test1[0] = "数组0"; test1[1] = "数组1"; //第二种 例: ...
  • Java对象数组定义与用法详解

    千次阅读 2021-03-04 02:08:39
    本文实例讲述了Java对象数组定义与用法。分享给大家供大家参考,具体如下:所谓的对象数组,就是指包含了一组相关的对象,但是在对象数组的使用中一定要清楚一点:数组一定要先开辟空间,但是因为其是引用数据类型,...
  • (1)如何声明定义一个一维数组 int [] array1; double [] array2; boolean [] array3; string [] array4; object [] array5; (2)怎么初始化一个一维数组? (a)静态初始化 int [] array = {1,2,3,4}; 注意:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 773,174
精华内容 309,269
关键字:

java定义数组的方式

java 订阅