数组的初始化:
当你产生某个存储对象的数组时,真正产生的其实是个存储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的 长 度 。
三 、 一 维 数 组 的 初 始 化
对 数 组 元 素 可 以 按 照 上 述 的 例 子 进 行 赋 值 。 也 可 以在 定 义 数 组 的 同 时 进 行 初 始化 。
例 如 :
int a[] = {1,2,3,4,5};
用 逗 号 (,)分 隔 数 组 的 各 个 元 素 ,系 统 自 动 为 数 组 分 配一 定 的 空 间 。
与 C中 不 同 ,这 时 Java不 要 求 数 组 为 静 态 (static)。
java中数组的使用:
1.
1.1
1.2
1.3
1.4
2.
2.1
2.2
3.
3.1
例如:
Arrays提供了一个fill()方法将一个值复制到一个位置,如果是对象数组则将引用复制到每一个位置。
Java 标准库提供了一个静态方法名为System.arraycopy() 专门用于数组的复制它复制数组的速度比自己亲自动手写一个for 循环来复制快得多System.arraycopy()已进行了重载可对所有类型进行控制。无论原始数据类型数组还是对象数组我们都可对它们进行复制。但是假如复制的对象数组,那么真正复制的只是引用对象本身可不会复制。
3.2
效率和类型。
3.2.1
对于Java 来说要想保存和随机访问一系列对象实际是对象引用效率最高的方法莫过于数组。
3.2.2
Java标准库中的容器类都把对象当作没有具体类型那样对待,换言之它们将其当作Object 类型处理。Object 类型是Java 中所有类的根类,从某种角度看这种处理方法是非常合理的,我们只需构建一个容器然后所有Java 对象都可进入那个容器。原始数据类型除外,可用Java 的基类型封装器类将其作为常数置入容器或自建一个类把它们封装到里面当作可变值进行对待。这再一次体现出数组相较于普通容器的优越性,创建一个数组时可让它容纳一种特定的类型。这意味着可进行编译时间的类型检查防范自己设置了错误的类型或者错误地提取了一种类型,而不是运行时的Exception。
总结:在你想容纳一组对象的时候第一个也是最有效的一个选择便是数组。
数组的一些使用技巧:
1.关于数组的特点
2.关于数组定义
1)数组在定义时,不能分配空间。只有定义完后,可以给数组分配空间。
int num[]; num=new int[3]; 或 int num[]=new int[3];
注意 int [] num=new int[]{1,2,3}; //ok int [] num=new int[3]{1,2,3}; //error;
int [][] num; //or num=new int[3][];
num[0]=new int[5]; num[1]=new int[3];
3)二维数组赋初值。
int [][] num=new int[][]{1,2,3,4,5,5}; //error int [][] num=new int[][]{{1,2,3},{4,5,5}}; //ok int [][] num=new int[2][]{{1,2,3},{4,5,5}}; //error int [][] num={{1,2,3},{4,5,6}}; //ok
3.关于数组初始化对象数组在创建之初会自动初始化成null,由原始数据类型构成的数组会自动初始化成零(针对数值类型),(Char)0 (针对字符类型)或者false (针对布尔类型)。
4.数组有关引用的问题
int[] a2; a2 = a1;//这里只是复制了一个引用 看以下代码:
public class Arrays { public static void main(String[] args)
int[] a1 = { 1, 2, 3, 4, 5 };
for (int i = 0; i < a1.length; i++)
System.out.println("a1[" + i + "] = " + a1[i]);
System.out.println("-----after change a2------");
for (int i = 0; i < a1.length; i++)
System.out.println("a1[" + i + "] = " + a1[i]); System.out.println("-----after change a2[0]------");
a2[0] = 333; System.out.println("a2[0]=" + a2[0]);
System.out.println("a1[0]=" + a1[0]);
结果:
1)在Java中,所有的数组都有一个缺省的属性length,用于获取数组中元素的个数。
2)数组的复制:System.arraycopy()。
3)数组的排序:Arrays.sort()。
4)在已排序的数组中查找某个元素:Arrays.binarySearch()。
2)以num为第一关键字,name为第二关键字排序 import java.util.Arrays; class Student implements Comparable { int num; String name; Student(int num, String name) { this.num = num; this.name = name; } public String toString() { return "number=" + num + "," + "name=" + name; } public int compareTo(Object o) { Student s = (Student) o; int result = num > s.num ? 1 : (num == s.num ? 0 : -1); if (0 == result) { result = name.compareTo(s.name); } return result; } } class ArrayTest { public static void main(String[] args) { Student[] ss = new Student[] { new Student(1, "zhangsan"), new Student(2, "lisi"), new Student(3, "wangwu"), new Student(3, "mybole") }; Arrays.sort(ss); for (int i = 0; i < ss.length; i++) { System.out.println(ss[i]); } } } 结果: number=1,name=zhangsan number=2,name=lisi number=3,name=mybole number=3,name=wangwu
7.关于java.util.Arrays
1)java.util.Class Arrays’s architecture java.lang.Object | +--java.util.Arrays
2)说明这个类提供的基本上都是静态方法,用户进行数组操作,binarySearch():数组中特定元素的寻找,equals():比较两个数组是否相等(在相同位置上的元素是否相等),fill():数组填充,sort():数组排序