java中的数组

数组的初始化：

当你产生某个存储对象的数组时，真正产生的其实是个存储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. Java中的数组作为对象带来的好处
1.1 越界检查

1.2 length field：与传统的C++中的数组相比，length字段可以方便的得到数组的大小；但要注意，仅仅可以得到数组的大小，不能得到数组中实际包含多少个元素，因为length 只会告诉我们最多可将多少元素置入那个数组。

1.3 初始化：对象数组在创建之初会自动初始化成null，由原始数据类型构成的数组会自动初始化成零（针对数值类型），(Char)0 （针对字符类型）或者false （针对布尔类型）。

1.4 数组作为返回值：首先，既然数组是对象，那么就可以把这个对象作为返回值；而且，不必担心那个数组的是否可用只要需要它就会自动存在而且垃圾收集器会在我们完成后自动将其清除

2.  通用算法
2.1 在java.util 中的Arrays 数组类容纳着一系列静态方法可简化我们对数组的操作，总共有四个函数。equals()用于比较两个数组是否相等、fill()可将一个值填入数组、sort()可对数组排序、而binarySearch()用于在排好序的数组中查找一个元素。所有这些方法都已为全部原始数据类型及对象重载使用。除此以外还有一个asList()方法可用它获取任意数组然后把数组转变成一个List 容器。

2.2 sort和binarySearch的使用：在Java 2 中有两个办法可提供比较功能。第一个办法是用自然比较方法,这是通过实现java.lang.Comparable 接口来实现。Java 2 提供的第二个办法来进行对象的比较，单独创建一个类实现名为Comparator 的一个接口。接口提供了两个方法分别是compare()和equals() 。不过除非考虑到一些特殊的性能方面的因素，否则我们用不着实现equals() ，因为每次创建一个类的时候它都会默认从Object 继承，而Object 已经有了一个equals()。Comparator可以作为sort和binarySearch方法的参数。

3. 需要注意的问题
3.1 Java中的数组中既可以存储基本的值类型，也可以存储对象。对象数组和原始数据类型数组在使用方法上几乎是完全一致的，唯一的差别在于对象数组容纳的是引用而原始数据类型数组容纳的是具体的数值。这一点要特别注意，在讨论关于数组的问题时，一定要先确定数组中存储的是基本值类型还是对象。特别是在调试程序时，要注意这方面。
例如：
Arrays提供了一个fill()方法将一个值复制到一个位置，如果是对象数组则将引用复制到每一个位置。
Java 标准库提供了一个静态方法名为System.arraycopy() 专门用于数组的复制它复制数组的速度比自己亲自动手写一个for 循环来复制快得多System.arraycopy()已进行了重载可对所有类型进行控制。无论原始数据类型数组还是对象数组我们都可对它们进行复制。但是假如复制的对象数组，那么真正复制的只是引用对象本身可不会复制。

3.2 为什么使用数组而不使用ArrayList等容器类？
效率和类型。
3.2.1 效率：
对于Java 来说要想保存和随机访问一系列对象实际是对象引用效率最高的方法莫过于数组。
3.2.2 类型：
Java标准库中的容器类都把对象当作没有具体类型那样对待，换言之它们将其当作Object 类型处理。Object 类型是Java 中所有类的根类，从某种角度看这种处理方法是非常合理的，我们只需构建一个容器然后所有Java 对象都可进入那个容器。原始数据类型除外，可用Java 的基类型封装器类将其作为常数置入容器或自建一个类把它们封装到里面当作可变值进行对待。这再一次体现出数组相较于普通容器的优越性，创建一个数组时可让它容纳一种特定的类型。这意味着可进行编译时间的类型检查防范自己设置了错误的类型或者错误地提取了一种类型，而不是运行时的Exception。

 

总结：在你想容纳一组对象的时候第一个也是最有效的一个选择便是数组。

数组的一些使用技巧：

1．关于数组的特点

 1）在Java中，无论使用数组或容器，都有边界检查。如果越界操作就会得到一个RuntimeException异常。

 2）数组只能保存特定类型。数组可以保存基本类型，容器则不能。容器不以具体的类型来处理对象，它们将所有对象都按Object类型处理。

 3）容器类只能保存对象的引用。而数组既可以创建为直接保存基本类型，也可以保存对象的引用。在容器中可以使用包装类，如Integer、Double等来实现保存基本数据类型值。

 4）对象数组和基本类型数组在使用上几乎是相同的；唯一的区别是对象数组保存的是引用，基本类型数组保存基本类型的值。

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;

 2）可以这样定义二维数组。

int [][] num; //or num=new int[3][];

num[0]=new int[5]; num[1]=new int[3];

 num[2]=new int[2];

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[] a1 = { 1, 2, 3, 4, 5 };

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]);

 int[] a2; a2 = a1; for (int i = 0; i < a2.length; i++) a2[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]);

 System.out.println("----- a2------");

 for (int i = 0; i < a2.length; i++) System.out.println("a2[" + i + "] = " + a2[i]); } }

结果：

 a1[0] = 1 a1[1] = 2 a1[2] = 3 a1[3] = 4 a1[4] = 5 -----after change a2------ a1[0] = 2 a1[1] = 3 a1[2] = 4 a1[3] = 5 a1[4] = 6 -----after change a2[0]------ a2[0]=333 a1[0]=333 ----- a2------ a2[0] = 333 a2[1] = 3 a2[2] = 4 a2[3] = 5 a2[4] = 6 数组a1和a2始终在操作同一个对象。

 5．关于数组的相关操作

1）在Java中，所有的数组都有一个缺省的属性length，用于获取数组中元素的个数。

2）数组的复制：System.arraycopy()。

3）数组的排序：Arrays.sort()。

4）在已排序的数组中查找某个元素：Arrays.binarySearch()。

 6．关于数组的排序操作

 1）对象数组排序，必须实现Comparable接口。 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()// 重写toString()方法，以便main:System.out.println(ss[i]); { return "number=" + num + "," + "name=" + name; } public int compareTo(Object o) { Student s = (Student) o; return num > s.num ? 1 : (num == s.num ? 0 : -1); } } class ArrayTest { public static void main(String[] args) { Student[] ss = new Student[] { new Student(1, "zhangsan"), new Student(2, "lisi"), new Student(3, "wangwu") }; 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=wangwu

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()：数组排序

转自：http://blog.sina.com.cn/s/blog_61390cb80100ew4u.html