黑马程序员——Java基础——集合类_1

集合类

集合框架_体系概述

对象多了用集合存，数据多了用对象存
数组和集合类容器的不同：
1. 数组也可以存储对象，但是长度是固定的，集合长度是可变的
2. 数组中可以存储基本数据类型，集合只能存储对象
集合类的特点：
1. 集合只用于存储对象
2. 集合长度是可变的
3. 集合可以存储不同类型的对象
Collection
- - List
- - - - ArrayList
- - - - LinkedList
- - - - Vector
- - Set
- - - - HashSet
- - - - TreeSet
集合框架_共性方法
集合中存储的都是对象的引用(地址)
集合框架_迭代器
迭代器：集合的取出元素的方式

ArrayList al = new ArrayList();
Iterator it1 = al.iterator();//获取迭代器，用于取出集合中的元素
while(it1.hasNext()){
    System.out.println(it1.next());
}
for(Iterator it2 = al.iterator(); it2.hasNext; ){
    System.out.println(it2.next());
}

集合框架_List集合共性方法
List：元素是有序的，元素可以重复，因为该集合体系有索引
- add(index,element);
- addAll(index,Collection);
- remove(index);
- set(index,element);
- subList(from,to);
- listIterator();
- indexOf(Object);
集合框架_ListIterator
在迭代过程中，集合的方法和迭代器方法不能同时使用，会发生ConcurrentModificationException
想要在迭代过程中准备添加删除等操作元素，需要使用List集合特有迭代器ListIterator
集合框架_List集合具体对象的特点
List
- - ArrayList：
- - - - - - 底层的数据结构使用的是数组结构(java 1.2)线程不同步
- - - - - - 查询速度快，但是增删稍慢
- - - - - - 可变长度数组，容器初始长度，在容器不够后，扩容50%
- - LinkedList：
- - - - - - 底层使用的是链表数据结构
- - - - - - 增删的速度很快，查询稍慢
- - Vector：
- - - - - - 底层是数组数据结构(java 1.0)线程同步
- - - - - - 增删查询都稍慢
- - - - - - 可变长度数组，容器初始长度，在容器不够后，扩容100%
集合框架_Vector中的枚举

public static void main(String[] args){
    //创建Vector集合对象v，并添加数据
    Vector v = new Vector();
    v.add("java1");
    v.add("java2");
    v.add("java3");
    v.add("java4");
    //将对象v中的元素放入枚举类对象中
    Enumeration en = v.elements();
    //循环枚举
    while(en.hasMoreElements()){
        System.out.println(en.nextElement());
    }
}

集合框架_LinkList
LinnkedList特有方法
- addFrist();
- addLast();
- getFrist();
- getLast();
获取元素，如果集合中没有元素，报NoSuchElementException异常
- removeFrist();
- removeLast();
删除元素，如果集合中没有元素，报NoSuchElementException异常
JDK 1.6出现了替代方法
- offerFrist()
- offerLast()
- peekFrist()
- peekLast()
获取元素，如果集合中没有元素，返回null
- pollFrist()
- pollLast()
删除元素，如果集合中没有元素，返回null
集合框架_LinkList练习

/*
使用LinkedList模拟一个堆栈或者列队数据结构
堆栈：先进后出
队列：先进先出
*/
public class TestLinkedList {
    public static void main(String[] args){
        DuiLie dl = new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");
        while(!dl.isNull()){
            System.out.println(dl.myGet());
        }
    }
}
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();
    }
}

集合框架_ArrayList练习
List集合判断元素是否相同，依据的是元素的equals方法
在迭代循环中判断一次hasNext();才能使用一次next();

/*
去除ArrayList集合中的重复元素
*/
public class TestArrayList {
    public static void main(String[] args){
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java03");
        System.out.println(singleElement(al));
    }
    public static ArrayList singleElement(ArrayList al){
        //private 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;
    }
}

/*
将自定义对象作为元素，存储到ArrayList集合中，并去除重复元素
*/
public class TestArrayList2 {
    public static void main(String[] args){
        ArrayList al = new ArrayList();
        al.add(new Person("dillinger", 18));
        al.add(new Person("hide", 20));
        al.add(new Person("dillinger", 18));
        al.add(new Person("sblx", 15));

        al = TestArrayList.singleElement(al);

        Iterator it = al.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p.getName() + "::" + p.getAge());
        }
    }
}
class Person{
    private String name;
    private int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

集合框架_HashSet
Set
- - HashSet:
- - - - - - 底层数据结构是哈希表
- - - - - - 通过hashCode();和equals();来保证数据唯一性
集合框架_HashSet存储自定义元素

public class TestHashSet {
    public static void sop(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args){
        HashSet hs = new HashSet();
        hs.add(new Human("a1", 11));
        hs.add(new Human("a2", 12));
        hs.add(new Human("a2", 12));
        Iterator it = hs.iterator();
        while(it.hasNext()){
            Human h = (Human)it.next();
            sop(h.getName() + "::::" + h.getAge());
        }
    }
}
class Human{
    private String name;
    private int age;
    Human(String name,int age){
        this.name = name;
        this.age = age;
    }
    public int hashCode(){
        return name.hashCode() + age;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Human))
            return false;
        Human h = (Human)obj;
        System.out.println(this.name + "::" + h.name);
        return this.name.equals(h.name) && this.age == h.age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

集合框架_HashSet判断和删除的依据
HashSet在判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法
集合框架_TreeSet、TreeSet存取自定义对象
Set
- - TreeSet：
- - - - - - 可以对Set集合中的元素排序，底层数据结构是二叉树
- - - - - - 排序时，主要条件相同时，要判断一下次要条件
集合框架_二叉树
TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法
TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。
在集合初始化时，定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
当两种排序都存在时，以比较器为主
集合框架_实现Comparator方法排序
定义一个类，实现Comparator接口，覆盖compare方法
集合框架_TreeSet练习

public class TreeSetDemo {
    public static void main(String[] args){
        TreeSet ts = new TreeSet(new StrLenCompare());
        ts.add("aadgs");
        ts.add("sdfh");
        ts.add("dvgsrr");
        ts.add("sdcawe");
        ts.add("asdaaws");

    Iterator it = ts.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
  }
}
class StrLenCompare 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)
        return s1.compareTo(s2);
    return num;
  }
}