对象的集合 一

1，数组
  i,Arrays类，System.arraycopy
  常用方法：equals(),fill(),sort(),binarySearch(),asList()
 

#数组的复制
import java.util.Arrays;

  public class ArrayOperation{
    public static void printArray(int[] input){
        for(int i=0;i
            if(i!=input.length-1)
              System.out.print(input[i]+" ");
            else System.out.println(input[i]);
        }
    }
    public static void main(String[] args){
        int[] aa=new int[7];
        int[] ab=new int[10];
        Integer[] ac=new Integer[10];
        Arrays.fill(aa,47);
        Arrays.fill(ab,99);
        Arrays.fill(ac,new Integer(10));
        printArray(aa);
        printArray(ab);
        System.arraycopy(aa,0,ab,0,5);
        printArray(ab);
        #复制的是引用
        System.out.println(ac[0]==ac[1]);
        #对普通类型数组，asList将整个数组插入第一个位置
      System.out.println(Arrays.asList(ab));
        #对对象数组，asList产生期望的行为       
      System.out.println(Arrays.asList(ac));
    }
}

 

#数组的比较
    int[] a1=new int[10];
    int[] a2=new int[10];
    Arrays.fill(a1,47);
    Arrays.fill(a2,47);
    System.out.println(Arrays.equals(a1,a2));
    String[] s1=new String[5];
    Arrays.fill(s1,"hi");
    String[] s2={"hi","hi","hi","hi","hi",};
    System.out.println(Arrays.equals(s1,s2));
#两次比较都会输出true,注意对象数组的比较是基于内容的

#数组元素的比较Comparable接口|Comparator接口

#CompType.java
public class CompType implements Comparable{
    int i,j;
    public CompType(int i,int j){
        this.i=i;
        this.j=j;
    }
    public String toString(){
        return "["+i+","+j+"]";
    }
    public int compareTo(Object o){
        int oi=((CompType)o).i;
        return (i    }
    public static void main(String[] args){
        Random rand=new Random();
        CompType[] cts=new CompType[10];
        for(int i=0;i            cts[i]=new CompType(rand.nextInt(100),rand.nextInt(100));
        System.out.println(Arrays.asList(cts));
        Arrays.sort(cts);
        System.out.println(Arrays.asList(cts));
    }
}

#ComparatorTest.java
import java.util.*;

class CompTypeComparator implements Comparator{
    public int compare(Object o1,Object o2){
        int i=((CompType)o1).i;
        int j=((CompType)o2).i;
        return (i    }
}
  public class ComparatorTest{
    public static void main(String[] args){
     Random rand=new Random();
         CompType[] cts=new CompType[10];
         for(int i=0;i             cts[i]=new CompType(rand.nextInt(100),rand.nextInt(100));
             System.out.println(Arrays.asList(cts));
             Arrays.sort(cts,new CompTypeComparator());
             System.out.println(Arrays.asList(cts));
    }
}
#这里有一个疑惑，当CompType实现了Comparable接口时，比如当CompTypeComparator类与CompType在同一个文件，使用Arrays.sort(cts,new CompTypeComparator())进行排序就会给出出错信息。


#另外对于实现了Comparable接口的对象数组进行排序时，java提供了Collections.reverseOrder()方法返回一个Comparator，可以反转排序规则进行排序。
  Arrays.sort(cts,Collections.reverseOrder());

#在已经排序的数组中查找
import java.util.*;

public class ArraySearch{
    public static void main(String[] args){
        Random rand=new Random();
        #这里可以用一个数组实现同样的效果。
        int[] tmp=new int[15];
        int[] is=new int[15];
        for(int i=0;i
            tmp[i]=i;
        int index=0;
        for(int i=15;i>0;i--){
            index=rand.nextInt(i);
           
            is[15-i]=tmp[index];
            tmp[index]=tmp[i-1];
        }
        while(true){
            int i=rand.nextInt(15);
            System.out.println(i);
            int location=Arrays.binarySearch(is,i);
            if(location>=0){
                System.out.println(is[location]);
                break;
            }
        }
    }
}
#binarySearch方法：
1，如果数组中包含了重复元素则无法确定是哪个。该方法不是为包含重复元素的数组设计的。
2，如果排序中使用到了Comparator接口，则在使用binarySearch方法时也需要传入该接口
  Arrays.binarySearch(Array,obj,Comparator);