集合

最新推荐文章于 2023-06-14 11:43:27 发布

daversun

最新推荐文章于 2023-06-14 11:43:27 发布

阅读量178

点赞数

分类专栏： javase

本文链接：https://blog.csdn.net/zhaoliyou/article/details/54599972

版权

javase 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

java集合大致简介：

大致分为List,Set,Queue,Map ,其中List代表有序的可重复的集合，Set代表无序，不可以重复的集合，Queue代表队列，Map代表有映射关系的集合，java集合就是一种盛放对象的容器，记住只能盛放对象，他不同于数组还可以放基本类型。

java集合继承体系：

java集合主要由两个接口进行派生出来，Collection或者Map，下面Collection的继承树
这里写图片描述
图一
下面是Map的继承树

图二

图三
从图三可以看出，List元素可以通过index进行获取，而Map可以通过其键值进行获取，Set只可以通过元素本身进行获取，这也就是为什么Set元素不能重复的原因。

常用集合：

常用的集合包括，HashSet,TreeSet,ArrayList,ArrayQueue,LinkedList,HashMap和TreeMap

Collection&Iterator接口：

Collection相关API:

boolean add(Object obj);//添加集合中的元素，成功返回true
boolean addAll(Collection c);//把集合C中的元素全部放到集合中
void clear();//把集合进行清空
boolean contains(Object obj);//看该集合是否包含该对象
boolean containsAll(Collection c);//看是否包含c中的全部元素
boolean isEmpty();//返回集合是否为空
Iterator iterator();//返回一个Iterator对象，用于遍历集合里面的所有元素
boolean remove(Object obj);//把obj对象从集合中移除
boolean removeAll(Collection c);//从集合中移除c中包含的所有元素
boolean retainAll(Collection c);//从集合中移除c不包含的元素
int size();//返回包含的元素个数
Object[]toArray();//把集合中的所有元素变成数组

Iterator相关API

boolean hasNext();//判断集合里是否含有下面一个元素
Object next();//返回集合中的下一个元素
void remove();//从集合中移除上一次next的元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
class People{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public People(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "People [name=" + name + ", age=" + age + "]";
    }

}
public class Main {
    public static void main(String[] args) {
        Collection<People>c=new ArrayList<People>();
        People p1=new People("zhangsan", 12);
        People p2=new People("lisi", 13);
        People p3=new People("wangwu", 15);
        //添加元素
        c.add(p1);
        c.add(p2);
        c.add(p3);
        Iterator<People> it=c.iterator();
        while(it.hasNext()){
            People p=it.next();
            System.out.println(p);
            it.remove();
        }
        System.out.println(c.size());

    }

}

注意：

在用Iterator进行遍历集合的时候，不能改变集合中对象的数目，但是可以通过返回对象的引用，对对象的内容进行修改

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
class People{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public People(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "People [name=" + name + ", age=" + age + "]";
    }

}
public class Main {
    public static void main(String[] args) {
        Collection<People>c=new ArrayList<People>();
        People p1=new People("zhangsan", 12);
        People p2=new People("lisi", 13);
        People p3=new People("wangwu", 15);
        //添加元素
        c.add(p1);
        c.add(p2);
        c.add(p3);
        Iterator<People> it=c.iterator();
        while(it.hasNext()){
            People p=it.next();
            p.setName("nnn");
            p.setAge(55);
        }
        it=c.iterator();
        while(it.hasNext()){
            People p=it.next();
            c.add(new People("asd", 2));//将抛出异常
        }

    }

}

通过foreach对集合元素进行遍历：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
class People{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public People(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "People [name=" + name + ", age=" + age + "]";
    }

}
public class Main {
    public static void main(String[] args) {
        Collection<People>c=new ArrayList<People>();
        People p1=new People("zhangsan", 12);
        People p2=new People("lisi", 13);
        People p3=new People("wangwu", 15);
        //添加元素
        c.add(p1);
        c.add(p2);
        c.add(p3);
        for(People p:c){
            System.out.println(p);
        }

    }

}

注意：

同样不能在foreach中改变集合中对象的数目

Set(HashSet,TreeSet,EnumSet)

因为Set是继承自Collection，所以上面的API都同样适用于Set,只不过不能有重复元素，在进行add(Object obj)的时候，如果有重复元素则会返回false

HashSet

特点：

    1. 具有很好的查找和存取性能
    2. 不能保证排列顺序，可能与放入的顺序不同
    3. HashSet不是同步的，非线程安全
    4. 集合元素可以是NULL
    5. 集合判断元素是否相等时通过hascode和equals同时判断的，所以重写的时候，一般是两个方法同时重写

LinkedHashSet

特点：也是通过hashcode来计算存储位置，但是他还创建了一个链表来维护存入的顺序，所以性能比HashSet更低，但是遍历全部元素的时候，效率比较高。

TreeSet

继承于SortedSet,从名字上面可以看出，TreeSet与排序相关，他有两种排序方法，定制排序和自然排序。

自然排序：

   会自动调用元素的compareTo方法。
   判断两个元素是否相等的唯一方法是看compareTo(Object obj)是否返回0。
   虽然TreeSet是排序的集合，但是如果在中途改变了可变元素，可能导致集合中的元素无法移除，同时该集合也不是排序的了。

