精华内容
下载资源
问答
  • java数组 初始化_用Java初始化数组

    千次阅读 2020-07-14 21:45:19
    java数组 初始化 具有使用C或FORTRAN等语言进行编程的经验的人熟悉数组的概念。 它们基本上是一个连续的内存块,每个位置都是某种类型:整数,浮点数或您所拥有的。 Java中的情况与此类似,但有一些额外的折痕。 ...

    java数组 初始化

    具有使用C或FORTRAN等语言进行编程的经验的人熟悉数组的概念。 它们基本上是一个连续的内存块,每个位置都是某种类型:整数,浮点数或您所拥有的。

    Java中的情况与此类似,但有一些额外的折痕。

    一个例子数组

    让我们用Java制作一个由10个整数组成的数组:

    
       
    int [ ] ia = new int [ 10 ] ;

    上面的代码是怎么回事? 从左到右:

    1. 最左边的int []将变量的类型声明为int的数组(由[]表示)。

    2. 右边是变量的名称 ,在这种情况下为ia

    3. 接下来, =告诉我们,左侧定义的变量设置为右侧的变量。

    4. = =的右边,我们看到了单词new ,它在Java中表示一个对象正在初始化 ,这意味着将分配存储并调用其构造函数( 有关更多信息,请参见此处 )。

    5. 接下来,我们看到int [10] ,它告诉我们正在初始化的特定对象是10个整数的数组。

    由于Java是强类型的,因此变量ia的类型必须与=右侧的表达式的类型兼容。

    初始化示例数组

    让我们将此简单数组放入一段代码中,然后尝试一下。 将以下内容保存在一个名为Test1.java的文件中,使用javac进行编译,然后使用java运行它(当然在终端中):

    
       
    import java.lang.* ;

    public class Test1 {

        public static void main ( String [ ] args ) {
            int [ ] ia = new int [ 10 ] ;                               // See note 1 below
            System . out . println ( "ia is " + ia. getClass ( ) ) ;         // See note 2 below
            for ( int i = 0 ; i < ia. length ; i ++ )                   // See note 3 below
                System . out . println ( "ia[" + i + "] = " + ia [ i ] ) ;   // See note 4 below
        }

    }

    让我们来研究最重要的部分。

    1. 我们很容易发现和声明10个整数ia的数组。
    2. 在下面的行中,我们看到表达式ia.getClass() 。 是的, ia是属于class对象 ,并且此代码将使我们知道是哪个类。
    3. 在此之后的下一行中,我们看到(int i = 0; i <ia.length; i ++)的循环的开始,该循环定义了循环索引变量i ,该变量的序列范围是从零到小于ia的一个。 length ,它是一个表达式,它告诉我们数组ia中定义了多少个元素。
    4. 接下来,循环的主体将输出ia的每个元素的值。

    编译并运行该程序时,将产生以下结果:

    
       
    me @ mydesktop:~ / Java$ javac Test1.java
    me @ mydesktop:~ / Java$ java Test1
    ia is class [ I
    ia [ 0 ] = 0
    ia [ 1 ] = 0
    ia [ 2 ] = 0
    ia [ 3 ] = 0
    ia [ 4 ] = 0
    ia [ 5 ] = 0
    ia [ 6 ] = 0
    ia [ 7 ] = 0
    ia [ 8 ] = 0
    ia [ 9 ] = 0
    me @ mydesktop:~ / Java$

    ia.getClass()输出的字符串表示形式为[I ,它是“整数数组”的简写。 与C编程语言类似,Java数组从元素零开始,一直扩展到元素<array size> – 1 。 我们可以在上面看到ia的每个元素都设置为零(似乎是通过数组构造函数)。

    那是吗? 我们声明类型,使用适当的初始化程序,我们完成了吗?

    好吧,不。 还有许多其他方法可以用Java初始化数组。

    为什么我要初始化一个数组?

    在某些情况下,数组自然会作为一种累加器出现。 例如,假设我们正在编写代码以计算小型办公室中一组电话分机接收和拨打的电话数量。 有八个分机,编号为1到8,加上话务员的分机,编号为零。 因此,我们可以声明两个数组:

    
       
    int [ ] callsMade ;
    int [ ] callsReceived ;

    然后,每当我们开始一个新的累积呼叫统计数据的周期时,我们就将每个数组初始化为:

    
       
    callsMade = new int [ 9 ] ;
    callsReceived = new int [ 9 ] ;

    在每个累积呼叫统计数据的阶段结束时,我们可以打印出统计数据。 粗略地说,我们可能会看到:

    
       
    import java.lang.* ;
    import java.io.* ;

    public class Test2 {

        public static void main ( String [ ] args ) {

            int [ ] callsMade ;
            int [ ] callsReceived ;

            // initialize call counters

            callsMade = new int [ 9 ] ;
            callsReceived = new int [ 9 ] ;

            // process calls...
            //   an extension makes a call: callsMade[ext]++
            //   an extension receives a call: callsReceived[ext]++

            // summarize call statistics

            System . out . printf ( "%3s%25s%25s \n " , "ext" , " calls made" ,
                "calls received" ) ;
            for ( int ext = 0 ; ext < callsMade. length ; ext ++ )
                System . out . printf ( "%3d%25d%25d \n " ,ext,
                    callsMade [ ext ] ,callsReceived [ ext ] ) ;

        }

    }

    这将产生如下输出:

    
       
    me @ mydesktop:~ / Java$ javac Test2.java
    me @ mydesktop:~ / Java$ java Test2
    ext               calls made           calls received
      0                         0                         0
      1                         0                         0
      2                         0                         0
      3                         0                         0
      4                         0                         0
      5                         0                         0
      6                         0                         0
      7                         0                         0
      8                         0                         0
    me @ mydesktop:~ / Java$

    呼叫中心不是很忙的一天。

    在上面的累加器示例中,我们看到由数组初始化程序设置的零起始值可以满足我们的需求。 但是在其他情况下,此起始值可能不是正确的选择。

    例如,在某些几何计算中,我们可能需要将二维数组初始化为单位矩阵(除沿主对角线的那些零以外的所有零)。 我们可以选择这样做:

    
       
      double [ ] [ ] m = new double [ 3 ] [ 3 ] ;
            for ( int d = 0 ; d < 3 ; d ++ )
                m [ d ] [ d ] = 1.0 ;

    在这种情况下,我们依靠数组初始化器new double [3] [3]将数组设置为零,然后使用循环将对角元素设置为1。 在这种简单情况下,我们可以使用Java提供的快捷方式:

    
       
      double [ ] [ ] m = {
              { 1.0 , 0.0 , 0.0 } ,
              { 0.0 , 1.0 , 0.0 } ,
              { 0.0 , 0.0 , 1.0 } } ;

    这种视觉结构特别适合此类应用程序,在这种情况下,仔细检查数组的实际布局可能会很有用。 但是在仅在运行时确定行数和列数的情况下,我们可能会看到如下所示:

    
       
      int nrc ;
      // some code determines the number of rows & columns = nrc
      double [ ] [ ] m = new double [ nrc ] [ nrc ] ;
      for ( int d = 0 ; d < nrc ; d ++ )
         m [ d ] [ d ] = 1.0 ;

    值得一提的是,Java中的二维数组实际上是数组的数组,没有什么能阻止无畏的程序员让这些第二级数组中的每个数组都具有不同的长度。 也就是说,这样的事情是完全合法的:

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

    有许多涉及不规则形状矩阵的线性代数应用,可以在其中应用这种类型的结构(有关更多信息,请参阅此Wikipedia文章作为起点)。 除此之外,既然我们了解到二维数组实际上是数组的数组,那么以下内容也就不足为奇了:

    
       
    differentLengthRows. length

    告诉我们二维数组differentLengthRows中的行数,以及:

    
       
    differentLengthRows [ i ] . length

    告诉我们differentLengthRows的i行中的列数。

    使阵列更进一步

    考虑到在运行时确定数组大小的想法,我们看到数组在实例化它们之前仍需要我们知道该大小。 但是,如果在处理完所有数据之前不知道大小怎么办? 这是否意味着我们必须处理一次以找出数组的大小,然后再次处理? 这可能很难做到,尤其是如果我们只有一次机会使用数据时。

    Java Collections Framework很好地解决了这个问题。 所提供的功能之一是ArrayList类,它类似于一个数组,但可以动态扩展。 为了演示ArrayList的工作原理,让我们创建一个并将其初始化为前20个斐波纳契数

    
       
    import java.lang.* ;
    import java.util.* ;

    public class Test3 {
           
            public static void main ( String [ ] args ) {

                    ArrayList < Integer > fibos = new ArrayList < Integer > ( ) ;

                    fibos. add ( 0 ) ;
                    fibos. add ( 1 ) ;
                    for ( int i = 2 ; i < 20 ; i ++ )
                            fibos. add ( fibos. get ( i - 1 ) + fibos. get ( i - 2 ) ) ;

                    for ( int i = 0 ; i < fibos. size ( ) ; i ++ )
                            System . out . println ( "fibonacci " + i +
                            " = " + fibos. get ( i ) ) ;

            }
    }

    在上方,我们看到:

    • 用于存储IntegerArrayList的声明和实例化。
    • 使用add()追加到ArrayList实例。
    • 使用get()通过索引号检索元素。
    • 使用size()确定ArrayList实例中已经有多少个元素。

    put()方法未显示,该方法将值放置在给定的索引号处。

    该程序的输出为:

    
       
    fibonacci 0 = 0
    fibonacci 1 = 1
    fibonacci 2 = 1
    fibonacci 3 = 2
    fibonacci 4 = 3
    fibonacci 5 = 5
    fibonacci 6 = 8
    fibonacci 7 = 13
    fibonacci 8 = 21
    fibonacci 9 = 34
    fibonacci 10 = 55
    fibonacci 11 = 89
    fibonacci 12 = 144
    fibonacci 13 = 233
    fibonacci 14 = 377
    fibonacci 15 = 610
    fibonacci 16 = 987
    fibonacci 17 = 1597
    fibonacci 18 = 2584
    fibonacci 19 = 4181

    ArrayList实例也可以通过其他技术进行初始化。 例如,可以将数组提供给ArrayList构造函数,或者在编译时知道初始元素时,可以使用List.of()Arrays.asList()方法。 我发现自己并没有经常使用这些选项,因为ArrayList的主要用例是我只想读取一次数据。

    而且,对于那些喜欢在数据加载后就使用数组的人,可以使用其ArrayList实例的toArray()方法将其转换为数组。 或者,在初始化ArrayList实例后返回当前主题。

    Java Collections Framework提供了另一种类似于数组的数据结构,称为Map 。 我所说的“类似数组”是指Map定义了一个对象集合,这些对象的值可以通过键设置或检索,但与数组(或ArrayList )不同的是,该键不必是整数。 它可以是String或任何其他复杂对象。

    例如,我们可以创建一个Map,其键为String ,其值为Integer ,如下所示:

    
       
    Map < String ,Integer > stoi = new Map < String ,Integer > ( ) ;

    然后,我们可以按如下方式初始化此Map

    
       
    stoi. set ( "one" , 1 ) ;
    stoi. set ( "two" , 2 ) ;
    stoi. set ( "three" , 3 ) ;

    等等。 稍后,当我们想知道“ three”的数值时,可以将其检索为:

    
       
    stoi. get ( "three" ) ;

    在我的世界中, 地图可用于将第三方数据集中出现的字符串转换为我的数据集中的一致代码值。 作为数据转换管道的一部分,我通常会构建一个小型独立程序,以在处理数据之前对其进行清理。 为此,我几乎总是使用一个或多个Map

    值得一提的是,拥有ArrayListsArrayListsMapMap很有可能,有时甚至是合理的。 例如,假设我们正在看树,并且对按树种和年龄范围累加树数的计数感兴趣。 假设年龄范围定义是一组字符串值(“年轻”,“中”,“成熟”和“旧”),并且该种类是诸如“道格拉斯冷杉”,“西部红柏”和“等等,那么我们可以定义一个地图 S作为的:

    
       
    Map < String ,Map < String ,Integer >> counter =
            new Map < String ,Map < String ,Integer >> ( ) ;

    这里需要注意的一件事是,以上内容仅为Map创建存储。 因此,我们的累积代码可能类似于:

    
       
    // assume at this point we have figured out the species
    // and age range
    if ( ! counter. containsKey ( species ) )
            counter. put ( species, new Map < String ,Integer > ( ) ) ;
    if ( ! counter. get ( species ) . containsKey ( ageRange ) )
            counter. get ( species ) . put ( ageRange, 0 ) ;

    在这一点上,我们可以开始累积为:

    
       
    counter. get ( species ) . put ( ageRange,
            counter. get ( species ) . get ( ageRange ) + 1 ) ;

    最后,值得一提的是(Java 8中的新增功能)Streams工具还可用于初始化数组, ArrayList实例和Map实例。 有关此功能的详细讨论可以在此处此处找到。

    翻译自: https://opensource.com/article/19/10/initializing-arrays-java

    java数组 初始化

    展开全文
  • Java数组初始化

    千次阅读 2019-05-06 22:34:32
    1.Java数组初始化的两种方法: 静态初始化:程序员在初始化数组时为数组每个元素赋值; 动态初始化:数组初始化时,程序员只指定数组的长度,由系统为每个元素赋初值。 Java数组是一种引用数据类型。数组...

    1.Java 数组初始化的两种方法:    

        静态初始化: 程序员在初始化数组时为数组每个元素赋值;

        动态初始化: 数组初始化时,程序员只指定数组的长度,由系统为每个元素赋初值。

     

      Java数组是一种引用数据类型。数组变量并不是数组本身,而是指向堆内存中存放的数组对象。因此,可以改变一个数组变量所引用的数组。

    2.数组是否必须初始化

        对于这个问题,关键在于要弄清楚数组变量和数组对象的差别。数组变量是存放在栈内存中的,数组对象是存放在堆内存中的。数组变量只是一个引用变量,他能够指向实际的数组对象。

        所谓的数组初始化并非对数组变量初始化,而是对数组对象进行初始化。

    展开全文
  • JAVA数组初始化

    万次阅读 2018-05-24 15:56:15
    JAVA数组初始化主要有两种方式,如下: dataType[] arrayRefVar;或者dataType arrayRefVar[]; 其中dataType可以是java支持的八中数据类型的任意一种,前者为首选方法; 通常用法如下: 创建一个包含n个元素的...

    JAVA数组初始化主要有两种方式,如下:
    dataType[] arrayRefVar;或者dataType arrayRefVar[];
    其中dataType可以是java支持的八中数据类型的任意一种,前者为首选方法;
    通常用法如下:

    1. 创建一个包含n个元素的数组对象:double[] list = new double[n];//此为动态初始化

    2. 初始化一个固定内容的数组:

    double[] list = {1, 29, 34, 35};//静态初始化的简化版
    double[] list = new double[]{1, 29, 34, 35};//此为静态初始化

    需要注意的是数组的长度是固定的,不管是何种初始化方式;
    如果要初始化一个空数组,则必须使用动态初始化方式为其赋予长度,如下:

    double[] list;
    list = new double[3];

    而后再进行赋值;

    展开全文
  • 1.Java数组是静态的 Java是静态语言,所以Java的数组也是静态的,即:数组被初始化后,长度不可变 静态初始化:显式指定每个数组元素的初始值,系统决定数组长度 String[] books = new String[]{"疯狂Java讲义",...

    1.Java数组是静态的

    Java是静态语言,所以Java的数组也是静态的,即:数组被初始化后,长度不可变

    静态初始化:显式指定每个数组元素的初始值,系统决定数组长度

    String[] books = new String[]{"疯狂Java讲义","Thinking in Java","Java核心技术卷"};
    String[] names = new String[]{"张三","李四","王五","赵六"};

    动态初始化:显式指定数组的长度,系统决定每个数组元素的初始值

    String[] strArr = new String[5];

    以上两种初始化的内存使用情况如图所示:

    动态初始化数组由系统决定每个数组元素的初始值,遵循以下规则:

    • byte、short、int、long类型的数组的初始值为0
    • float、double类型的数组的初始值为0.0
    • char类型的数组的初始值为'\u0000',表现为空字符'',但要占位
    • boolean类型的数组的初始值为false
    • 引用类型的数组的初始值为null

    一旦数组初始化完成,则长度不可改变,以下代码造成了数组初始化后长度可改变的假象:

    books = names;
    strArr = books;
    System.out.println(books.length); // 4
    System.out.println(strArr.length); // 4

    Java的数组变量是一种引用类型的变量,数组变量并不是数组本身,它只是指向堆内存中的数组对象,改变一个数组变量所引用的数组,可以造成数组长度可变的假象。

    上述代码让books数组变量和strArr数组变量都指向了names数组变量引用的数组,这样做的结果就是让三个数组变量都引用了相同的数组对象。内存图如下:

    而原来strArr和books引用的数组对象的长度不会改变,由于已经没有变量引用它们,它们成为垃圾,等待垃圾回收机制来回收。此时,程序使用strArr、books、和names这三个变量时,将会访问同一个数组对象。

    JavaScript是动态语言,其数组的长度可以改变

    <script type="text/javascript">
        var arr = [];
        document.write("arr的长度为:" + arr.length + "<br>"); // 0
        arr[0] = 1;
        document.write("arr的长度为:" + arr.length); // 1
    </script>

    2. 数组一定要初始化吗?

    实际上,懂得了Java数组的内存机制后,我们可以说:数组不是必须初始化,或者说,数组初始化不仅有之前介绍的两种方法,可以完全换一种方法:

    int[] nums = new int[]{1, 2, 3, 4, 5};
    int[] arr;
    arr = nums;

    对于数组对象来说,必须初始化,也就是为该数组对象分配一块连续的内存空间,连续内存空间的长度就是数组对象的长度。
    对于数组变量来说,不需要进行初始化,只需让其指向一个有效的数组对象就可以。
    实际上,所有引用类型的变量,其变量本身不需要任何初始化,需要初始化的是它所引用的对象。

    3. 基本类型数组的初始化

    程序直接先为数组分配内存空间,再将数组元素的值存入对应的内存中。

    int [] nums;   ①
    System.out.println(nums);   ②
    nums = new int[]{1, 2, 3, 4};   ③
    System.out.println(nums.length);    ④

    我们来分析①-④步的内存:

    ① 定义nums数组变量后的存储示意图如下:

    对于②行代码来说没有任何问题,虽然nums变量并未引用到有效的数组对象,但此时并未通过nums变量访问数组对象的方法或属性,所以没有问题。

    ③ 静态初始化nums数组后的存储示意图如下:

    对于④行代码来说,此时访问了nums数组对象的属性,所以要求nums必须引用一个有效的对象。

    当通过引用变量来访问实例属性或者调用非静态方法时,如果该引用变量还未指向有效的对象,程序就会抛出运行时异常:NullPointerException,例如,第二行代码如果为:
    System.out.println(nums.length);
    就会抛出NullPointerException

    误区:基本类型的数据的值存储在栈内存中
    实际上,应该是所有的局部变量都保存在栈内存中,不管是基本类型还是引用类型,局部变量都保存在各自的方法栈中

    4. 引用类型数组的初始化

    引用类型数组的数组元素仍然是引用类型,因此数组元素里存储的还是引用,它指向另一块内存,这块内存里存储了该引用变量所引用的对象,包括数组和Java对象。

    下面程序的执行代表了引用类型数组初始化的典型过程:

    class Person{
        String name;
        int age;
        public void info(){
            System.out.println("name:" + name + ", age:" + age);
        }
    }
    
    // 创建两个Person对象
    Person p1 = new Person();
    p1.name = "张三";
    p1.age = 20;
    Person p2 = new Person();
    p2.name = "李四";
    p2.age = 30;
            
    // 将两个Person对象赋给数组元素
    person[0] = p1;
    person[1] = p2;     
            
    // 结果一样,p1和person[0]指向同一个对象
    p1.info();
    person[0].info();

    分析内存:

    5. 数组元素就是变量

    当数组引用变量指向一个有效的数组对象之后,程序就可以通过该数组变量访问数组对象。
    Java语言不允许直接访问堆内存中的对象,因此无法直接访问堆内存中的数组对象,程序将通过数组引用变量来访问数组对象。
    Java语言避免直接访问堆内存可以使程序更加健壮,如果程序直接访问并修改堆内存中的数据,可能破坏内存的数据完整性,从而导致程序Crash。
    无论哪种类型的数组,其数组元素其实相当于一个普通变量。

    下面程序师范了将数组元素和普通变量相互赋值的情形:

    class Cat{
        String name;
        double height;
        
        public Cat(String name, double height){
            this.name = name;
            this.height = height;
        }
        public void info(){
            System.out.println("name:" + name + ", height:" + height);
        }
    }
    
    public class TestArray {
        public static void main(String[] args) {
            int[] a = new int[5];
            for(int i=0; i<a.length; i++){
                a[i] = ++i;
            }
            int x = a[0];
            int y = 99;
            a[4] = 99;
            
            Cat[] cats = new Cat[2];
            cats[0] = new Cat("咪咪", 10.0);
            cats[1] = new Cat("卡卡", 12.2);
            Cat c1 = cats[0];
            Cat c2 = new Cat("豆豆", 11.1);
            cats[1] = c2;
        }
    }

    内存分析:

    6. 没有多维数组

    所谓多维数组,其实只是数组元素元素依然是数组的数组,1维数组的数组元素的基本类型或者引用类型,2维数组的数组元素是1维数组,3维数组的数组元素是2维数组...N维数组的数组元素是N-1维数组。
    Java允许将多维数组当成1维数组来处理,初始化多维数组时可以先初始化最左边的维数,此时该数组的每个数组元素都相当于一个数组引用变量,这些数组还需要进一步初始化。

    如下程序示范了多维数组的用法:

    public static void main(String[] args) {
        int[][] a;
        a = new int[4][];
        // 把a当成一维数组,遍历a数组的每个数组元素
        for(int i=0; i<a.length; i++){
              System.out.println(a[i]); // 输出都为null
        }
                
        a[0] = new int[2];
        a[0][1] = 2;
        for(int i=0; i<a[0].length; i++){
              System.out.println(a[0][i]); // 输出0和2
        }
    }
    

    内存分析:

    说明:一般我们认为通过数组的length属性可以获取数组的长度,其实这个说法不够准确,例如数组a,它是一个传统的“二维数组”,它的长度好像定义不是很明确,其实,数组的长度指的是数组所分配的连续内存空间的长度,所以说a数组的长度为4.

    我们用一个“极端”的程序来更好的理解数组在内存中的分配机制:

    public static void main(String[] args) {
         Object[] objArr1 = new Object[3];
         objArr1[1] = new Object[2];
         Object[] objArr2 = (Object[]) objArr1[1];
         objArr2[1] = new Object[3];
         Object[] objArr3 = (Object[]) objArr2[1];
         objArr3[1] = new int[5];
         int[] iArr = (int[]) objArr3[1];
         for(int i=0; i<iArr.length; i++){
             iArr[i] = ++i;
         }
    }

    内存分析:

    此时的objArr1不再是一个简单的一维数组,它是一个四维数组。
    最后我们执行如下语句:

    System.out.println(((int[])((Object[])((Object[])objArr1[1])[1])[1])[2]);

    通过以上内存分析不难得出结果为3.

    通过上面的分析不难得出,多维数组的本质仍然是一维数组

    因为Java是强类型语言,所以上诉代码需要多次强制类型转化,如果用弱类型语言实现会简单很多,比如用JavaScript实现:

    <script type="text/javascript">
         var objArr1 = [];
         objArr1[1] = [];
         var objArr2 = objArr1[1];
         objArr2[1] = [];
         var objArr3 = objArr2[1];
         objArr3[1] = [];
         var iArr = objArr3[1];
         for(var i=0; i<5; i++){
              iArr[i] = i;
         }
         document.write(objArr1[1][1][1][2]);
    </script>
    

     

    展开全文
  • Java数组初始化长度

    千次阅读 2020-06-04 11:22:29
    巴拉巴拉小魔仙:肯定是要先声明数组长度,不然系统不会为他分配内存空间。...火箭队喵:java数组长度必须在初始化时给定,长度不可变 第一种 1.先声明 2.分配空间 3.赋值 int[] arr; //先声明 arr
  • java数组在编程中非常常见,一般我们使用数组有如下几种方式: Object [] obj = new Object[10]; Object [] obj = {}; Object [] obj = new Object[]{}; 大部分声明数组就是这三种方式,还有一些特殊的创建方式,...
  • 文章目录1 数组定义与初始化基本方式2 Array 工具类3 Stream 方式4 Arrays 1 数组定义与初始化基本方式 数组定义的两种基本方式...内存空间在数组初始化时分配: int[][] a1 = new int[2][3]; int a2[][] = new int[...
  • 文章目录Java数组相关知识数组初始化一维数组二维数组数组输出一维数组二维数组 Java数组相关知识 数组初始化 一维数组 初始化为0 int[] a; a = new int[5]; int[] b = new int[5]; 初始化为指定值 int[] a = new ...
  • 首先因为数组初始化要使用的时候必须确定数组的长度,也就是说数组的长度是不可变的。 在JAVA中创建数组有两种方式 : (1)静态创建如 Object[] arr1 = {"a","b","c"}; (2)动态创建如 1 Object[] arr3 =new...
  • java数组初始化

    千次阅读 2019-01-16 19:31:49
    package equality; public class demo5 { public static void main(String[] args){ int[] a1={1,2,3,4,5...//将a1的数组赋给a2两者指向同一个数组。 for(int i=0;i&lt;a2.length;i++){ a2[i]=a2[i]+1;...
  • java数组初始化以及数组拷贝

    千次阅读 2017-03-20 18:19:54
    //这里创建了一个可以存储100个整数的数组,当创建数值数组时,所有的元素都被初始化为0,boolean数组初始化为false,对象数组初始化为null值 2.数组的初始化  int[] a = {2,4,5,7,8};//数组的长度由
  • java 数组初始化注意事项

    千次阅读 2017-05-25 02:22:53
    ) 首先因为数组初始化要使用的时候必须确定数组的长度,也就是说数组的长度是不可变的。 在JAVA中创建数组有两种方式 : (1)静态创建 如 Object[] arr1 = {"a","b","c"}; (2)动态创建 如 1 Object[] arr3 =...
  • PAGE / NUMPAGES 动态初始化创建数组时由系统默认地为数组中的元素赋初值你指定数组长度 静态初始化创建数组时程序员显式地为数组中的元素赋初值你不指定数组长度 数组的隐式初始化因为数组是引用类型它的元素相当于...
  • java数组初始化及内存分析

    千次阅读 2015-09-29 09:40:30
    数组:相同类型的、用一个标识符名封装到一起是一个对象序列或基本类型数据序列。 一维数组的声明:1 int[ ] a1; 2 int a1[ ] 两种格式含义一样,第二种符合c和c++程序员的习惯。...初始化的时候可以指定大小。 Ja
  • 1.数组元素的类型是基本类型中的整数类型(byte、short、int和long),则数组元素的值是0。 2.数组元素的类型是基本类型中的浮点类型(float、double),则数组元素的值是0.0。 3.数组元素的类型是基本类型...
  • java代码-JAVA中String数组初始化,一维数组和二维数组初始化
  • 1.定义数组直接赋值 int a[]= {1,2,3,4,5}; 2.用new在数组中创建元素 ...注意:基本类型会自动初始化为空值,int型则为0.输出结果为[0, 0, 0],Arrays.toString产生一维数组的可打印版本。 4.先声明再赋值 int c
  • java数组初始化与初始值

    千次阅读 2013-11-08 21:30:24
    初始化是为数组对象的元素分配内存空间,并为每个数组元素指定初始值。...java语言是典型的静态语言,因此数组是静态的,即是当数组初始化后,该长度是不可变的。 在java中,当执行动态初始化时,系统将为数
  • Java数组进行初始化

    2019-10-29 15:48:36
    Java数组初始化有两种:静态初始化和动态初始化 静态初始化 静态初始化:初始化的时候为每个数组元素指定初始值,有系统决定数组的长度。 格式: eg:int[] b=new int[]{1,2,3}; 动态初始化 动态初始化:初始时...
  • java对象数组 创建对象数组初始化对象数组

    万次阅读 多人点赞 2019-07-30 16:34:15
    对象数组的定义与一般数组的定义类似,但是需要为每一个元素实例。 对象数组的声明形式是: 类名 对象数组名 [ ]; 为对象数组分配内存空间: 对象数组名=new 类名[数组长度];//注意 :此处不是构...
  • java数组初始化详解

    2012-12-15 18:41:01
    java 数组初始化 详解 doc
  • java数组初始化

    2019-07-09 15:41:49
    一:数组的动态初始化java运行过程 1:数组的动态初始化,只指定数组长度,初始值由系统提供默认值 2:学习java的运行能加深我们对代码的理解。 java程序为了提高程序效率,就对数据进行了不同空间的分配。具体...
  • Java数组默认初始化

    2019-10-26 11:18:32
    默认初始化: 整型:0 浮点型:0.0 char型:0或’\u0000’,不是’0’ boolean型:false 引用数据类型:null
  • 转载:https://zhidao.baidu.com/question/1959001009392056060.html?qbl=relate_question_1&amp;word=java��byte�����÷�
  • Java基础(五):Java数组声明与初始化

    千次阅读 2021-01-04 11:31:27
    Java语言中数组必须先初始化,然后才可以使用。 初始化就是为数组的数组元素分配内存空间,并为每个数组元素附初始值。 注意:数组完成初始化后,内存空间中针对该数组的各个元素就有个一个默认值: 基本数据...
  • 主要介绍了Java编程中二维数组初始化和基本操作实例,是Java入门学习中的基础知识,需要的朋友可以参考下
  • java 数组默认初始化

    万次阅读 2017-06-15 02:07:09
    java 在声明了一个数组,并为其分配好存储空间后,未赋值之前会默认对其初始化: 整形数组 默认初始值为0; 布尔数组默认初始值为 false; String 数组以及 对象数组初始值为 null.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 431,108
精华内容 172,443
关键字:

java数组初始化

java 订阅