16.集合与泛型

1. 除了ArrayList外还有这些集合

• Treeset 以有序状态保持并可防止重复
• HashMap 可用成对的name/value来保存与取出
• LinkedList 针对经常插入或删除中间元素所设计的高效率集合
• HashSet 防止重复的集合，可快速地寻找相符的元素
• LinkedHashMap 类似HashMap，但可记住元素插入的顺序，也可以设定成依照元素上次存取的先后来排序

2. 可以用TreeSet或Collections.sort( )方法对数组进行按字母排序
3. toString( )

• 因为toString( )是定义在Object类中的，所以Java中的每个类都会继承toString( )，又因为对象被System.out.println(anObject)列出来时会被调用toString( )，所以当你把list列出时，每个对象的toString( )都会被调用一次。

public String toString(){ 
return title;
}

4. 为什么要用泛型？（带有<>的就是泛型）

• 运用泛型可以创建类型安全更好的集合，让问题尽可能在编译器就能抓到，而不会等到执行期才冒出来
• 如果没有泛型，编译器会很愉快地接受你把绵羊对象送到老虎集合中

5. 泛型使用须知
   (1)创建被泛型化类（如ArrayList）的实例new ArrayList<Song>();
   (2)声明与指定泛型类型的变量List<Song> songList = new ArrayList<Song>();
   (3)声明（与调用）取用泛型类型的方法。void foo(List<Song> list);
   6.ArrayList的说明文件

public class ArrayList<E> extends AbstractList<E> implements List<E>...{
  E部分会用你所声明与创建的真正类型来替代
public boolean add(E o);//E用来指示可以加入ArrayList的元素类型
}E代表用来创建与初始ArrayList的类型，当你看到ArrayList文件上的E时，就可以把它换成实际上的类型

7. 使用泛型的方法

• 使用定义在类声明的类型参数

