java数组简介

数组简介
  数组与其它容器的优势体现在三个方面：效率，类型识别以及可以持有primitives。
  数组是Java中的能随机存储和访问reference序列的诸多方法中的，最高效的一种。
  数组是一个简单的线性序列，所有它可以快速的访问其中的元素。
  但是速度是有代价的；当你创建了一个数组之后，它的容量就固定了，而且在其生命周期里不能改变。
  也许你会提议先创建一个数组，等到快不够用的时候，再创建一个新的，
  然后将旧的数组里的reference全部导到新的里面。
  其实（我们以后会讲的）ArrayList就是这么做的。但是这种灵活性所带来的开销，使得ArrayList的效率比起数组有了明显下降。   
  Java对数组和容器都做边界检查；如果过了界，它旧会给一个RuntimeException（IndexOutOfBoundsException）。
    
  泛型容器类包括List，Set和Map。他们处理对象的时候就好像这些对象都没有自己的具体类型一样。
  也就是说，容器将它所含的元素都看成是（Java中所有类的根类）Object的（在Java1.5中引入了泛型，应该还是当做Object处理的）。
  这样你只需要建一种容器，就能把所有类型的对象全都放进去。从这个角度来看，这种做法很不错（只是苦了primitive。
  如果是常量，你还可以用Java的primitive的Wrapper类；如果是变量，那就只能放在你自己的类里了）。
  与其他泛型容器相比，这里体现数组的第二优势：创建数组的时候，你也同时指明了它所持有的对象的类型
  （这又引出了第三点－－数组可以持有primitives，而容器却不行）。
  也就是说，它会在编译的时候作类型检查，从而防止你插入错误类型的对象，或者是在提取对象的时候把对象的类型给搞错了。
  Java在编译和运行时都能阻止你将一个不恰当的消息传给对象。所有这并不是说使用容器就有什么危险，
  只是如果编译器能够帮你指定，那么程序运行会更快，最终用户也会较少收到程序运行异常的骚扰。   
  从效率和类型检查的角度来看，使用数组总是没错的。
  注意：在Java1.5中引入了泛型，泛型容器类虽然应该还是把元素当做Object处理的，
  但是泛型容器是可以类型识别，所以数组的类型识别这个优势已经没有。
数组本质是对象
  不管你用的是那种类型的数组，数组的标识符实际上都是一个“创建在堆（heap）里的实实在在的对象的”reference。
  实际上是那个对象持有其他对象的reference。你即可以用数组的初始化语句（见例1），隐含地创建这个对象，
  也可以用new表达式（见例2），明确地创建这个对象。只读的length属性能告诉你数组能存储多少元素。
  它是数组对象的一部分（实际上也是你唯一能访问的属性或方法）。‘[]’语法是另一条访问数组对象的途径。   
  你没法知道数组里面究竟放了多少元素，因为length只是告诉你数组能放多少元素，也就是说是数组对象的容量，
  而不是它真正已经持有的元素的数量。但是，创建数组对象的时候，它所持有的reference都会被自动地初始化为null，
  所以你可以通过检查数组的某个“槽位”是否为null，来判断它是否持有对象。
  以此类推，primitive的数组，会自动来数字初始化为零，字符初始化为(char)0，boolean初始化为false。
  例1：用数组的初始化语句，隐含地创建这个对象。
  int ids[]={0,2,3,};
  例2：用new表达式来创建数组这个对象
  int ids[]=new int[3];
primitive容器
  容器类只能持有Object对象的reference。而数组除了能持有Objects的reference之外，还可以直接持有primitive。
  当然可以使用诸如Integer，Double之类的wrapper类。把primitive的值放到容器中，淡这样总有点怪怪的。
  此外，primitive数组的效率要比wrapper类容器的高出许多。当然，如果你使用primitive的时候，
  还需要那种“能随需要自动扩展的”容器类的灵活性，那就不能用数组了。你只能用容器来存储primitive的wrapper类。
返回一个数组
  假设你写了一个方法，它返回的不是一个而是一组东西。那么在Java中就可以返回的“就是一个数组”。
  与C++不同，你永远也不必为Java的数组操心－－只要你还需要它，它就还在；一旦你用完了，垃圾回收器会帮你把它打扫干净。
Arrays类
  java.util里面有一个Arrays类，它包括了一组可用于数组的static方法，这些方法都是一些实用工具。
  其中有四个基本方法：用来比较两个数组是否相等的equals()；用来填充的fill()；用来对数组进行排序的sort()；
  以及用于在一个已排序的数组中查找元素的binarySearch()。
  所有这些方法都对primitive和Object进行了重载。此外还有一个asList()方法，它接受一个数组，然后把它转成一个List容器。   
  注意：fill()是把一个值填到整个数组（如fill(int[] array, int value)）
  或数组的一部分(如fill(int[] array, int start, int end, int value))。
  所以，如果你想把随即生成的数字填进数组的话，fill()是无能为力的。
复制一个数组
  Java标准类库提供了一个System.arraycopy()的static方法。相比for循环，它能以更快的速度拷贝数组（应该是用的内存拷贝）。
  System.arraycopy()对所有类型都作了重载。对象数组和primitive数组都能拷贝。
  但是如果你拷贝的是对象数组，那么你只拷贝了它们的reference－－对象本身不会被拷贝。这被成为浅拷贝（shallow copy）。
数组的比较
  为了能比较数组是否完全相等，Arrays提供了经重载的equals()方法。当然，也是针对各种primitive以及Object的。
  两个数组要想完全相等，他们必须有相同数量的元素，而且数组的每个元素必须与另一个数组的相对应的位置上的元素相等。
  元素的相等，用equals()判断。（对于primitive，它会使用其wrapper类的equals()；比如int使用Integer.equals()。是这样吗？这个有必要吗？不解）。
