即日起在codingBlog上分享您的技术经验即可获得积分,积分可兑换现金哦。

Java语言之集合学习与进阶

编程语言 Y_L_X_P 18℃ 0评论
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 number=new ArrayList<>();
    static List 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 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 list=new ArrayList<>();
        list.add("西游记");
        list.add("红楼梦");
        list.add("三国演义");
        list.add("水浒传");
        list.add("金瓶梅");        
        Stack 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 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 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 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 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{

    @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 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 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接口。

转载请注明:CodingBlog » Java语言之集合学习与进阶

喜欢 (0)or分享 (0)
发表我的评论
取消评论

*

表情