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