黑马程序员 7 集合容器(List&Set)

 

基本操作：增删改查(判断)

结构
Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍
慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不
同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--Set：元素是无序，元素不可以重复。
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素hashcode
和equals方法。
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：compareTo方法return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。

 

Collection定义了集合框架的共性功能。
1，添加
add(e);
addAll(collection);
2，删除
remove(e);
removeAll(collection);
clear();
3，判断。
contains(e);
isEmpty();
4，获取
iterator();
size();
5，获取交集。
retainAll();
6，集合变数组。
toArray();

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

增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();
=============================================================

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

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法获取。

import java.util.*;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> a =  new ArrayList<String>();
        a.add("1");
        a.add("2");
        a.add("3");
        a.add("4");
        ListIterator<String> li = a.listIterator();
        while(li.hasNext()){
            String str = li.next();
            System.out.println(str);
            if(str.equals("2")) li.add("2_1"); //在2后面插入2_1
            if(str.equals("3")) li.remove();   //移除3    
            if(str.equals("4")) li.set("5"); //把4改成5        
        }
        System.out.println(a);
    }
}

==============================================================
LinkedList示例

//用Linkedlist 模拟堆栈
import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        Stack<Integer> s = new Stack<Integer>(new LinkedList<Integer>());        
        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s);
    }
}

class Stack<T>{
    private LinkedList<T> list;
    Stack(LinkedList<T> list){
        this.list = list;
    }
    public void push(T data){
        list.addLast(data);
    }
    public T pop(){
        return list.removeLast();   //返回并移除最后的元素
    }
    @Override
    public String toString(){
        return list.toString();        
    }    
}

=================================================
HashSet判断元素相同 例

import java.util.*;
/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
public class HashSetTest 
{
    public static void main(String[] args) 
    {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));
        Iterator it = hs.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 int hashCode()
    {
        System.out.println(this.name+"....hashCode");
        return name.hashCode()+age*37;      //防止出现name和age都不同，但是

name.hashCode()+age相同的情况。37可以是其他整数
    }

    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }
    
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

 

==========================================
TreeSet
对类实现Comparable接口进行顺序判断

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<Person>();
        ts.add(new Person("c",10));
        ts.add(new Person("a",10));
        ts.add(new Person("b",10));
        System.out.println(ts);
        
    }
}

class Person implements Comparable<Person>{
    private String name;
    private int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public int compareTo(Person p){
        if(this.name == p.name)
            return new Integer(this.age).compareTo(new Integer(p.age));
        else return this.name.compareTo(p.name);
    }
    public String toString(){
        return name +"的年龄是"+age;
    }
}

 

使用自定义的比较器进行顺序判断

import java.util.*;

public class TreeTest {
    public static void main(String[] arg){
        TreeSet<String> ts = new TreeSet<String>(new StrLenComparator());
        ts.add("100");
        ts.add("dadadadad");
        ts.add("a");
        ts.add("cdd");
        ts.add("d");
        Iterator<String> it = ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }    
        System.out.println(ts);
    }
}

class StrLenComparator implements Comparator<String>{
    @Override
    public int compare(String s1,String s2){
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num == 0) return s1.compareTo(s2);
        return num;
    }
}