精华内容
下载资源
问答
  • 一维数组的初始化

    2019-08-03 20:51:26
    数组初始化分类 数组初始化分为动态初始化和静态初始化。 动态初始化: ...将数组的定义和数组的初始化分开来进行。 int[] array1 = new int[3]; array1 = {1,2,3,} 注意: ①.所谓初始...

    数组初始化分类

    数组初始化分为动态初始化和静态初始化。

    静态初始化:

    在定义数组的时候就对该数组进行初始化。

    int[] array = new int[]{23,34,45,56};

    分步写:

    int[] array;
    第一步还可以写为:int array[];两种方式都可以

    array = new int[]{23,34,45,56};
    第二步黑体部分可以省略,注意别忘记大括号后面的分号。

    动态初始化:

    将数组的定义和数组的初始化分开来进行。

    // 等号后面的[ ]内必须写上数组的长度
    int[] array1 = new int[3];
    array1[0] = 1;
    array1[2] = 2;
    array1[3] = 3;
    

    注意:
    ①.所谓初始化就是为数据对象或变量赋初值的做法,但引用数据类型有初值,如null,0等,数组的初值为0。
    ②.

    	 array1 = new int[]{2,3,4,2};
         System.out.println(array1[4]);
    

    这个错误不会报告错误,但运行时会出错。
    ③.
    int[] numbers = new int[3] {};
    在提供数组初始化器时不能定义维度表达式,不能同时写[3]里的数字{},两者只能选其一写。

    展开全文
  • 哈喽,继续记录我的学习心得。30 岁的老工程师能做到每天坚持学习,你还抱怨没时间学习吗?一、每天一点C / 一维数组的初始化正文目录:1.用以逗号分隔的值列表来初始化数组 2.把数组...

    哈喽,继续记录我的学习心得。

    30 岁的老工程师能做到每天坚持学习,你还抱怨没时间学习吗?


    一、每天一点C / 一维数组的初始化

    正文目录:

    1. 用以逗号分隔的值列表来初始化数组
    2. 把数组设置为只读
    3. 忘记初始化数组
    4. 部分初始化数组
    5. 让编译器自动推导数组大小
    6. 指定初始化器 (designated initializer )
    

    运行环境:

    • Ubuntu 16.04

    • gcc version 5.4.0

    1. 以逗号分隔的值列表来初始化

    演示 demo:

    #include <stdio.h>
    #define MONTHS 12
    int main(void)
    {
        int days[MONTHS] = {31,28,31,30,31,30,31,31,30,31,30,31};
        int index;
        
        for (index = 0; index < MONTHS; index++)
            printf("Month %d has %2d days.\n", index +1, days[index]);
        
        return 0;
    }
    

    运行效果:

    $ gcc day_mon1.c -o day_mon
    $ ./day_mon 
    Month 1 has 31 days.
    Month 2 has 28 days.
    ...
    Month 12 has 31 days.
    

    相关要点:

    • MONTHS 是符号常量,使用符号常量表示数组大小,是推荐做法

    2. 把数组设置为只读

    要创建只读数组,可以用 const。

    演示 demo:

    #define MONTHS 12
    int main(void)
    {
        const int days[MONTHS] = {31,28,31,30,31,30,31,31,30,31,30,31};
        days[1] = 29; // ERROR
        return 0;
    }
    

    运行效果:

    $ gcc const_array.c -o const_array
    const_array.c: In function ‘main’:
    const_array.c:6:13: error: assignment of read-only location ‘days[1]’
         days[1] = 29; // ERROR
    

    3. 忘记初始化数组

    演示 demo:

    #define SIZE 4
    int main(void)
    {
        int no_data[SIZE];  /* uninitialized array */
        int i;
        
        printf("%2s%14s\n",
               "i", "no_data[i]");
        for (i = 0; i < SIZE; i++)
            printf("%2d%14d\n", i, no_data[i]);
        
        return 0;
    }
    

    运行效果:

    $ gcc no_data.c -o no_data
    $ ./no_data
     i    no_data[i]
     0       4195872
     1             0
     2       4195488
     3             0
    

    相关要点:

    • 打印的是内存相应位置上的现有值。

    • 可以把数组创建成不同的存储类别 (storage class),例如auto / static。上述结论仅适用于 auto 变量,即在函数内部声明,且声明时未使用关键字 static 的变量。

    4. 部分初始化数组

    演示 demo:

    #define SIZE 4
    int main(void)
    {
        int some_data[SIZE] = {1492, 1066};
        int i;
        
        printf("%2s%14s\n",
               "i", "some_data[i]");
        for (i = 0; i < SIZE; i++)
            printf("%2d%14d\n", i, some_data[i]);
        
        return 0;
    }
    

    运行效果:

    $ gcc some_data.c -o some_data
    $ ./some_data 
     i  some_data[i]
     0          1492
     1          1066
     2             0
     3             0
    

    相关要点:

    • 如果部分初始化数组,剩余的元素会被编译器初始化为 0。

    • 如果初始化列表的项数多于数组元素个数,gcc 5.4 编译器只会警告有多余的元素:(warning: excess elements in array initializer)。

    5. 让编译器自动推导数组大小

    演示 demo:

    int main(void)
    {
        const int days[] = {31,28,31,30,31,30,31,31,30,31};
        int index;
        
        for (index = 0; index < sizeof days / sizeof days[0]; index++)
            printf("Month %2d has %d days.\n", index +1, days[index]);
    
        return 0;
    }
    

    运行效果:

    $ gcc day_mon2.c -o day_mon2
    $ ./day_mon2 
    Month  1 has 31 days.
    Month  2 has 28 days.
    ...
    Month 10 has 31 days.
    

    相关要点:

    • 初始化数组时省略方括号中的数字,编译器会根据初始化列表中的项数来确定数组的大小。

    • sizeof(array) / sizeof(array[0]) 常用于计算数组的长度。这种方式的弊端:无法察觉初始化列表中的项数有误,遗漏了 2 个月份。

    6. 指定初始化器 (designated initializer )

    该特性用于初始化指定的数组元素,例如,只初始化数组中的最后一个元素。

    演示 demo:

    #define MONTHS 12
    int main(void)
    {
        int days[MONTHS] = {31,28, [4] = 31,30,31, [1] = 29};
        int i;
        
        for (i = 0; i < MONTHS; i++)
            printf("%2d  %d\n", i + 1, days[i]);
        
        return 0;
    }
    

    运行效果:

    $ gcc designate.c -o designate
     1  31
     2  29
     3  0
     4  0
     5  31
     6  30
     7  31
     8  0
     9  0
    10  0
    11  0
    12  0
    

    相关要点:

    • 这是 C99 的特性。

    • 如果指定初始化器后面有更多的值,那么后面这些值将被用于初始化指定元素后面的元素:在days[4] 被初始化为 31,days[5] 被初始化为 30。

    • 如果再次初始化指定的元素,那么最后的初始化将会取代之前的初始化:day1[1] 的最终值为 29。

    • 如果未指定元素大小,编译器会把数组的大小设置为足够装得下初始化的值:int staff[] = {1, [6] = 4, 9, 10},staff 的长度为 9。

    二、欢迎加入我的微信群

    加我微信,我来拉你进群,暗号:加群


    你和我各有一个苹果,如果我们交换苹果的话,我们还是只有一个苹果。但当你和我各有一个想法,我们交换想法的话,我们就都有两个想法了。

    如果你也对 嵌入式系统 (Linux、RTOS、OpenWrt、Android) 和 开源软件 感兴趣,并且想和更多人互相交流学习的话,请关注我的公众号:嵌入式Hacker,一起来学习吧。

    无论是关注或转发,还是打赏,都是对作者莫大的支持。对了,记得 在看和点赞 ,如果你还想看到我的推送的话。

    祝各位工作顺利,家庭幸福,财源滚滚~

    展开全文
  • 一维数组的初始化与遍历

    千次阅读 2018-05-11 15:59:45
    这里主要写一些数组的初始化操作与遍历方式,给初学者一些帮助,同时对自己也算是总结吧。 数组的初始化分为两种:1、基本类型数组的初始化;2、引用类型数组的初始化; 至于遍历方式也分两种:1、普通的for(){}...

           这里主要写一些一维数组的初始化操作与遍历方式,给初学者一些帮助,同时对自己也算是总结吧。

           一维数组的初始化分为两种:1、基本类型数组的初始化;2、引用类型数组的初始化;

            至于遍历方式也分两种:1、普通的for(){}循环;2、foreach循环;

            先说,基本类型数组的初始化,在内部会用这两中遍历方式遍历数组:

    package com.google.array.array01;
    
    /**
     * 基本类型数组:数组中的元素是基本类型的数据,这种数组就成为基本类型的数组:
     * 有8种:byte,short,int,long,float,double,char,boolean
     */
    public class BaseTypeArray {
    
        public static void main(String[] args){
    
            //先定义一个数组:arr[0]=1,arr[1]=8,arr[2]=4,arr[3]=3,arr[4]=25,arr[5]=47,arr[6]=45,
            int[] arr={1,8,4,3,25,47,45};
    
            //使用for循环遍历数组:1,8,4,3,25,47,45,
            circulation01(arr);
    
    
            //使用foreach循环遍历数组:
            circulation02(arr);
        }
    
    
        /**
         * 数组的定义:用两种方式
         * 这里使用int类型
         */
        public static void defineArray(){
            int[] arr;
            int arr02[];
        }
    
        /**
         * 数组的赋值:3种
         */
        public static void initArray(){
    
            //第一种赋值方式:
            int[] arr = new int[3];
            arr[0]=0;
            arr[1]=1;
            arr[2]=2;
    
            //第二种赋值方式:
            int[] arr02 = new int[]{0,1,2};
    
            //第三种赋值方式:
            int[] arr03={0,1,2};
        }
    
        /**
         * for循环遍历数组
         * @param arr
         */
        public static void circulation01(int[] arr){
    
            for(int i=0;i<arr.length;i++){
                System.out.print("arr["+i+"]="+arr[i]+",");
            }
        }
    
    
        /**
         * foreach遍历数组
         * @param arr
         */
        public static void circulation02(int[] arr){
    
            for(int a:arr){
                System.out.print(a+",");
            }
        }
    }
    
    

    再说引用类型的数组,同样用for和foreach遍历:

    先定义一个实体类:

    package com.google.array.array02;
    
    public class Student {
    
        private String name;
        private int age;
    
    
    
        public Student() {
        }
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
    
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    然后在对这个引用类型的实体类进行操作:

    package com.google.array.array02;
    
    /**
     * 引用类型数组的引用:
     */
    public class RefTypeArray {
    
        public static void main(String[] args){
            /**
             *   student[0]=Student{name='张1', age=1}
                 name-0=张1
                 age-0=1
                 student[1]=Student{name='张2', age=2}
                 name-1=张2
                 age-1=2
                 student[2]=Student{name='张3', age=3}
                 name-2=张3
                 age-2=3
             */
            dynamicInit();
    
            /**
             *  Student{name='赵6', age=12}
                Student{name='赵7', age=15}
                Student{name='赵8', age=17}
             */
            staticInt();
        }
    
        /**
         * 动态初始化引用类型的数组:
         */
        public static void dynamicInit(){
    
            //创建学生对象:
            Student stu1=new Student("张1",1);
            Student stu2=new Student("张2",2);
            Student stu3=new Student("张3",3);
    
            //创建一个数组容器,尺寸为3,用来存放学生元素:
            Student[] student=new Student[3];
            student[0]=stu1;
            student[1]=stu2;
            student[2]=stu3;
    
            print1(student);
        }
    
        /**
         * 静态初始化数组:
         */
        public static void staticInt(){
    
            //第一种方式:
            Student[] student={new Student("赵6",12),new Student("赵7",15),new Student("赵8",17)};
    
            //第二种方式:有点麻烦
            /*Student stu1=new Student("赵6",12);
            Student stu2=new Student("赵7",15);
            Student stu3=new Student("赵8",17);
            Student[] student2={stu1,stu2,stu3};*/
    
            print2(student);
        }
    
        /**
         * 采用for循环:
         * @param student
         */
        public static void print1(Student[] student){
    
            for(int i=0;i<student.length;i++){
                System.out.println("student["+i+"]="+student[i]);
                System.out.println("name-"+i+"="+student[i].getName());
                System.out.println("age-"+i+"="+student[i].getAge());
            }
    
    
        }
    
        /**
         * 采用foreach循环:
         * @param student
         */
        public static void print2(Student[] student){
    
            for(Student stu:student){
                System.out.println(stu);
            }
        }
    
    
    }
    

    至于内存分析,这里就不说了,只要记住,数组是一个引用,

    对于基本类型,内部存放的是数值;

    对于引用类型,内部存放的仍然是一个引用;


    展开全文
  • 1、一维数组的初始化方式  数组初始化赋值是指数组定义时给数组元素赋予初值。数组初始化是在编译阶段进行的。这样将减少运行时间,提高效率。  初始化方式有两种:1) 定义的同时初始化 2) 先定义,后初始化。 ...

     

    1、一维数组的初始化方式

      数组初始化赋值是指数组定义时给数组元素赋予初值。数组初始化是在编译阶段进行的。这样将减少运行时间,提高效率。

      初始化方式有两种:1) 定义的同时初始化  2) 先定义,后初始化。

    (1) 定义的同时初始化

      常见形式为:

      类型说明符  数组名[常量表达式] = {值1, 值2, 值3, ..., 值n};

    其中在{}中的各数据值即为各元素的初值,各值之间用逗号间隔。例如:int a[3] = {1, 2, 3};

      又细分为以下几种情况:

      1> 指定元素个数的同时,对所有的元素进行显式的初始化

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

      2> 指定数组的元素个数,对数组进行部分显式初始化

        定义的同时对数组进行初始化,没有显式初始化的元素,那么系统会自动将其初始化为0

        int nums[10] = {1, 2};

      3> 不指定元素个数,定义的同时初始化,它是根据大括号中元素的个数来确定数组元素的个数。

        int nums[] = {1, 2, 3, 9, 5};

      4> 指定元素个数, 同时给指定元素进行初始化

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

      给数组赋值的方法除了用赋值语句对数组元素逐个赋值外,还可采用初始化赋值和动态赋值的方法。

    注意:

     
     
    (2) 先定义,后初始化
    1 //先定义数组,然后对数组进行初始化
    2 //使用常量作为元素个数
    3 int a[3];
    4 a[0] = 1;
    5 a[1] = 4;
    6 a[2] = 3;
    1 //使用变量作为元素个数:C99不支持使用变量作为元素个数,但LLVM编译器支持
    2 int len = 5;
    3 int scores[len];
    4 scores[0] = 87;
    5 scores[1] = 34;
    6 scores[2] = 12;
    7 scores[3] = 45;
    8 scores[4] = 56;

    关于数组的几个让人疑惑的问题

    (1) 数组如果没有进行初始化,数组中到底有没有值?啥东西?

      1> 整型数组

      2> 实型数组

      3> 字符数组

    结论:如果定义数组后,没有初始化,数组中是有值的,是随机产生的垃圾值,所以如果想要正确地使用数组必须进行初始化。

    (2)数组如果部分初始化,那么没有初始化的元素是什么?

    整型

     

    实型

     

    字符型

     

    结论:对于整型、实型数组来说,一旦有元素被初始化,其他元素都被赋值0,字符型的还是随机的垃圾值。 

    思考&实现1: 通过for循环,从键盘获取10个数,存放到数组中。

    思路:循环10,下标从0-9;   每次从键盘获取一个值,放到arr[i]

     1 #include <stdio.h>
     2 int main(int argc, const char * argv[])
     3 {
     4     int arr[10];
     5     //从键盘获取数组元素
     6     for(int i = 0; i < 10; i++)
     7     {
     8         //输入数组元素,用空格或回车或tab隔开
     9         scanf("%d", &arr[i]);
    10     }
    11     //遍历数组元素并打印出来
    12     for(int i = 0; i < 10; i++)
    13     {
    14         printf("%d ", arr[i]);
    15     }
    16     return 0;
    17 }

    2、一维数组的引用方式

    数组元素是组成数组的基本单元。数组元素也是一种变量,其标识方法为数组名后跟一个下标。

    下标表示元素在数组中的顺序号

    数组元素访问一般形式为: 数组名[下标]

    其中下标只能为整型常量或整型表达式。

    例如:a[3]   a[i+j]  a[i++]   都是合法的数组元素

    数组元素通常也称为下标变量。必须先定义数组,才能使用下标变量。

    在C语言中,只能逐个使用下标变量,而不是一次引用整个数组。

    思考&实现2: 通过for循环,打印数组元素

     

     1 #include <stdio.h>
     2 int main(int argc, const char * argv[])
     3 {
     4     char ch[5] = {'a', 'b', 'e', 'r', 'o'};
     5     //遍历数组元素并打印出来
     6     for(int i = 0; i < 5; i++)
     7     {
     8         printf("%c ", ch[i]);
     9     }
    10     return 0;
    11 }

     

    下面是错误的写法(此处通过数组名不能获取整个数组内容)

    思考&实现3: 通过for循环,从键盘获取10个数,存放到数组中。并使用for循环输出查看 

     1 #include <stdio.h>
     2 int main(int argc, const char * argv[])
     3 {
     4     int arr[10];
     5     //从键盘获取数组元素
     6     for(int i = 0; i < 10; i++)
     7     {
     8         //输入数组元素,用空格或回车或tab隔开
     9         scanf("%d", &arr[i]);
    10     }
    11     //遍历数组元素并打印出来
    12     for(int i = 0; i < 10; i++)
    13     {
    14         printf("%d ", arr[i]);
    15     }
    16     return 0;

    思考&实现4: 通过for循环,从键盘获取10个数,存放到数组中。并使用for循环输出查看 (按倒序输出)

     

     1 #include <stdio.h>
     2 int main(int argc, const char * argv[])
     3 {
     4     int arr[10];
     5     //从键盘获取数组元素
     6     for(int i = 0; i < 10; i++)
     7     {
     8         //输入数组元素,用空格或回车或tab隔开
     9         scanf("%d", &arr[i]);
    10     }
    11     //遍历数组元素并打印出来
    12     for(int i = 9; i >= 0; i--)
    13     {
    14         printf("%d ", arr[i]);
    15     }
    16     return 0;
    17 }



     

    转载于:https://www.cnblogs.com/xdl745464047/p/4003765.html

    展开全文
  • 初始化数组时按照书上方法可以完成,但为什么另种方法不行,按道理应该可以啊?看下图[img=https://img-bbs.csdn.net/upload/201804/18/1524027895_920977.jpg][/img][img=...
  • Java数组的初始化主要分为两种:静态初始化和动态初始化。在了解这两种初始化方式之前,先看一下Java提供的数组默认初始化。 Java为了保证安全性,防止内存缺失,为已创建的数组提供了默认初始化机制。在创建成功...
  • package com.sxt.arraytest1; import java.util.Arrays; ... * 一维数组 */ public class ArrayTest2 { public static void main(String[] args) { //动态初始化 int[] arr1 = new in...
  • 数组是个变量,存储相同数据类型的组数据步骤 举例 解释 声明 int[ ] a; 告诉计算机数据类型是什么 分配空间 a = new int[5];... 数组的常用操作a) 声明数组并分配空间数据类型[ ] 数组名 ...
  • 数组元素初始化时,若没有显式提供幸元素值,则元素会被像普通变量一样初始化: 函数体外定义内置类型数组(即内置类型全局数组),元素初始化为0; 函数体内定义内置类型数组,元素无初始化(注意,若只...
  • 【C++】 一维数组的初始化

    千次阅读 2016-01-27 13:12:19
    1、在定义数组时对全部数组元素赋予初值。 int [10]={0,1,2,3,4,5,6,7,8,9} 2、可以只给部分元素赋值。 Int a[10]={0,1,2,3,4,5} 3、在对全部数组元素赋初值时,可以不指定数组长度。 int a[5]={1,2,3...
  • java int类型一维数组的初始化

    千次阅读 2013-07-11 18:47:22
    1、 一维int类型数组的声明 int[] arraynames或者 int arraynames[]; 2、 初始化:(1) int [] arraynames = {1,2,3,4,5};  (2) int[] arraynames = new int[5];  arraynames = new int[]{1,2,...
  • 二维数组其实就是每一个元素为一维数组的数组。 (二)二维数组初始化格式 1.动态初始化 1.1 二维数组格式1 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个...
  • 本文将重点介绍一维数组的创建、初始化和使用。 创建一维数组 为了在程序中使用一个数组,必须声明一个引用该数组的变量,并指明整个变量可以引用的数组类型。声明一维数组的语法格式为: 数据类型数组名[]; //...
  • 1.一维数组的初始化: 静态初始化: int[] a = {1,2,3,4}; 动态初始化: String books = new String[3]; books[0] = "活着"; books[1] = "追风筝的人"; books[2] = "茶花女"; 2. 二维数组的初始化: 二维数组实际上...
  • 《C++笔记》 Part7 一维数组与二维数组的初始化问题(vector)转载自: C++——二维vector初始化大小方法 C++ vector多维数组初始化及清零一. 一维数组初始化问题数组元素初始化时,若没有显式提供幸元素的值,则...
  • 对于 Python 来说,序列是最基本数据结构。...对于 Java 来说,数组是在内存中存储相同数据类型连续空间,声明数组就是在内存空间中划出串连续空间。 数组名代表是连续空间首地址,通过首地
  • 数组的定义格式 ›格式1:数据类型[ ] 数组名; ›格式2:数据类型 数组名[ ]; 1:针对数组定义两种格式,推荐使用第种格式。因为第种的可读性更强。 第二种可以早期的时候确实有很多人这样用。不过,现在...
  • java一维数组和二维数组初始化方式

    千次阅读 2018-03-22 15:06:26
    java一维数组的初始化方式和二维数组的初始化方式都包括动态初始化和静态初始化,四种(两种动态初始化方式和两种静态初始化方式)。 一维数组初始化: 动态初始化:数据类型[] 变量名 = new 数据类型[数组长度];...
  • //数组:相同大小,相同类型的数组的集合,且占用一片连续的空间 //普通变量定义:类型 变量名; //数组变量定义:类型 数组名[个数]; //使用中括号去区分变量与数组 //访问方式:使用下标法,下标是从0开始的,例如...
  • 一维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] data=new int [5] :声明并开辟一个长度为5数组 数组通过下标索引来获取元素,下标默认从0开始。数组下标...
  • 维数组正确初始化规则

    千次阅读 多人点赞 2019-03-19 20:30:50
    最近刷题总在二维数组初始化这里栽跟头,接下来总结一点二维数组的初始化规则以便记忆 这里提一句一维数字代表行,二维数字代表列 arr[2][3]就是创建两行三列的数组 二维数组在初始化的时候可以分行进行初始化 int...
  • 一维数组既可以在定义时候初始化(例1),又可以在定义之后初始化(例2)。 例1: publicstaticvoidmain(String[]args){ intarray[]=newint[]{100,200}; } 例2: publicstaticvoidmain(String[]args){ intar....
  • 维数组的初始化

    2013-11-16 16:47:15
    )二维数组的初始化维数组的初始化分为两种,种是顺序初始化,种是按行初始化, 按顺序初始化就是先从左向右再由上而下地初始化,即第行所 有元素都初始化好以后再对第二行初始化。 而按行初始化则是...
  • 维数组的初始化位数组初始化类似,同样可以使用静态初始化或动态初始化。 1)静态初始化 静态初始化的格式如下: 数组名字 = new 数组元素的类型[][]{new 数组元素的类型[]{元素1,元素2,...},new 数组元素...
  • 维数组的初始化及访问 C++可以模拟多维数组,但存储数组的内存是一维的。 编译器将多维数组映射到内存,而内存只沿一个方向延伸。 在C++定义二维数组并使用函数初始化 #include <iostream> using namespace ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,229
精华内容 2,891
关键字:

一维数组的初始化