public class ArrayList<E> extends AbstractList<E>...{
        public boolean add(E o);只能在此使用E，因为它已经被定义成类的一部分

• 使用未定义在类声明的类型参数

public <T extends Animal> void takeThing(ArrayList<T> list)
可以传入Animal或任何Animal的子型（如Cat或Dog），可以使用ArrayList<Dog>来调用该方法

8. sort()方法只能接受Comparable对象的list。

public static <T extends Comparable<?  super T>> void sort(List<T> list)
             这表示它必须是Comparable           仅能传入继承Comparable的参数化类型的list

因此，只要让要排序的类（比如Song）实现Comparable就行了

class Song implements Comparable<Song>{
        public int comparaTo(Song s){
                return title.compareTo(s.getTitle());
用compareTo()方法将执行方法的Song与传入的Song比较并输出

9. int compareTo(T o)
   比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
10. Comparator

• 使用compareTo()方法时，list中的元素只能有一种将自己与同类的另一个元素做比较的方法
• 但Comparator是独立与所比较的元素类型之外的——它是独立的类

11. compareTo()与Caomparator比较

• 调用单一参数的sort(List o)方法代表由List元素上的compareTo()方法来决定顺序。因此元素必须要实现Comparable这个接口
• 调用两个参数的sort(List o,Compararot c)方法代表不会调用list元素的compareTo()方法，而会使用Comparator的compare()方法。这意味着list元素不需要实现Comparable

class ArtistCompare implements Comparator<Song>{
        public int Compare(Song one,Song two){
        return one.getArtist().compareTo(two.getArtist());
    }              这会返回String ,以String来比较
}
public void go(){
...
        ArtistCompare artistCompare = new AritstCompare();
        Collections.sort(songList,artistCompare);
}

2

1. 如何解决数据重复——用Set集合
2. 集合中的三个主要接口——List Set Map

• List——对付顺序的好帮手（是一种知道索引位置的集合，可重复）
  List知道某物在系列集合中的位置，可以由多个元素引用相同的对象
• SET——注重独一无二的性质（不允许重复的集合，不会重复）
  它知道某物是否已存在与集合中，不会有多个元素引用相同的对象
• MAP——用Key来搜索的专家（值可以重复，但key不行）
  两个key可以引用相同的对象，但key不能重复，典型的key会是String，但也可以是任何对象

3. 对象怎样才算相等？

• 引用相等性——堆上同一个对象的两个引用
  可以用==来比较两个引用是否相等
• 对象相等性——堆上的两个不同对象在意义上是相同的
  如果想要把两个不同的对象视为相等的，就必须覆盖过从Object继承下来的hashCode()方法与equals方法
  4.HashSet如何检查重复：hashCode()与equals()
• 当你把对象加入HashSet时，它会使用对象的hashCode值来判断对象加入的位置。但同时也会与其他已经加入的对象的hashCode作比对，如果没有相符的hashCode，HashSet就会假设新对象没有重复出现。
  也就是说，如果hashCode不同，则HashSet会假设对象不可能是相同的（但有相同hashCode的对象也不一定相等）

5. 覆盖过hashCode()与equals()的Song类

public boolean equals(Object aSong){  //aSong是要被比较的对象
        Song s = (Song) aSong;
        return getTitle().equals(s.getTitle));
}//因为歌名是String,且String本来就覆盖过的equals()，所以我们可以调用它
public int hashCode(){
        return title.hashCode();
}//String也有覆盖过的hashCode()，注意到hashCode()与equals()使用相同的实例变量

6. hashCode与equals()的相关规定

• 如果两个对象相等，则hashcode必须也是相等的
• 如果两个对象相等，对其中一个对象调用equals()必须返回true，也就是说，若a.equas(b)，则b.equals(a)
• 如果两个对象有相同的hashCode值，它们也不一定是相等的。但若两个对象相等，则hashCode值一定是相等的
• 因此若equals()被覆盖过，则hashCode()也必须被覆盖
• hashCode()的默认行为是对在heap上的对象产生独特的值。如果你没有override过hashCode()，则该class的两个对象怎样都不会被认为是相同的
• equals()的默认行为是执行==的比较。也就是说会去测试两个引用是否是否对上heap上的同一个对象。如果equals()没有被覆盖过，两个对象永远都不会被视为相同的，因为不同的对象有不同的字节组合。
  a.equals(b)必须与a.hashCode() == b.hashCode()等值
  但a.hashCode() == b.hashCode()不一定要与a.equals()等值

7. TreeSet
   TreeSet在防止重复上面与HashSe一样。但它还会一直保持集合处于有序状态。

public void go(){  //调用没有参数的构造函数来用TreeSet
...                //取代HashSet意味着以对象的compareTo()方法来进行排序
TreeSet<Song> songSet = new TreeSet<Song>();
songSet.addAll(songList);
}

8. TreeSet的元素必须是Comparable
   要使用TreeSet，下列其中一项必须为真

• 集合中的元素必须是有实现Comparable的类型

class Book implements Comparable{
        String title;
        public Book(String t){
                title = t;
        }
        public int compareTo(Object b){
                Book book = (Book) b;
                return (title.compareTo(book.title));
        }
}

• 使用重载、取用Comparator参数的构造函数来创建TreeSet

public class BookCompare implements Comparator<Book>{
      public int compare(Book one,Book two){
          return (one.title.compareTo(two.title));
      }
}
class Test{
        public void go(){
                BookCompare bCompare = new BookCompare();
                TreeSet<Book> tree = new TreeSet<Book>(bCompare);
        }

9. Map
   Map中的元素实际上是两个对象：关键字和值，值可以重复，但是key不行

public static void main(String[] args){//hashMap需要两个参数，关键字和值
        hashMap<String,Integer> scores = new hashMap<String,Integer>();
        scores.put("kathy",42);
        scores.put("Bert",343);//使用put()取代add()，它需要两个参数
        System.out.println(scores);
        System.out.println(scores.get("Bert"));//get()取用关键字参数，返回它的值
}

10. 数组的类型是在运行期间检查的，但集合的类型检查只会发生在编译期间
11. 万用字符<?>

public void takeAnimals(ArrayList<? extends Animals> animals) {
...}       //此处的extends同时代表继承和实现

• 在方法中使用万用字符时，编译器会阻止任何可能破坏引用参数所指集合的行为
• 你能够调用List中任何元素的方法，但不能加入元素
• 也就是说，你可以操作集合元素，但不能新增集合元素。如此才能保证执行期间的安全性，因为编译器会阻止执行期的恐怖行动。

12. 相同功能的另一种语法

public <T extends Animal> void takeThing(ArrayList<T> list)

• 如果都一样，为什么要用有？那个
  这要看你是否会用到T来决定，如果方法有两个参数，则可以

public <T extends Animals> void takeThing(ArrayList<T> one,ArrayList<T> two)

而不必这样

public void takeThing(ArrayList<? extends Animal> one,ArrayList<? extends Animals> two)