定制排序:

通过实现Comparator接口实现compare方法,在TreeSet构造器中与集合进行关联

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
class R implements Comparable<R>{
    Integer a;
    R(int a){
        this.a=a;
    }
    public int compareTo(R o) {
        R c=(R)o;
        return a-c.a;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return Integer.toString(a);
    }

}
class MyCompare implements Comparator<R>{
    @Override
    public int compare(R o1, R o2) {
        // TODO Auto-generated method stub
        return o1.a-o2.a;
    }
}
public class Main {
    public static void main(String[] args) {
        TreeSet<R>set=new TreeSet<R>(new MyCompare());
        set.add(new R(1));
        set.add(new R(2));
        System.out.println(set);
    }

}

EnumSet不怎么常用就不讲了

List:

list代表有序，可重复的集合，这里的有序指的是每个元素都有自己的索引。

下面是相关的API的使用：

package demo3;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
class MyCompare implements Comparator<R>{
    public int compare(R o1, R o2) {
        return o1.a-o2.a;
    }
}
class R{
    int a;
    R(int a){
        this.a=a;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return Integer.toString(a);
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        R c=(R) obj;
        return this.a==c.a;
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return this.a;
    }

}
public class MyTest {
    public static void main(String[]args){
        List list=new ArrayList<R>();
        list.add(new R(1));
        list.add(new R(2));
        list.add(new R(3));
        show(list);
        System.out.println("查看某元素第一次出现的index");
        System.out.println(list.indexOf(new R(1)));
        System.out.println("查看某元素最后一次次出现的index");
        list.add(1, new R(1));
        show(list);
        System.out.println("---------------------------------------");
        System.out.println(list.lastIndexOf(new R(1)));
        System.out.println("插入单个元素元素");
        list.add(1,new R(4));
        show(list);
        System.out.println("插入整个集合");
        List test=new ArrayList<R>();
        test.add(new R(10));
        test.add(new R(12));
        list.addAll(1,test);
        show(list);
        System.out.println("改变某个索引上对象的值");
        list.set(0, new R(45));
        show(list);
        System.out.println("从list中获取某一段");
        show(list.subList(1, 3));//后面是开区间
        System.out.println("进行排序,java8提供");
        list.sort(new MyCompare());
    }
    public static void show(List list){
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}
最后一个排序属于java8的内容，因为自身jdk的原因无法展示
1
2
3
查看某元素第一次出现的index
0
查看某元素最后一次次出现的index
1
1
2
3
---------------------------------------
1
插入单个元素元素
1
4
1
2
3
插入整个集合
1
10
12
4
1
2
3
改变某个索引上对象的值
45
10
12
4
1
2
3
从list中获取某一段
10
12

ListIterator extends Iterator:

除了包含Iterator提供的hasNext(),next(),remove()之外，还有以下API：
boolean hasPrevious();//判断是否还有上一个元素
Object previous();//返回上一个元素
void add(Object obj);//添加元素进入集合

ArrayList&Vector

ArrayList和Vector作为list的典型代表，前面的方法完全适用于这两个集合，他们在里面都封装了一个可以动态变化长度的数组，当然有方法可以设定这个长度值。
ArrayList是线程不同步的，Vector是线程同步的，所以vector的效率较低，平时尽量少用Vector,同时vector还有一个子类Stack，具有pop(),.push(),peek()方法，peek只获取栈顶元素，但是不会出栈,我们一般采用ArrayDeque来代替栈，因为这个效率更高。

Queue:

队列，先进先出，有关API使用方法：

package demo3;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Queue;
import java.util.Set;
class R {
    int a;
    R(int a){
        this.a=a;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return Integer.toString(a);
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        R c=(R) obj;
        return this.a==c.a;
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return this.a;
    }

}
public class MyTest {
    public static void main(String[]args){
        Queue q=new ArrayDeque();
        System.out.println("入队");
        q.add(new R(1));
        System.out.println("获取头部元素但是不删除该元素,当队为空的时候将抛出异常");
        R temp=(R) q.element();
        System.out.println(temp);
        System.out.println("入队，当队有容量限制的时候，用该方法");
        q.offer(new R(4));
        System.out.println("获取头部元素但是不删除该元素,当队为空的时返回NULL");
        temp=(R) q.peek();
        System.out.println(temp);
        System.out.println("获取头部元素且删除该元素,当队为空的时返回NULL");
        temp=(R) q.poll();
        System.out.println(temp);
        System.out.println("获取头部元素且删除该元素,当队为空的时将抛出异常");
    }
}

PriorityQueue:优先级队列，优先级的规则，可以通过前面所讲过的自然排序和定制排序。

Map：

   具有两个典型的实现类，HashMap（线程不安全）,HashTable（线程安全）,相关API通过查阅文档来获取
   Map中Key相等的标准：hashcode和Equals,都需要返回true，而Value只需要equals返回true即可,不要去改变Key值，否则也会出现和HashSet一样想不到的后果。
   Collections里面还有很多工具类，可以查看相关的API文档