Java笔记（四）

13. 集合框架：

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

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

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Demo{
     public static void main(String[] args) {
         //创建一个集合容器，使用Collection接口的子类：ArrayList
         ArrayList al1 = new ArrayList();
         ArrayList al2 = new ArrayList();

         //添加元素
         al1.add("java01");
         al1.add("java02");
         al1.add("java03");

         al2.add("java01");
         al2.add("java02");
         al2.add("java05");

         //删除元素
         al1.remove("java02");

         //获取元素个数(集合长度)
         al1.size();

         //清空集合
         al1.clear();

         //判断元素
         al1.contains("java03");

         //判断集合是否为空
         al1.isEmpty();

         //取交集
         al1.retainAll(al2);

         //获取迭代器，用于取出集合中的元素
         Iterator it = al1.iterator();
         while(it.hasNext()){
             System.out.println(it.next());
         }

     }
 }

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特有的取出方式，与迭代器相像。被迭代器取代了。

 import java.util.Enumeration;
 import java.util.Vector;

 public class Demo{
     public static void main(String[] args) {
         Vector v = new Vector();

         v.add("java01");
         v.add("java02");
         v.add("java03");

         Enumeration en = v.elements();

         while(en.hasMoreElements()){
             System.out.println(en.nextElement());
         }
     }
 }

LinkedList特有方法：

　　addFirst();   addLast();

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

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

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

　　offerFirst();  offerLast();

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

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

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

 import java.util.LinkedList;

 class DuiLie{
     private LinkedList link;
     DuiLie(){
         link = new LinkedList();
     }

     public void myAdd(Object obj){
         link.addFirst(obj);
     }

     public Object myGet(){
         return link.removeLast();
     }

     public boolean isNull(){
         return link.isEmpty();
     }
 }
 public class Demo{
     public static void main(String[] args) {
         DuiLie dl = new DuiLie();

         dl.myAdd("java01");
         dl.myAdd("java02");
         dl.myAdd("java03");

         while(!dl.isNull())
             System.out.println(dl.myGet());
     }
 }

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

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Demo{
     public static void main(String[] args) {
         ArrayList al = new ArrayList();

         al.add("java01");
         al.add("java02");
         al.add("java01");
         al.add("java03");
         al.add("java02");
         al.add("java04");
         System.out.println(al);

         al = singleElement(al);
         System.out.println(al);
     }

     public static ArrayList singleElement(ArrayList al){
         ArrayList newAl = new ArrayList();

         Iterator it = al.iterator();

         while(it.hasNext()){

             Object obj = it.next();

             if(!newAl.contains(obj)){

                 newAl.add(obj);
             }
         }
         return newAl;
     }
 }

输出结果：

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

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

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

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

 import java.util.ArrayList;
 import java.util.Iterator;

 class Person{
     private String name;
     private int age;
     Person(String name, int age){
         this.name = name;
         this.age = age;
     }
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
     public boolean equals(Object obj){
         if(!(obj instanceof Person)) return false;
         Person p = (Person)obj;
         return p.name.equals(this.name) && p.age == this.age;
     }
 }
 public class Demo{
     public static void main(String[] args) {
         ArrayList al = new ArrayList();
         al.add(new Person("ztq01", 20));
         al.add(new Person("ztq02", 21));
         al.add(new Person("ztq03", 22));
         al.add(new Person("ztq03", 22));
         al.add(new Person("ztq05", 24));

         al = singleElement(al);
         Iterator it = al.iterator();
         while(it.hasNext()){
             Person p = (Person)it.next();
             System.out.println(p.getName() + "..." + p.getAge());
         }
     }
     public static ArrayList singleElement(ArrayList al){
         ArrayList newAl = new ArrayList();
         Iterator it = al.iterator();
         while(it.hasNext()){
             Object obj = it.next();
             if(!newAl.contains(obj)){
                 newAl.add(obj);
             }
         }
         return newAl;
     }
 }

输出结果：

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

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

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

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

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

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

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

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

 import java.util.Iterator;
 import java.util.TreeSet;

 class Student implements Comparable{  //该接口强制让学生类具备比较性
     private String name;
     private int age;
     Student(String name, int age){
         this.name = name;
         this.age = age;
     }
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
     public int compareTo(Object obj){
         if(!(obj instanceof Student)) throw new RuntimeException("不是学生对象");
         Student s = (Student)obj;
         if(this.age > s.age) return 1;
         if(this.age == s.age)
             return this.name.compareTo(s.name);
         return -1;
     }
 }
 public class Demo{
     public static void main(String[] args) {
         TreeSet ts = new TreeSet();
         ts.add(new Student("ztq01", 20));
         ts.add(new Student("ztq04", 23));
         ts.add(new Student("ztq02", 21));
         ts.add(new Student("ztq05", 21));
         ts.add(new Student("ztq03", 22));

         Iterator it = ts.iterator();
         while(it.hasNext()){
             Student s = (Student)it.next();
             System.out.println(s.getName() + "~~~" + s.getAge());
         }
     }
 }

或者：

 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.TreeSet;

 class Student{
     private String name;
     private int age;
     Student(String name, int age){
         this.name = name;
         this.age = age;
     }
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
 }

 class MyCompare implements Comparator{
     public int compare(Object o1, Object o2) {
         Student s1 = (Student)o1;
         Student s2 = (Student)o2;

         int num =  s1.getName().compareTo(s2.getName());
         if(num == 0)
             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
         return num;
     }

 }

 public class Demo{
     public static void main(String[] args) {
         TreeSet ts = new TreeSet(new MyCompare());
         ts.add(new Student("ztq01", 20));
         ts.add(new Student("ztq01", 23));
         ts.add(new Student("ztq02", 21));
         ts.add(new Student("ztq05", 21));
         ts.add(new Student("ztq03", 22));

         Iterator it = ts.iterator();
         while(it.hasNext()){
             Student s = (Student)it.next();
             System.out.println(s.getName() + "~~~" + s.getAge());
         }
     }
 }

按照字符串长度排序

 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.TreeSet;

 class StrLenComparator implements Comparator{
     public int compare(Object o1, Object o2){
         String s1 = (String)o1;
         String s2 = (String)o2;
         int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
         if(num == 0)
             num = s1.compareTo(s2);
         return num;
     }
 }

 public class Demo{
     public static void main(String[] args) {
         TreeSet ts = new TreeSet(new StrLenComparator());
         ts.add("abcd");
         ts.add("cc");
         ts.add("cba");
         ts.add("aaa");
         ts.add("z");
         ts.add("hahaha");
         Iterator it = ts.iterator();
         while(it.hasNext()){
             System.out.println(it.next());
         }
     }
 }