数组复习

JAVA数组的声明,初始化和为数组内容赋值:
　　 1>String[] s; //只是定义了一个指向String数组的数组对象,并未为其分配内存,如果此时使用编译器会报错
　　 s = new String[10]; //此时才真正的为该数组对象分配了10个内存空间,每个空间初始化为null,不过s仍然为reference;
　　 for(int i=0;i　　 s[i] = new String("Array" + (new Integer(i).toString()));//为数组对象中的每个对象赋值,其实这个数组对象中的每个对像
　　 它持有的仍然是reference
　　 2>String[] s = new String[10]; //定义初始化,为该数组对象分配了10个内存空间,每个空间初始化为null,不过s仍然为reference;
　　 for(int i=0;i　　 s[i] = new String("Array" + (new Integer(i).toString()));//为数组对象中的每个对象赋值,其实这个数组对象中的每个对像
　　 它持有的仍然是reference
　　 3>String[] s = {new String(),new String(),new String(),...};[list=]
　　 //这是一种比较特殊的初始化方法,它在声明的时候就已经给每个数组对象赋值,并且数组的大小是由创建了多少个对象而决定的;
　　 4>String[] s ;
　　 s = (new String(),new String(),new String(),...);
　　 //结合1>,3>
　　
　　JAVA数组的fill(填充):
　　 JAVA的基本类库中提供了一个Arrays的类,专门对JAVA的数组进行一些基本操作,对数组的fill也是使用它,如下:
　　 1>//把s的所有元素赋值为指向"test".也就是指向了同一对象.
　　 String[] s = new String[10];
　　 Arrays.fill(s,new String("test"));//参数一是,要填充的array,二是要用于填充的对象
　　 2>//唯一区别在于,参数二三.二是指定从何处开始填充(此索引包含在填充范围内),三是,填充到什么位置
　　 (此索引不包含在填充范围内)
　　 String[] s = new String[10];
　　 Arrays.fill(s,0,s.length,new String("test"));
　　
　　JAVA数组的比较:
　　 JAVA的比较有三种:
　　 1>直接使用"=="比较,这种比较只是比较reference,比如:
　　 String[] s = new String[10];
　　 String[] s1 = new String[10];
　　 System.out.println(s==s1);//false
　　 s = s1;
　　 System.out.println(s==s1);//true
　　 结果我已经说了,原因是,"=="只是比较reference,而第一次比较s和s1指向的是不同的数组对象,理所当然是false,
　　 后面我把s1的reference给了s,再进行比较就是true了,原理一样.
　　 2>使用数组对象的equals()方法进行比较,但遗憾的是它也是只是比较reference,因为,从Object继承下来的equals()默认就是比较
　　 reference的,由此可见,数组对象并未覆写该方法(但JAVA的其他大多数类都覆写了该方法,所以,你可以放心的使用):
　　 String[] s = new String[10];
　　 String[] s1 = new String[10];
　　 System.out.println(s.equals(s1));//false
　　 s = s1;
　　 System.out.println(s.queals(s1));//true
　　 原理同上
　　 3>最后就是使用JAVA提供的Arrays类的equals()方法来比较两个数组对象,如下:
　　 String[] s = new String[10];
　　 String[] s1 = new String[10];
　　 System.out.println(Arrays.equals(s,s1));
　　 Arrays.equals()方法的实现是这样的:
　　 //该方法的实现只是其重载函数种的一种,还有一些是primitives
　　 public static boolean equals(Object o1,Object o2){
　　 if(o1.length == o2.length){
　　 for(int i=0;i　　 if(o1[i]!=o2[i])
　　 return false;
　　 }
　　 return true;
　　 }
　　 return false;
　　 }
　　 String[] s = new String[10];
　　 Object[] d = new Object[10];
　　 String[] s1= new String[12];
　　
　　 A:>//此处输出是true,因为,他们每一个都指向null
　　 System.out.println(Arrays.equals(s, d));
　　 B:>//输出false,因为,length不等
　　 System.out.println(Arrays.equals(s1, d));
　　 ---------------------------------------------
　　 for(int i=0;i　　 s[i] = new String("something");
　　 C:>//输出false,因为,经过for的赋值之后,s的每个元素都指向不同的对象,而d的每个元素仍然指向null
　　 System.out.println(Arrays.equals(s, d));
　　
　　JAVA数组的排序:
　　 JAVA数组的排序,是使用Arrays.sort()进行的.
　　 在这里还必须提到两个interface.一个是Comparable,另一个是Comparator.
　　 先说第一个:
　　 实现Comparable接口使某个class具有比较能力,它有一个方法叫:compareTo(Object o);如果,o大返回负整数,o小返回正整数,等于
　　 返回0;你一但实现了这个接口你就要负责你所比较的含义.
　　 第二个:
　　 一个实现了Comparator接口的类可以,作为Arrays.sort()的第二个参数和接下来要讲到的Arrays.binarySearch()方法的最后一个参数
　　 这样排序时候的比较就是使用Comparator接口定义的比较方法进行的.
　　 Comparator接口有两个方法compare(Object o1,Object o2)和equals(Object o),一般我们只要实现compare()就可以了,因为
　　 ,Object中就已经帮我们实现了equals(),Bruce Eckel说除非你有效率的考虑而要去实现equals().compare()的返回值与
　　 compareTo()一样.
　　
　　 言归正传,Arrays.sort()有两种调用方式:
　　 1>//这种情况下,如果Test这个类实现了Comparable接口,那么就使用compareTo()方法作为排序的比较算法.
　　 //如果,没有实现就才用Arrays中自己定义的比较算法
　　 Test[] s = new Test[10];
　　 for(int i=0;i　　 s[i] = new Test("something");
　　 Arrays.sort(s);
　　 2>//我们假定Comp类实现了Comparator接口
　　 //这样的调用就是使用Comp中实现的compare()方法作为排序的比较算法.
　　 Comp c = new Comp();
　　 Test[] s = new Test[10];
　　 for(int i=0;i　　 s[i] = new Test("something");
　　 Arrays.sort(s,c);
　　
　　JAVA数组的复制:
　　 JAVA数组的复制是使用System.arraycopy()这个方法实现的,使用如下:
　　
　　 String[] s = new String[10];
　　 String[] s1 = new String[20];
　　
　　 for(int i=0;i　　 s[i] = new String("test" + (new Integer(i)).toString);
　　 s1[i] = new String("test" + (new Integer(i+100)).toString);
　　 System.out.print(s1[i] + " ");
　　 if(i == s.length-1)
　　 System.out.println(s1[i]);
　　 }
　　
　　 System.arraycopy(s,0,s1,10,s.length);
　　
　　 for(int i=0;i　　 System.out.print(s1[i] + " ");
　　 if(i == s1.length-1)
　　 System.out.println(s1[i]);
　　 }
　　 参数1:拷贝源array
　　 参数2:拷贝源的起始拷贝位置(拷贝偏移量)
　　 参数3:拷贝目的array
　　 参数4:拷贝目的的起始接收位置(接收偏移量)
　　 参数5:要拷贝的元素个数(如果,越界将引发异常)
　　
　　JAVA数组的查找:
　　 查找使用Arrays.binarySearch(),使用方法如下:
　　 注意:
　　 如果你要查找的值,在数组中存在多个时,你在使用binarySearch()之前必须对其进行排序
　　 如果不然,结果不可预料,也就是你所找到的位置不一定的数组中第一次出现的该值位置.
　　 1>//在数组对象s中查找"test",如果找到则返回"test"的下标位置,如果,没找到
　　 String[] s = new String[10];
　　 for(int i=0;i　　 s[i] = new String("test");
　　 Arrays.sort(s);
　　 System.out.println("\"test\" 在数组s中的下标是" + Arrays.binarySearch(s,"test") + "\n 其值是" +
　　 s[Arrays.binarySearch(s,"test")]);
　　
　　 2>//如果,在对某个数组排序的时候使用了某个Comparator,那么在对其进行查找的时候也必须使用那个Comparator.
　　 Comp c = new Comp();
　　 String[] s = new String[10];
　　 for(int i=0;i　　 s[i] = new String("test");
　　 Arrays.sort(s,c);
　　 System.out.println("\"test\" 在数组s中的下标是" + Arrays.binarySearch(s,"test",c) + "\n 其值是" +
　　 s[Arrays.binarySearch(s,"test",c)]);
　　
　
　　对数组查找的补充:
　　如果使用 Arrays.binarySearch()未找到匹配的元素,那么就返回一个负整数,这个数据是,该查找的元素要安插在这个array中的索引位置.具体请查看JDK