java中怎么数组初始化?
发布网友
发布时间：2022-04-26 18:07
共3个回答
热心网友
时间：2023-10-20 04:34
1)
int[] a; //声明,没有初始化
2)
int[] a=new int[5]; //初始化为默认值,int型为0
3)
int[] a={1,2,3,4,5};
//初始化为给定值
4)
int[] a=new int[]{1,2,3,4,5}; //同(3)
int[] a=new int[5]{1,2,3,4,5};
//错误,如果提供了数组初始化操作，则不能定义维表达式
5)
int[] a;
a=new int[5]; //正确,同(2)一样
int[] a;
a={1,2,3,4,5}; //错误数组常量只能在初始化操作中使用，如（3)
6) int a[];
a[0]=1;
//错误,因为数组没有初始化,不能赋值a[1]=2; 二维数组
1)
int[][] a;
//声明,没有初始化
2) int[][] a=new int[2][3];
//初始化为默认值,int型为0
3)
int[][] a={{1,2},{2,3},{3,4}};
//初始化为给定值
int[][] a={{1,2},{2,3},{3,4,5}};
//没有错,数组空间不是连续分配的，所以不要求每一维的大小相同
4)
int[][] a=new int[2][];
a[0]=new int[3];
//a[0]其实就是一个数组a[1]=new int[4];
//每一维的大小可以不一样
;
5)
int[][] a=new
int[][]{{1,2},{2,3},{3,4,5}};
//同(3)
热心网友
时间：2023-10-20 04:34
//数组定义最方便的就是用for循环来做定义，数组下标是从0开始，到11的话就是12个数字。要输出的话可以用以//号注释掉的后面的一句if(i<12）{System.out.println(x[i]);}当然也可以自己再写一个for循环语句来输出，不过我觉得这有点画蛇添足了
public class shuzu {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int x[]=new int[12];
for(int i=0;i<=11;i++)
{
x[i]=i;
//if(i<12){System.out.println(x[i]);}
}
}
}
.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。
数组名加上下标可以表示数组元素。数组的第一个元素是下标为O的元素，例如points[0]。最后一个元素的下标为length一1，如points[points．1ength一1]。当创建一个数组时，每个元素都被初始化。如前面创建的字符数组s，它的每个值被初始化为O(\0000)。而数组points的每个值被初始化为null，表明它还没指向真正的Point对象。
在赋值语句points[o]= New Point()；后，系统创建一个真正的Point对象，并让数组的第一个元素指向它。
注意：包括数组元素在内的所有变量的初始化．从系统安全角度看都是必不可少的任何变量都不能在没有初始化状态下使用。编译器不能检查数组元素的初始化情况。Java允许用初值来创建数组，如例：String names[]={”Georgianna”，“Tenn”，“Simon“，“Tom“};用4个字符串常量初始化names数组，这种方式称为静态初始化，它等价于：String names[]；names=new String[4]；names[0]=“Georgianna“;names[1]=“JEN”;names[2]=”Simon“；静态初始化可用于任何元素类型，初值块中每个位置的每个元素对应一个引用。
热心网友
时间：2023-10-20 04:35
当你产生某个存储对象的数组时，真正产生的其实是个存储references的数组。此一数组建立之后，其中的每一个reference皆会被自动设为某个特殊值。
该值以关键字null表示。当Java看到null值，便将这个reference视为“不指向任何对象”。使用任何reference之前，你必须先将某个对象指派给它。如果你使用某个reference而其值为null，便会在执行期发生错误。因此，数组操作上的常犯错误，在Java中均可避免。
你当然也可以产生一个数组，用来存储基本型别。编译器一样保证初始化动作的必然进行：这一次它会将数组所占的内存全部清为零。
一 维 数 组 的 定 义 方 式 为 :
type arrayName[];
其 中 类 型 (type)可 以 为 Java中 任 意 的 数 据 类 型 ,包 括 简 单 类 型 和 组 合 类 型 (见 2.1),数 组 名
arrayName为 一 个 合 法 的 标 识 符 ,[]指 明 该 变 量 是 一 个 数 组 类 型 变 量 。 例 如 :
int intArray[];
声 明 了 一 个 整 型 数 组 ,数 组 中 的 每 个 元 素 为 整 型 数 据 。 与 C 、 C++不 同 ,Java在 数 组 的 定
义 中 并 不 为 数 组 元 素 分 配 内 存 ,因 此 []中 不 用 指 出 数 组 中 元 素 的 个 数 ,即 数 组 长 度 ,而 且 对 于
如 上 定 义 的 一 个 数 组 是 不 能 访 问 它 的 任 何 元 素 的 。 我 们 必 须 为 它 分 配 内 存 空 间 ,这 时 要 用
到 运 算 符 new,其 格 式 如 下 :
arrayName = new type[arraySize];
其 中 ,arraySize指 明 数 组 的 长 度 。 如 :
intArray = new int[3];
为 一 个 整 型 数 组 分 配 3个 int型 整 数 所 占 据 的 内 存 空 间 。
通 常 ,这 两 部 分 可 以 合 在 一 起 ,格 式 如 下 :
type arrayName = new type [arraySize];
例 如 :
int intArray = new int[3];
二 、 一 维 数 组 元 素 的 引 用
定 义 了 一 个 数 组 ,并 用 运 算 符 new为 它 分 配 了 内 存 空 间 后 ,就 可 以 引 用 数 组 中 的 每 一 个
元 素 了 。 数 组 元 素 的 引 用 方 式 为 :
arrayName[index]
其 中 :index为 数 组 下 标 ,它 可 以 为 整 型 常 数 或 表 达 式 。 如 a[3] ,b[i](i为 整 型 ),c[6*I]等 。 下 标
从 0开 始 ,一 直 到 数 组 的 长 度 减 1。 对 于 上 面 例 子 中 的 in- tArray数 组 来 说 ,它 有 3个 元 素 ,分 别 为 :
intArray[0],intArray[1], intArray[2]。 注 意 :没 有 intArray[3]。
另 外 ,与 C、 C++中 不 同 ,Java对 数 组 元 素 要 进 行 越 界 检 查 以 保 证 安 全 性 。 同 时 ,对 于 每 个
数 组 都 有 一 个 属 性 length指 明 它 的 长 度 ,例 如 :intArray.length指 明 数 组 intArray的 长 度 。
例5.1
public class ArrayTest{
public static void main( String args[] ){
int i;
int a[]=new int[5];
for( i=0; i＜5; i++ )
a[i]=i;
for( i=a.length-1; i＞=0; i-- )
System.out.println("a["+i+"] = "+a[i]);
}
}
运行结果如下:
C:\＞java ArrayTest
a[4] = 4
a[3] = 3
a[2] = 2
a[1] = 1
a[0] = 0
该 程 序 对 数 组 中 的 每 个 元 素 赋 值 ,然 后 按 逆 序 输 出 。
三 、 一 维 数 组 的 初 始 化
对 数 组 元 素 可 以 按 照 上 述 的 例 子 进 行 赋 值 。 也 可 以 在 定 义 数 组 的 同 时 进 行 初 始 化 。
例 如 :
int a[] = {1,2,3,4,5};
用 逗 号 (,)分 隔 数 组 的 各 个 元 素 ,系 统 自 动 为 数 组 分 配 一 定 的 空 间 。
与 C中 不 同 ,这 时 Java不 要 求 数 组 为 静 态 (static)。
四 、 一 维 数 组 程 序 举 例 :
例5.2 Fibonacci数列
Fibonacci数 列 的 定 义 为 :
F1 = F2 = 1, Fn = Fn-1 + Fn-2 (n＞=3)
public class Fibonacci{
public static void main( String args[] ){
int i;
int f[]=new int[10];
f[0]=f[1]=1;
for( i=2; i＜10; i++ )
f[i]=f[i-1]+f[i-2];
for( i=1; i＜=10; i++ )
System.out.println("F["+i+"]= "+f[i-1]);
}
}
运 行 结 果 为 :
C:\＞java Fibonacci
F[1]= 1
F[2]= 1
F[3]= 2
F[4]= 3
F[5]= 5
F[6]= 8
F[7]= 13
F[8]= 21
F[9]= 34
F[10]= 55
例 5.3冒 泡 法 排 序 (从 小 到 大 )
冒 泡 法 排 序 对 相 邻 的 两 个 元 素 进 行 比 较 ,并 把 小 的 元 素 交 换 到 前 面 。
public class BubbleSort{
public static void main( String args[] ){
int i,j;
int intArray[]={30,1,-9,70,25};
int l=intArray.length;
for( i=0; i＜l-1; i++)
for( j=i+1; j＜l; j++ )
if( intArray[i]＞intArray[j] ){
int t=intArray[i];
intArray[i]=intArray[j];
intArray[j]=t;
}
for( i=0; i＜l; i++ )
System.out.println(intArray[i]+" ");
}
}
运 行 结 果 为 :
C:\＞java BubbleSort
-9
1
25
30
70]@@@
§ 5.2 多 维 数 组
与 C、 C++一 样 ,Java中 多 维 数 组 被 看 作 数 组 的 数 组 。 例 如 二 维 数 组 为 一 个 特 殊 的 一 维数 组 ,其 每 个 元 素 又 是 一 个 一 维 数 组 。 下 面 我 们 主 要 以 二 维 数 组 为 例 来 进 行 说 明 ,高 维 的情 况 是 类 似 的 。
