Java笔记（四）

13. 集合框架：

　　集合中存储的都是对象的引用（地址）

　　迭代器：集合的取出元素的方式

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Demo{
 5     public static void main(String[] args) {
 6         //创建一个集合容器，使用Collection接口的子类：ArrayList
 7         ArrayList al1 = new ArrayList();
 8         ArrayList al2 = new ArrayList();
 9         
10         //添加元素
11         al1.add("java01");
12         al1.add("java02");
13         al1.add("java03");
14         
15         al2.add("java01");
16         al2.add("java02");
17         al2.add("java05");
18         
19         //删除元素
20         al1.remove("java02");
21                 
22         //获取元素个数(集合长度)
23         al1.size();
24         
25         //清空集合
26         al1.clear();
27         
28         //判断元素
29         al1.contains("java03");
30         
31         //判断集合是否为空
32         al1.isEmpty();
33         
34         //取交集
35         al1.retainAll(al2);
36         
37         //获取迭代器，用于取出集合中的元素
38         Iterator it = al1.iterator();
39         while(it.hasNext()){
40             System.out.println(it.next());
41         }
42         
43         
44     }
45 }

Collection

　　|--List：元素是有序的，元素可以重复。因为该集合体系有索引。判断元素是否相同，依据元素的equals方法。

　　　　|--ArrayList：底层使用的数组数据结构。查询速度很快，但是增删稍慢。不是同步的。默认长度为10。超过10则延长50%。

　　　　|--LinkedList：底层使用的链表数据结构。增删速度很快，但是查询速度稍慢。

　　　　|--Vector：底层使用的是数组数据结构。是同步的。被ArrayList替代了。超过10则延长100%，变为20。

　　|--Set：元素是无序的（存入和取出的顺序不一致），元素不可以重复

　　　　|--HashSet：底层使用的是Hash表，通过hashCode和equals两个方法来保证元素唯一性。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，则不会调用equals。线程时非同步的。

　　　　|--TreeSet：底层使用的是二叉树，可以对set集合中的元素进行排序。compareTo()方法return 0 能保证元素唯一性。TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖CompareTo方法，这种方式也成为元素的自然顺序，或默认顺序；第二种方式：当元素自身不具备比较性，或具备的比较性不是所需要的，这时就需要让集合自身具备比较性。定义比较器，将比较器作为参数传递给TreeSet集合的构造函数。当两种排序都存在时，以比较器为主。

比较器的定义方法：定义一个类，实现Comparator接口，覆盖Compare方法。

List特有方法：凡是可以操作角标的方法都是体系特有的方法

　　增：add(index, element); addAll(index, Collection);

　　删：remove(index);

　　改：set(index, element);

　　查：get(index); subList(from, to); listIterator();

List集合特有的迭代器：ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常，所以在迭代时，只能用迭代器的方法操作元素，可是Iterator方法有限，只能对元素进行判断，取出，删除的操作。如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的ListIterator方法获取。

Vector中的枚举：Vector特有的取出方式，与迭代器相像。被迭代器取代了。

 1 import java.util.Enumeration;
 2 import java.util.Vector;
 3 
 4 public class Demo{
 5     public static void main(String[] args) {
 6         Vector v = new Vector();
 7         
 8         v.add("java01");
 9         v.add("java02");
10         v.add("java03");
11         
12         Enumeration en = v.elements();
13         
14         while(en.hasMoreElements()){
15             System.out.println(en.nextElement());
16         }
17     }
18 }

LinkedList特有方法：

　　addFirst(); addLast();

　　getFirst(); getLast(); 获取元素，但不删除元素。如果列表为空，则抛NoSuchElementException异常。

　　removeFirst(); removeLast(); 获取元素，也删除元素。如果列表为空，则抛NoSuchElementException异常。

　　JDK1.6后出现的替代方法：

　　offerFirst(); offerLast();

　　peekFirst(); peekLast(); 获取元素，但不删除元素。如果列表为空，则返回null。

　　pollFirst(); pollLast(); 获取元素，也删除元素。如果列表为空，则返回null。

使用LInkedList模拟一个堆栈或者队列的数据结构。

 1 import java.util.LinkedList;
 2 
 3 class DuiLie{
 4     private LinkedList link;
 5     DuiLie(){
 6         link = new LinkedList();
 7     }
 8     
 9     public void myAdd(Object obj){
10         link.addFirst(obj);
11     }
12     
13     public Object myGet(){
14         return link.removeLast();
15     }
16     
17     public boolean isNull(){
18         return link.isEmpty();
19     }
20 }
21 public class Demo{
22     public static void main(String[] args) {
23         DuiLie dl = new DuiLie();
24         
25         dl.myAdd("java01");
26         dl.myAdd("java02");
27         dl.myAdd("java03");
28         
29         while(!dl.isNull())
30             System.out.println(dl.myGet());
31     }
32 }

去除ArrayList集合中的重复元素：

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 public class Demo{
 5     public static void main(String[] args) {
 6         ArrayList al = new ArrayList();
 7         
 8         al.add("java01");
 9         al.add("java02");
10         al.add("java01");
11         al.add("java03");
12         al.add("java02");
13         al.add("java04");
14         System.out.println(al);
15         
16         al = singleElement(al);
17         System.out.println(al);
18     }
19     
20     public static ArrayList singleElement(ArrayList al){
21         ArrayList newAl = new ArrayList();
22         
23         Iterator it = al.iterator();
24         
25         while(it.hasNext()){
26             
27             Object obj = it.next();
28             
29             if(!newAl.contains(obj)){
30                 
31                 newAl.add(obj);
32             }
33         }
34         return newAl;
35     }
36 }

