Java之集合学习

Collection
|-List
  |-ArrayList
  |-LinkedList
  |-Vector
    |-Stack
|-Set
  |-HashSet
  |-TreeSet
  |-LinkedHashSet
|-Queue

1、Collection
Collection是所有集合的根接口，JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。
2、List
List是一个接口，有序，可以对元素的插入位置进行控制，元素可重复
2.1 ArrayList
实现List接口，有序，可重复，实现不同步，即多线程操作该ArrayList实例会造成数据不统一的现象。底层为数组

class Number implements Runnable{
    //static List<Integer> number=new ArrayList<>();
    static List<Integer> number=Collections.synchronizedList(new ArrayList<>());
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            number.add(i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

public class Text extends Number{

    public static void main(String[] args) throws InterruptedException {
        Number n=new Number();
        Thread thread1=new Thread(n);
        Thread thread2=new Thread(n);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
        System.out.println(number);
    }

}

2.2 LinkedList
实现List接口，有序，可重复，实现不同步（与ArrayList相同），不同在于底层为链表（对两者不同操作的开销不同）
2.3 Vector
实现List接口，动态数组，线程同步

public class Text {
    public static void main(String[] args) {
    Vector<String> vector=new Vector<>();
    String string=new String("Hello");
    vector.add("你好");
    vector.add("哦还有");
    vector.add("哈梅雷");
    vector.add("啊你哈噻有");
    System.out.println(vector);
    vector.insertElementAt(string, 1);
    vector.remove(2);
    System.out.println(vector);
    }
}
output:
[你好, 哦还有, 哈梅雷, 啊你哈噻有]
[你好, Hello, 哈梅雷, 啊你哈噻有]

2.4 Stack
继承Vector，数据结构中的栈，先进后出

public class Text {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("西游记");
        list.add("红楼梦");
        list.add("三国演义");
        list.add("水浒传");
        list.add("金瓶梅");        
        Stack<String> books=new Stack<>();
        for(int i=0;i<5;i++){
            books.push(list.get(i));
        }
        for(String book : books){
            System.out.println(book);
        }
        System.out.println("---------");
        if(!books.isEmpty()){
            System.out.println("foreach后Stack不为空");
        }
        System.out.println("---------");
        while(!books.isEmpty()){
            System.out.println(books.pop());
        }
        System.out.println("---------");
        if(books.isEmpty()){
            System.out.println("pop后Stack为空");
        }
    }

}

/*
output：
西游记
红楼梦
三国演义
水浒传
金瓶梅
---------
foreach后Stack不为空
---------
金瓶梅
水浒传
三国演义
红楼梦
西游记
---------
pop后Stack为空
*/

3、Set
接口，无重复（不存在满足e1.equals(e2)的元素对），最多包含一个null元素。
3.1 HashSet
实现Set接口，无序，实现不同步，底层为HashMap，添加对象时，要重写hashCode()和equals()方法

class Tea{
    private String color;
    private int price;

    public Tea(String color,int price){
        this.color=color;
        this.price=price;
    }

    public String getColor() {
        return color;
    }
    public int getPrice() {
        return price;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((color == null) ? 0 : color.hashCode());
        result = prime * result + price;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Tea other = (Tea) obj;
        if (color == null) {
            if (other.color != null)
                return false;
        } else if (!color.equals(other.color))
            return false;
        if (price != other.price)
            return false;
        return true;
    }

}

public class Text {
    public static void main(String[] args) {
        HashSet<Tea> hashTea=new HashSet<>();

        hashTea.add(new Tea("红", 5));
        hashTea.add(new Tea("绿", 6));
        hashTea.add(new Tea("白", 3));
        hashTea.add(new Tea("红", 5));
        hashTea.add(new Tea("绿", 5));

        Iterator<Tea> it=hashTea.iterator();
        while(it.hasNext()){
            Tea tea=(Tea) it.next();
            System.out.println(tea.getColor()+"tea："+tea.getPrice()+"块");
        }
    }
}
/*output:
绿tea：6块
绿tea：5块
白tea：3块
红tea：5块
//去掉equals()或hashCode()后：
白tea：3块
绿tea：5块
红tea：5块
绿tea：6块
红tea：5块
*/

3.2 TreeSet
底层为TreeMap，实现不同步，可排序但需要有排序规则（String，Integer等拥有自己的排序规则，自己写的类也要自己定义规则）。
排序两种方案：
1、使用TreeSet()构造方法，需要添加的元素实现Comparable接口

class Tree implements Comparable{
    private String type;
    private int age;
    public Tree(String type,int age){
        this.type=type;
        this.age=age;
    }
    public String getType() {
        return type;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Object obj) {
        Tree tree=(Tree) obj;
        if(tree.age < this.age){
            return -1;
        }
        if(tree.age > this.age){
            return 1;
        }
        if(tree.age == this.age){
            return this.type.compareTo(tree.type);
        }
        return 0;
    }

}

public class Text {
    public static void main(String[] args) {
        Set<Tree> set=new TreeSet<>();

        Tree tree1=new Tree("杨树", 15);
        Tree tree2=new Tree("榆树", 20);
        Tree tree3=new Tree("松树", 25);
        Tree tree4=new Tree("朴树", 25);
        Tree tree5=new Tree("直上春树", 20);

        set.add(tree1);
        set.add(tree2);
        set.add(tree3);
        set.add(tree4);
        set.add(tree5);

        Iterator<Tree> iterator=set.iterator();
        while(iterator.hasNext()){
            Tree tree=iterator.next();
            System.out.println(tree.getType()+": "+tree.getAge()+"岁了");
        }
    }
}
/*output：
朴树: 25岁了
松树: 25岁了
榆树: 20岁了
直上春树: 20岁了
杨树: 15岁了
*/

2、使用TreeSet(Comparator<？> comparator)构造方法，自定义一个比较器

class Tree {
    private String type;
    private int age;
    public Tree(String type,int age){
        this.type=type;
        this.age=age;
    }
    public String getType() {
        return type;
    }

    public int getAge() {
        return age;
    }

}
class MyCompare implements Comparator<Tree>{

    @Override
    public int compare(Tree t1, Tree t2) {
        if(t1.getAge() < t2.getAge()){
            return 1;
        }
        if(t1.getAge() > t2.getAge()){
            return -1;
        }
        if(t1.getAge() == t2.getAge()){
            return t1.getType().compareTo(t2.getType());
        }
        return 0;
    }

}
public class Text {
    public static void main(String[] args) {
        Set<Tree> set=new TreeSet<>(new MyCompare());

        Tree tree1=new Tree("杨树", 15);
        Tree tree2=new Tree("榆树", 20);
        Tree tree3=new Tree("松树", 25);
        Tree tree4=new Tree("朴树", 25);
        Tree tree5=new Tree("直上春树", 20);

        set.add(tree1);
        set.add(tree2);
        set.add(tree3);
        set.add(tree4);
        set.add(tree5);

        Iterator<Tree> iterator=set.iterator();
        while(iterator.hasNext()){
            Tree tree=iterator.next();
            System.out.println(tree.getType()+": "+tree.getAge()+"岁了");
        }
    }
}
/*output：
朴树: 25岁了
松树: 25岁了
榆树: 20岁了
直上春树: 20岁了
杨树: 15岁了
*/

4、Queue
接口，数据结构中的队列，先进先出，LinkedList实现了Deque接口，Deque接口继承Queue接口。