- 除了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)