16.集合与泛型

2017-09-19 本文已影响0人 ccc_74bd

除了ArrayList外还有这些集合

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

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

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

public String toString(){ 
return title;
}

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

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

泛型使用须知
(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时，就可以把它换成实际上的类型

使用泛型的方法

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

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>来调用该方法

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比较并输出

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

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

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

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

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

对象怎样才算相等？

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

覆盖过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()使用相同的实例变量

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()等值

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

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

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

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()取用关键字参数，返回它的值
}

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

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

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

相同功能的另一种语法

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)

16.集合与泛型

2

猜你喜欢

热点阅读