精华内容
下载资源
问答
  • java代码-JAVA中String数组初始化,一维数组和二维数组初始化
  • 方法二:未知长度的二维数组 var tArray = new Array(); //先声明一维 for(var k=0;k<i;k++){ //一维长度为i,i为变量,可以根据实际情况改变 tArray[k]=new Array(); //声明二维,每一个一维数组里面的一个元素...
  • 主要介绍了Java编程中二维数组初始化和基本操作实例,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 二维数组初始化

    千次阅读 2019-03-01 11:03:54
    @TOC二维数组初始化及输出 //二维数组动态初始化及输出 int[][] at=new int[2][]; at[0]=new int[2]; at[1]=new int[3]; at[0][0]=10; at[0][1]=11; at[1][0]=20; at[1][1]=21; at[1][2]=22; int num=0; while(num...

    @TOC二维数组初始化及输出

    //二维数组动态初始化及输出

    int[][] at=new int[2][];
    at[0]=new int[2];
    at[1]=new int[3];
    
    at[0][0]=10;
    at[0][1]=11;
    at[1][0]=20;
    at[1][1]=21;
    at[1][2]=22;
    
    int num=0;
    while(num<at.length){
      for (int i = 0; i < at[num].length; i++) {
        System.out.print(at[num][i]+"   ");
      }
      System.out.println();
      num++;
    }
    

    //二维数组静态初始化及输出

    int[][] arr = {{11,12},{21,22,23},{30,31,32,33}};
    
    for (int[] is : arr) {
      for (int i = 0; i < is.length; i++) {
        System.out.print(is[i]+"   ");
      }
      System.out.println();
    }
    
    展开全文
  • java之二维数组初始化

    2019-11-21 21:16:49
    package libai; public class meihua { public static void main(String[] args) { // TODO Auto-generated method stub char a[][]=new char[4][]; //数组初始化 a[0]=new char[]{'云','想','衣'...

    小试牛刀,简单的二维数组初始化
    小生初次进军CSDN,如有错误,望诸位海涵

    /*第一种方法*/
    int a[][]={{1,35}{7,911}}/*第二种方法*/比较常用
    int b[][]=new int [][]{{2,4,6},{8,10,12}};
    /*第三种方法*/
    int c[][]=new int[2][3];//先给数组分配内存空间空间
    c[0]=new int[]{1,2,3};//先给第一行分配一个一维数组
    c[1][0]=5;
    c[1][1]=2;
    c[1][2]=1;
    

    一首《清平调一》的横版和竖版输出,利用二维数组输出且代码如下:

    package libai;
    public class meihua {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
         char a[][]=new char[4][];              //数组初始化
         a[0]=new char[]{'云','想','衣','裳','花','想','容'};
         a[1]=new char[]{'春','风','拂','揽','露','华','浓'};
         a[2]=new char[]{'若','非','群','玉','山','头','见'};
         a[3]=new char[]{'会','向','瑶','台','月','下','逢'};
         
         System.out.println("");
         System.out.println("...横板输出...");
         for(int i=0;i<a.length;i++) {
        	 for(int j=0;j<a[i].length;j++) {
        		 System.out.print(a[i][j]);
        	 }
    //标点符号:奇行为“,”偶行为“。”
        	 if(i%2 == 0) {
        		 System.out.println(", ");
        	 }else {
        		 System.out.println(". ");
        	 }
         }
    //竖版输出
         System.out.println("...竖版输出...");
         for(int j=0;j<7;j++) {
        	 for(int i=0;i<=3;i++) {
        		 System.out.print(a[i][j]);
        	 }
         System.out.println();
             }
         System.out.println(",.,.");
    	}
    }
    
    
    

    运行结果,请君过目
    在这里插入图片描述

    展开全文
  • 维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] data=new int [5] :声明并开辟一个长度为5的数组 数组通过下标索引来获取元素,下标默认从0开始。数组下标...

    数组属于引用数据类型,在使用前必须初始化,否则会报NullPointerException(空指针异常:运行时异常)
    一维数组初始化:
    动态初始化:(声明并开辟数组)
    数据类型[ ] 数组名称=new 数据类型[长度]

    int[ ] data=new int [5] :声明并开辟一个长度为5的数组

    数组通过下标索引来获取元素,下标默认从0开始。数组下标超出数组长度,数组越界异常(运行时异常)

    数组中每个元素都有默认值,默认值是该数据类型默认值

    数组长度:数组名称.length

    数组遍历推荐使用JDK1.5 提供for-each循环(仅限于数组内容读取),要修改数组内容,还是使用常规for循环

        for(int x : data)
    

    {
    System.out.println(x+" ");
    }
    引用传递:多个栈内存指向同一块堆内存

    int[ ] tmp=data; //引用传递 注意是地址的传递
    tmp[3]=10; ----> x[3]=10;

    数组静态初始化
    简化格式:
    数据类型[ ] 数组名称 ={值,值…}
    完整格式: (推荐使用)
    数据类型[ ] 数组名称 =new 数据类型[ ]{值,值…}
    int[ ] data =new int[ ] {1,2,3} ;

    长度 :数组名称.length ,静态初始化长度固定,根据值的个数确定长度,并且长度不可修改

    匿名数组:没有任何栈内存指向,在使用一次后会变成垃圾,只会使用一次

    二维数组
    动态初始化:数据类型[ ][ ] 数据名称 =new 数据类型[ 行个数] [列个数]

    int[ ] [ ]data =new int [3][4];开辟行数为3,列数为4的整型数组

    静态初始化:
    数据类型[ ][ ] 数组名称 =new 数据类型[ ][ ]{ {第一行的值},{第二行的值}…}

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

    x<data.length

    y<data[x].length

    对象数组初始化:

    首先看对象数组动态初始化:

    对象数组动态初始化
    public class ArrayDemo
    {
        public static void main(String[] args)
        {
            String[] str=new String[3];  //数组动态初始化,每个元素都是其对应数据类型的默认值
            for(String num :str)
            {
                System.out.print(num+"、"); //null、null、null、
            }
            str[0]=new String("pick");
            str[1]=new String("happy");
            str[2]=new String("day");
           for(String num :str)
           {
               System.out.print(num+"、"); //pick、happy、day、
           }
        }
    }
    

    对象数组静态初始化:

    public class ArrayDemo
    {
        public static void main(String[] args)
        {
            String[] str=new String[]{"pick","happy","day"};  //数组静态初始化,pick、happy、day、
           for(String num :str)
           {
               System.out.print(num+"、"); //pick、happy、day、
           }
        }
    }
    
    展开全文
  • C语言中二维数组初始化和作为形参的设定细节

    1、int二维数组初始化方式

    int A[2][3] = {1, 2, 3, 4, 5, 6};
    对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=5; A[1][2]=6;
    
    int A[2][3] = {1, 2, 3, 4};
    其中剩余的未赋值元素编译器自动初始化为0。
    数组元素值对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=0; A[1][2]=0;
    
    int A[2][3] = {{1, 2, 3}, {4}};
    其中剩余的未赋值元素编译器自动初始化为0。
    数组元素值对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=0; A[1][2]=0;
    
    int A[][3] = {{1, 2, 3}, {4}};
    省略行数,切记列数无法省略。其中剩余的未赋值元素编译器自动初始化为0。
    数组元素值对应顺序是
    A[0][0]=1; A[0][1]=2; A[0][2]=3;
    A[1][0]=4; A[1][1]=0; A[1][2]=0;
    

    2、char二维数组初始化方式

    char A[2][3] = {'a', 'b', 'c', 'd'};
    其中未初始化的部分,编译器自动初始为'0'NULL)。
    printf("%s\n", A);
    输出"abcd"
    
    char A[2][3] =  {{'a'}, {'d', 'e', 'f'}};
    其中未初始化的部分,编译器自动初始为'0'NULL)。
    printf("%s\n", A);
    输出"a",输出第一行时遇到结束符导致停止输出。
    
    char A[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
    printf("%s\n", A);
    输出"abcdef"
        
    char A[][3] = {{'a', 'b'}, {'d'}};
    省略行数,切记列数无法省略。
    printf("%s\n", A);
    输出"ab"
    

    3、二维数组作为形参

    想要在函数中传递一个一维数组作为参数,必须以下面三种方式来声明函数形式参数,这三种声明方式的结果是一样的,因为每种方式都会告诉编译器将要接收一个整型指针

    方式1,形式参数是一个指针
    void myFunction1(int *param)
    
    方式2,形式参数是一个已定义大小的数组
    void myFunction2(int param[10])
    
    方式3,形式参数是一个未定义大小的数组
    void myFunction3(int param[])
    
    int param[3] = {0};
    myFunction1(param);
    myFunction2(param);
    myFunction3(param);
    int *param2;
    myFunction1(param2);
    myFunction2(param2);
    myFunction3(param2);
    

    就函数而言,一维数组作为形参时的长度是无关紧要的,因为 C 不会对形式参数执行边界检查。

    同样的方式也可以传递一个多维数组作为形式参数?

    方式1,形式参数是一个指针
    void myFunction1(int **param)
    
    方式2,形式参数是一个已定义大小的数组
    void myFunction2(int param[2][10])
    void myFunction2(int param[2][3])
    
    方式3,形式参数是一个未定义一维宽度的数组
    void myFunction3(int param[][3])
    
    方式4
    void myFunction4(int (*a)[3])
    
    方式5
    void myFunction5(int *a[3])
    
    int param[2][3] = {0};
    myFunction1(param);
    错误,[Error] cannot convert 'int (*)[3]' to 'int**' for argument '1' to 'void myFunction(int**)'int param[2][3]中param其实是"int (*)[3]"类型,不是"int**"类型,这两者不能混用
    myFunction2(param);
    二维宽度为10的错误,[Error] cannot convert 'int (*)[3]' to 'int (*)[10]' for argument '1' to 'void myFunction2(int (*)[10])',可以理解为"int (*)[3]""int (*)[10]"不是一种类型
    为3的正确,二维数组作为函数形参会进行边界检查,所以第二个维度必须一致
    myFunction3(param);
    myFunction4(param);
    myFunction5(param);
    错误,注意如果是int *a[3],因为"[]"的优先级比"*"高,所以会导致该形参被编译器识别为"int**"
    
    int **param2 = (int **)malloc(sizeof(int *) * 2);
    myFunction1(param);
    myFunction2(param);
    myFunction3(param);
    myFunction4(param);
    myFunction5(param);
    只有myFunction1和myFunction5正确,其余的形参都不是"int**"类型
    注意myFunction5中的"a[3]"类似一维数组作形参的效果,不管数组大小都被当作"int *"
    

    4、综合例子

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // 二维数组作为函数的形式参数会进行边界检查,所以第二个维度必须为5 
    void example(char acHello[][5])
    {
    	printf("%d\n", sizeof(char (*)[5])); // 输出8
    	printf("%d\n", sizeof(acHello)); // 输出8,为sizeof(char (*)[5]),指针为8 
    	printf("%d\n", strlen(acHello[0])); // 输出9,因为acHello[0]并没有'\0'结束符,所以是acHello的总长度 
    	acHello[0][0] = 'c';
    	return;
    }
    
    int main(void)
    {
    	char str[] = "\\\\";
    	printf("%d\n", sizeof(str)); // 输出3,\\其实是转义,所以2个'\'加字符串自带的1个'\0'是3 
    	printf("%d\n", strlen(str)); // 输出2,即2个'\' 
    	
    	char *str2 = "\\\\";
    	printf("%d\n", sizeof(str2)); // 输出8,str是char*类型的指针,指针在64位下都是8 
    	printf("%d\n\n", strlen(str2)); // 输出2,即2个'\' 
    
    	char str3[2][3] = {"qw", "er"};
    	printf("%c ", *(*(str3 + 0) + 0));
    	printf("%c ", *(*(str3 + 0) + 1));
    	printf("%c ", *(*(str3 + 1) + 0));
    	printf("%c\n", *(*(str3 + 1) + 1));
    
    	printf("%c ", *(str3[0] + 0));
    	printf("%c ", *(str3[0] + 1));
    	printf("%c ", *(str3[1] + 0));
    	printf("%c\n", *(str3[1] + 1));
    
    	printf("%c ", str3[0][0]);
    	printf("%c ", str3[0][1]);
    	printf("%c ", str3[1][0]);
    	printf("%c\n\n", str3[1][1]);
    	// *(str3 + 0)等效于str3[0],*(*(str3 + 0) + 0)等效于str3[0][0] 
    
    	char *szStr = "abcde";
    	printf("%c\n", szStr[0]); // 输出a 
    	printf("%llu\n", szStr); // 输出4210713,该值为"abcde"这个常串中字符a所在的地址
    	szStr += 2;
    	printf("%c\n", szStr[0]); // 输出c 
    	printf("%llu\n\n", szStr); // 输出4210715,该值为"abcde"这个常串中字符c所在的地址
    
    	char dqq[][10] = {{'h', 'e', 'l', 'l', 'o'}, {'q', 'w', 'e'}};
    	printf("%s\n", dqq); // 输出hello,因为第一维多的部分被自动初始化为'\0',所以输出的时候截断了 
    	printf("%s\n", dqq[1]); // 将第二维输出,所以是输出qwe
    	printf("%c\n\n", dqq[1][0]); // 输出q
    
    	char acHello[][5] = {{'h', 'e', 'l', 'l', 'o'}, {'h', 'e', 'l', 'l'}};
    	example(acHello);
    	printf("%s\n\n", acHello); // 输出cellohell,由于是传的指针,所以第一个字符被修改为c
    
    	return 0;
    }
    
    展开全文
  • 二维数组初始化规则

    万次阅读 多人点赞 2018-03-27 14:24:16
    二维数组初始化的形式为: 数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }; 在{ }中给出各数组元素的初值,各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。 有如下几种初始化方式: ...
  • golang二维数组初始化

    千次阅读 2020-10-21 21:42:00
    golang二维数组初始化来看一下,有点特别 func main() { x := 2 y := 4 table := make([][]int, x) for i := range table { table[i] = make([]int, y) } }
  • 在刷LeetCode的时候需要初始化创建一个行大小为r、列大小为c的vector二维数组,具体的实现方法如下: vector<vector<int>> num(r, vector<int>(c)); 初始化创建r个类型为vector<int>,大小...
  • java二维数组初始化的三种方式

    千次阅读 2019-07-30 17:16:10
    下面主要介绍下二位数组初始化的三种方式 1、定义数组的同时使用大括号直接赋值,适合数组元素已知的情况 2、定义二维数组的大小,然后分别赋值 3、数组第二维的长度可变化 //第一种方式:定义的同时大括号...
  • Python一维数组初始化 ...Python的一维数组初始化时没有太大问题,但是二维初始化就不能这么搞了,不信你看 In [5]: a = [[0]*5]*5 In [6]: a Out[6]: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0,.
  • c++ 二维数组初始化

    千次阅读 2020-07-24 10:17:15
    1)静态数组 int array2[3][2]={{4,2},{5},{6}}; 2)动态数组,行列不确定由 m、n定义 int **array2=new int*[m];...以上初始化完成,后续赋值及使用 ...释放二维数组 for (int i = 0; i < m;i++) { delete[]a
  • c++二维数组初始化

    千次阅读 2020-03-15 16:43:06
    (c/c++定义二维数组初始化) C语言规定,普通数组没有赋初值,默认的数组元素值是随机数,不是0。 如果在定义数组时,数据类型前面加上关键字static,数组变成了静态数组;或者把数组定义在函数的外面,成为全局变量...
  • C语言的二维数组初始化的几种方式介绍1、直接赋值2、循环对每个元素赋值3、借用memset/memset_s初始化为0或-14、`数组所有元素初始化为相同值` 1、直接赋值 适合数组元素较少的,各元素的值可以不同。 int[2][3] arr...
  • C++二维数组初始化的形式

    万次阅读 2019-08-26 09:36:23
    数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }; 在{ }中给出各数组元素的初值,各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。 有如下几种初始化方式: ⑴ 分行进行初始化 int a[2][3]=...
  • 1.定义数组直接赋值 int a[]= {1,2,3,4,5}; 2.用new在数组中创建元素 int a[]=new int[]{1,2,3}; 注意:后面的[]不要忘...输出结果为[0, 0, 0],Arrays.toString产生一维数组的可打印版本。 4.先声明再赋值 int c
  • C++ vector 二维数组初始化方式

    万次阅读 2019-06-30 15:00:54
    原文:... 在LeetCode刷算法的时候发现,使用vector<vector<int>> 时如果声明时不初始化,会报空指针引用错误:reference binding to null pointer of type 'value_type'。 根据《...
  • 二维数组初始化方法

    2019-03-11 18:03:00
    /* 第一种方式 */ int tdarr1[][] = { ... /* 第种方式 */ int tdarr2[][] = new int[][] { { 65, 55, 12 }, { 92, 7, 22 } }; /* 第三种方式 */ int tdarr3[][] = new int[2][3]; // 先给数组分配内存空间 ...
  • vector二维数组初始化

    千次阅读 2018-12-05 18:28:37
    //二维数组初始化 //vector<vector<int>> vec(10, vector(10)); vector<vector<int> >right(num.size(), vector(num[0].size())); vector<vector<int> >down(num.size(), vector(num[0].size())); construct...
  • java二维数组初始化

    万次阅读 2019-02-22 16:35:59
    1.int [][] a=new int[][]{{1,2,3},{2,3}}; 2.int [][] a=new int[4][4]; 3.int [][]a=new int[3][];  a[2]=new int[3];
  • memset函数为二维数组初始化

    万次阅读 2018-05-28 17:38:13
    1int* a; a = new int[10];sizeof(a) 只会返回出来指针的大小,所以我们只能自己计算这个数组的长度,这里应当是sizeof(int) * 10,...//将a数组初始化为02 int **p;//开一个n*m的数组 p = new int*[n]; for (int i = ...
  • 一维数组,二维数组初始化

    千次阅读 2017-03-26 20:51:02
    1 static int a[10]={0,1,2,3,4,5,6,7,8,9};...经过上面的定义和初始化后,a[0]=0,a[1]=1,…,a[9]=9。 (2)初始化时可以只对一部分元素赋初值。例如: 1 static int a[10]=
  • C#基础(四十三)二维数组初始化

    千次阅读 2019-09-03 14:52:44
    #region 二维数组 //https://www.cnblogs.com/zblc2016/p/5721725.html using System; using System.Collections; using System.Collections.Generic; using System.Drawing; using System.IO; using System.Linq; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,235
精华内容 62,094
关键字:

二维数组初始化