输出结果：

[java01, java02, java01, java03, java02, java04]
[java01, java02, java03, java04]

注：在迭代时，循环中next调用一次，就要hasNext判断一次。

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

例如：存储人对象。同姓名，同年龄，就视为同一个人，为重复元素。

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 
 4 class Person{
 5     private String name;
 6     private int age;
 7     Person(String name, int age){
 8         this.name = name;
 9         this.age = age;
10     }
11     public String getName(){
12         return name;
13     }
14     public int getAge(){
15         return age;
16     }
17     public boolean equals(Object obj){
18         if(!(obj instanceof Person)) return false;
19         Person p = (Person)obj;
20         return p.name.equals(this.name) && p.age == this.age;
21     }
22 }
23 public class Demo{
24     public static void main(String[] args) {
25         ArrayList al = new ArrayList();
26         al.add(new Person("ztq01", 20));
27         al.add(new Person("ztq02", 21));
28         al.add(new Person("ztq03", 22));
29         al.add(new Person("ztq03", 22));
30         al.add(new Person("ztq05", 24));
31         
32         al = singleElement(al);
33         Iterator it = al.iterator();
34         while(it.hasNext()){
35             Person p = (Person)it.next();
36             System.out.println(p.getName() + "..." + p.getAge());
37         }
38     }
39     public static ArrayList singleElement(ArrayList al){
40         ArrayList newAl = new ArrayList();
41         Iterator it = al.iterator();
42         while(it.hasNext()){
43             Object obj = it.next();
44             if(!newAl.contains(obj)){
45                 newAl.add(obj);
46             }
47         }
48         return newAl;
49     }
50 }

输出结果：

ztq01...20
ztq02...21
ztq03...22
ztq05...24

将自定义对象作为元素存到HashSet集合中，并去除重复元素。

例如：存储人对象。同姓名，同年龄，就视为同一个人，为重复元素。

复写hashCode()和equals()方法：其中equals同上。

public int hashCode(){
    return name.hashCode() + age;
}

注：对于判断元素是否存在，以及删除等操作，依赖的方法时元素的hashCode()和equals()

往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。

注：排序时，当主要条件相同时，一定要判断一下次要条件。

 1 import java.util.Iterator;
 2 import java.util.TreeSet;
 3 
 4 class Student implements Comparable{  //该接口强制让学生类具备比较性
 5     private String name;
 6     private int age;
 7     Student(String name, int age){
 8         this.name = name;
 9         this.age = age;
10     }
11     public String getName(){
12         return name;
13     }
14     public int getAge(){
15         return age;
16     }
17     public int compareTo(Object obj){
18         if(!(obj instanceof Student)) throw new RuntimeException("不是学生对象");
19         Student s = (Student)obj;
20         if(this.age > s.age) return 1;
21         if(this.age == s.age) 
22             return this.name.compareTo(s.name);
23         return -1;
24     }
25 }
26 public class Demo{
27     public static void main(String[] args) {
28         TreeSet ts = new TreeSet();
29         ts.add(new Student("ztq01", 20));
30         ts.add(new Student("ztq04", 23));
31         ts.add(new Student("ztq02", 21));
32         ts.add(new Student("ztq05", 21));
33         ts.add(new Student("ztq03", 22));
34         
35         Iterator it = ts.iterator();
36         while(it.hasNext()){
37             Student s = (Student)it.next();
38             System.out.println(s.getName() + "~~~" + s.getAge());
39         }
40     }
41 }

或者：

 1 import java.util.Comparator;
 2 import java.util.Iterator;
 3 import java.util.TreeSet;
 4 
 5 class Student{ 
 6     private String name;
 7     private int age;
 8     Student(String name, int age){
 9         this.name = name;
10         this.age = age;
11     }
12     public String getName(){
13         return name;
14     }
15     public int getAge(){
16         return age;
17     }
18 }
19 
20 class MyCompare implements Comparator{
21     public int compare(Object o1, Object o2) {
22         Student s1 = (Student)o1;
23         Student s2 = (Student)o2;
24         
25         int num =  s1.getName().compareTo(s2.getName());
26         if(num == 0)
27             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
28         return num;
29     }
30     
31 }
32 
33 public class Demo{
34     public static void main(String[] args) {
35         TreeSet ts = new TreeSet(new MyCompare());
36         ts.add(new Student("ztq01", 20));
37         ts.add(new Student("ztq01", 23));
38         ts.add(new Student("ztq02", 21));
39         ts.add(new Student("ztq05", 21));
40         ts.add(new Student("ztq03", 22));
41         
42         Iterator it = ts.iterator();
43         while(it.hasNext()){
44             Student s = (Student)it.next();
45             System.out.println(s.getName() + "~~~" + s.getAge());
46         }
47     }
48 }

按照字符串长度排序

 1 import java.util.Comparator;
 2 import java.util.Iterator;
 3 import java.util.TreeSet;
 4 
 5 class StrLenComparator implements Comparator{
 6     public int compare(Object o1, Object o2){
 7         String s1 = (String)o1;
 8         String s2 = (String)o2;
 9         int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
10         if(num == 0)
11             num = s1.compareTo(s2);
12         return num;
13     }
14 }
15 
16 public class Demo{
17     public static void main(String[] args) {
18         TreeSet ts = new TreeSet(new StrLenComparator());
19         ts.add("abcd");
20         ts.add("cc");
21         ts.add("cba");
22         ts.add("aaa");
23         ts.add("z");
24         ts.add("hahaha");
25         Iterator it = ts.iterator();
26         while(it.hasNext()){
27             System.out.println(it.next());
28         }
29     }
30 }