注意1：primitive的比较，我认为是对于long,int,short,byte,char应该是直接比较把们的值。
   对于浮点数：我想double是调用了compare(double double1, double double2)，float是调用compare(float float1, float float2)来比较。
   浮点数为什么不直接用值比较了。我想是因为浮点数的离小数点一定远后的小数部分是没有意义的。
注意2：虽然Arrays对float数组比较的描述是The values are compared in the same manner as Float.equals().
   对double数组比较的描述也是The values are compared in the same manner as Double.equals().
   但是比没有说的用Float.equals()/Double.equals()来进行比较。
   我想Arrays对浮点数：double是调用了compare(double double1, double double2)，float是调用compare(float float1, float float2)来比较。
   而Double.equals()正是调用了compare(double double1, double double2)，Float.equals()正是调用了ompare(float float1, float float2)。
   所以他们的比较结果就相同。正如文档说他们的方式相同。
数组元素的比较
  Arrays的对数组的比较有三类：
  第一种，基本类型的比较：
  对整形(long,int,short,byte)及字符(char)：直接比较值。
  对浮点数（float/double）；调用容器类的中的compare方法。
  第二种：通过Comparable接口来比较。
  该方式要求数组中的对象必须实现了Comparable接口。否则会抛出ClassCastException异常。
  Arrays为此提供的函数有：
  public static void  sort  (Object[] array)
  public static void  sort  (Object[] array, int start, int end)
   实现java.lang.Comparable接口，就是要实现compareTo  (T another)方法。
   这个方法能接受另一个对象作为参数，如果现有对象比参数小，它就会返回一个负数，
   如果相同则返回零，如果现有的对象比参数大，它就返回一个正数。
   第三种：通过个性化比较器（它实现了Comparator接口）。  
   现在假设，有人给你一个没有实现Comparable接口的类，或者这个类实现了Comparable接口，
   但是你发现它的工作方式不是你所希望的，于是要重新定义一个新的比较方法。
   Java没有强求你一定要把比较代码塞进类里，它的解决方案是使用“策略模式（strategy design pattern）”。
   有了策略之后，你就能把会变的代码（即实现比较的代码）封装到它自己的类里（即所谓的策略对象strategy object）。
   你把策略对象交给不会变的代码，然后用它运用策略完成整个算法。这样，你就可以用不同的策略对象来表示不同的比较方法，
   然后把它们都交给同一个排序程序了。
   这里策略对象是实现Comparator接口了的对象。
   Comparator接口有两个方法compare(T object1, T object2)和equals(Object object)。
   compare()方法会根据第一个参数是小于，等于还是大于第二个参数，分别返回负整数，零或是正整数。
   但是除非是有特殊的性能要求，否则你用不着去实现equals()。因为只要是类，它就都隐含地继承自Object，
   而Object里面已经有了一个equals()了。所以你尽可以使用缺省的Object的equals()，这样就已经满足接口的要求了。   
   Collections类里专门有一个会返回与对象自有的比较法相反的Comparator的方法。它能很轻易地被用到CompType上面。   
   Collections.reverseOrder()/reverseOrder(Comparator<T> c)返回了一个Comparator的reference。   
数组的排序
  有了内置的排序方法之后，你就能对任何数组排序了，不论是primitive的还是对象数组的，
  只要它实现了Comparable接口或有一个与之相关的Comparator对象就行了。   
   Java标准类库所用的排序算法已经作了优化。
   对primitive，它用的是“快速排序（Quicksort）”，对对象，它用的是“稳定合并排序（stable merge sort）”。
  所以除非是prolier表明排序算法是瓶颈，否则你不用为性能担心。
查询有序数组
  一旦数组排完序，你就能用Arrays.binarySearch()进行快速查询了。
  但是切忌对一个尚未排序的数组使用binarySearch()；因为这么做的结果是没意义的。
  如果Arrays.binarySearch()找到了，它就返回一个大于或等于0的值。否则它就返回一个负值，
  而这个负值要表达的意思是，如果你手动维护这个数组的话，这个值应该插在哪个为止。
  这个值就是，-(插入点)-1 
  “插入点”就是，在所有“比要找的那个值”更大值中，最小的那个值的下标，
  或者，如果数组中所有的值都比要找的值小，它就是a.size()。
  如果数组里面有重复元素，那它不能保证会返回哪一个。这个算法不支持重复元素，不过它也不报错。
  所以，如果你需要的是一个无重复元素的有序序列的话，
  那么可以考虑使用本章后面所介绍的TreeSet（支持【排序顺序“sorted order”】）和LinkedHashSet（支持【插入顺序“sorted order”】）。
  这两个类会帮你照看所有细节。只有在遇到性能瓶颈的时候，你才应该用手动维护的数组来代替这两个类。   
  如果排序的时候用到了Comparator（针对对象数组，primitive数组不允许使用Comparator），那么binarySearch()的时候，
  也必须使用同一个Comparator（用这个方法的重载版）。
数组部分的总结
  总而言之，如果你要持有一组对象，首选，同时也是效率最高的选择，应该是数组。
 而且，如果这是一组primitive的话，你也只能用数组。还有一些更为一般的情况，
 也就是写程序的时候还不知道要用多少对象，或者要用一种更复杂方式来存储对象情况。
 为此，Java提供了“容器类（container class）”。其基本类型有List，Set和Map。   
 它们还有一些别的特性。比方说Set所持有的对象，个个都不同，Map则是一个“关联性数组（associative array）”，
 它能在两个对象之间建立联系。此外，与数组不同，它们还能自动调整大小，所以你可以往里面放任意数量的对象。