目录

Collection集合

1.常用方法

2.使用Iterator接口遍历集合元素

3.使用foreach循环遍历集合元素

4.Set集合

4.1 HashSet类

4.2 LinkedHashSet类 

4.3 TreeSet类 

 4.4 EnumSet类

 5. List接口

5.1 ListIteractor接口

5.2 Stack类 

5.3 Arrays.ArrayList 

5.4 LinkedList类

6. Queue集合

6.1 PriorityQueue实现类

6.2 Deque接口 

---

Collection集合

 

1.常用方法

Collection接口里定义了如下操作集合元素的方法。

boolean add(Object o)：该方法用于向集合里添加一个元素。如果集合对象被添加操作改变了，则返回true。

boolean addAll(Collection c)：该方法把集合c里的所有元素添加到指定集合里。如果集合对象被添加操作改变了，则返回true。

void clear()：清除集合里的所有元素，将集合长度变为0。

boolean contains(Object o)：返回集合里是否包含指定元素。

boolean isEmpty()：返回集合是否为空。当集合长度为0时返回true，否则返回false。

Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object o)：删除集合中的指定元素o，当集合中包含了一个或多个元素o时，这些元素将被删除，该方法将返回true。

boolean remove(Object o)：删除集合中的指定元素o，当集合中包含了一个或多个元素o时，这些元素将被删除，该方法将返回true。

boolean removeAll(Collection c)：从集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，则该方法返回true。

boolean removeAll(Collection c)：从集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，则该方法返回true。

boolean retainAll(Collection c)：从集合中删除集合c里不包含的元素（相当于把调用该方法的集合变成该集合和集合c的交集），如果该操作改变了调用该方法的集合，则该方法返回true。

int size()：该方法返回集合里元素的个数。

Object[] toArray()：该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素。

2.使用Iterator接口遍历集合元素

import java.util.Iterator;

Iterator it=cities.iterator();
while(it.hasNext())
{
 
}

package Text;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class LearnText {
    public static void main(String[] args)
    {
        //创建一个集合
        Collection cities=new HashSet();
        cities.add("北京");
        cities.add("上海");
        cities.add("广州");
        cities.add("深圳");
        //获取集合对应的迭代器
        Iterator it=cities.iterator();
        while(it.hasNext())
        {
            String city=(String)it.next();
            System.out.println(city);
        }
    }
}

3.使用foreach循环遍历集合元素

for(Object obj:cities) {

}

package Text;

import java.util.Collection;
import java.util.HashSet;

public class LearnText {
    public static void main(String[] args)
    {
        //创建一个集合
        Collection cities=new HashSet();
        cities.add("北京");
        cities.add("上海");
        cities.add("广州");
        cities.add("深圳");
        //foreach
        for(Object obj:cities) {
            String city = (String)obj;
            System.out.println(city);
        }
    }
}

4.Set集合

4.1 HashSet类

HashSet cities=new HashSet();

package Text;

import java.util.Collection;
import java.util.HashSet;

//类A的equals()方法总是返回true，但没有重写其hashCode()方法
class A
{
    public boolean equals(Object obj)
    {
        return true;
    }
}
//类B的hashCode()方法总是返回1，但没有重写其equals()方法
class B
{
    public int hashCode()
    {
        return 1;
    }
}
//类C的hashCode()方法总是返回2，且重写了其equals()方法
class C
{
    public int hashCode()
    {
        return 2;
    }
    public boolean equals(Object obj)
    {
        return true;
    }
}

public class LearnText {
    public static void main(String[] args)
    {
        HashSet cities=new HashSet();
        //分别向books集合中添加两个A对象、两个B对象、两个C对象
        cities.add(new A());
        cities.add(new A());
        cities.add(new B());
        cities.add(new B());
        cities.add(new C());
        cities.add(new C());
        System.out.println(cities);
    }
}

 

从上面程序可以看出，即使两个A对象通过equals()方法比较返回true，但HashSet依然把它们当成两个对象；即使两个B对象的hashCode()返回相同值（都是1），但HashSet依然把它们当成两个对象。

当把一个对象放入HashSet中时，如果需要重写该对象对应类的equals()方法，则也应该重写其hashCode()方法。其规则是：如果两个对象通过equals()方法比较返回true，这两个对象的hashCode值也应该相同。 

4.2 LinkedHashSet类 

HashSet还有一个子类LinkedHashSet，LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。

LinkedHashSet cities=new LinkedHashSet();

package Text;

import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;

public class LearnText {
    public static void main(String[] args)
    {
        //创建一个集合
        LinkedHashSet cities=new LinkedHashSet();
        cities.add("北京");
        cities.add("上海");
        cities.add("广州");
        cities.add("深圳");
        //foreach
        for(Object obj:cities) {
            String city = (String)obj;
            System.out.println(city);
        }
    }
}

 

4.3 TreeSet类 

TreeSet是SortedSet接口的实现类，正如SortedSet名字所暗示的，TreeSet可以确保集合元素处于排序状态。与HashSet集合相比，TreeSet还提供了如下几个额外的方法。

Comparator comparator()：如果TreeSet采用了定制排序，则该方法返回定制排序所使用的Comparator；如果TreeSet采用了自然排序，则返回null。

Object first()：返回集合中的第一个元素。

Object lower(Object e)：返回集合中位于指定元素之前的元素（即小于指定元素的最大元素，参考元素不需要是TreeSet集合里的元素）。

Object higher (Object e)：返回集合中位于指定元素之后的元素（即大于指定元素的最小元素，参考元素不需要是TreeSet集合里的元素）。

SortedSet subSet(fromElement, toElement)：返回此Set的子集合，范围从fromElement（包含）到toElement（不包含）。

SortedSet headSet(toElement)：返回此Set的子集，由小于toElement的元素组成。

SortedSet tailSet(fromElement)：返回此Set的子集，由大于或等于fromElement的元素组成。

TreeSet nums=new TreeSet();

package Text;

import java.util.TreeSet;

public class LearnText {
    public static void main(String[] args)
    {
        TreeSet nums=new TreeSet();
        //向TreeSet中添加四个Integer对象
        nums.add(5);
        nums.add(2);
        nums.add(10);
        nums.add(-9);
        //输出集合元素，看到集合元素已经处于排序状态
        System.out.println(nums);
        //输出集合里的第一个元素
        System.out.println(nums.first());
        //输出集合里的最后一个元素
        System.out.println(nums.last());
        //返回小于4的子集，不包含4
        System.out.println(nums.headSet(4));
        //返回大于5的子集，如果Set中包含5，子集中也包含5
        System.out.println(nums.tailSet(5));
        //返回大于等于-3、小于4的子集
        System.out.println(nums.subSet(-3 , 4));
    }
}

 

 4.4 EnumSet类

EnumSet类没有暴露任何构造器来创建该类的实例，程序应该通过它提供的static方法来创建EnumSet对象。EnumSet类它提供了如下常用的static方法来创建EnumSet对象。

static EnumSet allOf(Class elementType)：创建一个包含指定枚举类里所有枚举值的EnumSet集合。

static EnumSet complementOf(EnumSet s)：创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合，新EnumSet集合包含原EnumSet集合所不包含的、此枚举类剩下的枚举值（即新EnumSet集合和原EnumSet集合的集合元素加起来就是该枚举类的所有枚举值）。

static EnumSet copyOf(Collection c)：使用一个普通集合来创建EnumSet集合。

static EnumSet of(E first, E... rest)：创建一个包含一个或多个枚举值的EnumSet集合，传入的多个枚举值必须属于同一个枚举类。

static EnumSet range(E from, E to)：创建一个包含从from枚举值到to枚举值范围内所有枚举值的EnumSet集合。

package Text;

import java.util.EnumSet;

public class LearnText {
    enum Season
    {
        SPRING,SUMMER,FALL,WINTER
    }
    public static void main(String[] args)
    {
        //创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值
        EnumSet es1=EnumSet.allOf(Season.class);
        System.out.println(es1);
        //创建一个EnumSet空集合，指定其集合元素是Season类的枚举值
        EnumSet es2=EnumSet.noneOf(Season.class);
        System.out.println(es2);
        //手动添加两个元素
        es2.add(Season.WINTER);
        es2.add(Season.SPRING);
        System.out.println(es2);
        //以指定枚举值创建EnumSet集合
        EnumSet es3=EnumSet.of(Season.SUMMER , Season.WINTER);
        System.out.println(es3);
        //区间
        EnumSet es4=EnumSet.range(Season.SUMMER , Season.WINTER);
        System.out.println(es4);
        //除去
        EnumSet es5=EnumSet.complementOf(es4);
        System.out.println(es5);
    }
}

 5. List接口

List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

List作为Collection接口的子接口，当然可以使用Collection接口里的全部方法。而且由于List是有序集合，因此List集合里增加了一些根据索引来操作集合元素的方法。

void add(int index, Object element)：将元素element插入到List集合的index处。

boolean addAll(int index, Collection c)：将集合c所包含的所有元素都插入到List集合的index处.

Object get(int index)：返回集合index索引处的元素。

int indexOf(Object o)：返回对象o在List集合中第一次出现的位置索引。

int lastIndexOf(Object o)：返回对象o在List集合中最后一次出现的位置索引。

Object remove(int index)：删除并返回index索引处的元素。

Object set(int index, Object element)：将index索引处的元素替换成element对象，返回新元素

List subList(int fromIndex, int toIndex)：返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合。

package Text;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class LearnText {
    public static void main(String[] args)
    {
        List cities = new ArrayList();
        //add
        cities.add("北京");
        cities.add("上海");
        cities.add("广州");
        System.out.println(cities);
        //addAll
        cities.addAll(3, Collections.singleton("深圳"));
        System.out.println(cities);
        //get
        System.out.println("索引为0处的值为："+cities.get(0));
        //indexof
        System.out.println("北京的索引为："+cities.indexOf("北京"));
        //lastIndex
        System.out.println("北京的索引为："+cities.lastIndexOf("北京"));
        //remove
        cities.remove("深圳");
        System.out.println(cities);
        //set
        cities.set(2,"深圳");
        System.out.println(cities);
        //subList
        System.out.println(cities.subList(0,1));
    }
}

 

5.1 ListIteractor接口

与Set只提供了一个iterator()方法不同，List还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口基础上增加了如下方法。

boolean hasPrevious()：返回该迭代器关联的集合是否还有上一个元素。

Object previous()：返回该迭代器的上一个元素。

void add()：在指定位置插入一个元素。

5.2 Stack类 

Vector还提供的一个Stack子类，它用于模拟“栈”这种数据结构。

Object peek()：返回“栈”的第一个元素，但并不将该元素“pop”出栈。

Object pop()：返回“栈”的第一个元素，并将该元素“pop”出栈。 

void push(Object item)：将一个元素“push”进栈，最后一个进“栈”的元素总是位于“栈”顶。

package Text;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;

public class LearnText {
    public static void main(String[] args)
    {
        Stack cities = new Stack();
        //push
        cities.push("北京");
        cities.push("上海");
        cities.push("广州");
        cities.push("深圳");
        System.out.println(cities);
        //pop
        cities.pop();
        System.out.println(cities);
        //peek
        cities.peek();
        System.out.println(cities);
    }
}

 

5.3 Arrays.ArrayList 

Arrays.ArrayList是一个固定长度的List集合，程序只能遍历访问该集合里的元素，不可增加、删除该集合里的元素。

5.4 LinkedList类

LinkedList类是List接口的实现类——这意味着它是一个List集合，可以根据索引来随机访问集合中的元素。除此之外，LinkedList还实现了Deque接口，因此它可以被当成双端队列来使用，自然也可以被当成“栈”来使用了。

package Text;

import java.util.LinkedList;

public class LearnText {
    public static void main(String[] args) {
        LinkedList cities=new LinkedList();
        //将字符串元素加入队列的尾部
        cities.offer("北京");
        //将一个字符串元素加入栈的顶部
        cities.push("上海");
        //将字符串元素添加到队列的头部（相当于栈的顶部）
        cities.offerFirst("广州");
        for (int i=0; i < cities.size() ; i++ )
        {
            System.out.println(cities.get(i));
        }
        System.out.println("------------");
        //访问但不删除栈顶的元素
        System.out.println(cities.peekFirst());
        //访问但不删除队列的最后一个元素
        System.out.println(cities.peekLast());
        //将栈顶的元素弹出“栈”
        System.out.println(cities.pop());
        //下面输出将看到队列中第一个元素被删除
        System.out.println(cities);
        //访问并删除队列的最后一个元素
        System.out.println(cities.pollLast());
        //下面输出将看到队列中只剩下中间一个元素：
        System.out.println(cities);
    }
}

 

 

6. Queue集合

Queue用于模拟队列这种数据结构，队列通常是指“先进先出”（FIFO）的容器。队列的头部保存在队列中存放时间最长的元素，队列的尾部保存在队列中存放时间最短的元素。新元素插入（offer）到队列的尾部，访问元素（poll）操作会返回队列头部的元素。通常，队列不允许随机访问队列中的元素。

void add(Object e)：将指定元素加入此队列的尾部。

Object element()：获取队列头部的元素，但是不删除该元素。 

boolean offer(Object e)：将指定元素加入此队列的尾部。当使用有容量限制的队列时，此方法通常比add(Object e)方法更好。

Object peek()：获取队列头部的元素，但是不删除该元素。如果此队列为空，则返回null。Object poll()：获取队列头部的元素，并删除该元素。如果此队列为空，则返回null。 

Object remove()：获取队列头部的元素，并删除该元素。

6.1 PriorityQueue实现类

PriorityQueue是一个比较标准的队列实现类。之所以说它是比较标准的队列实现，而不是绝对标准的队列实现，是因为PriorityQueue保存队列元素的顺序并不是按加入队列的顺序，而是按队列元素的大小进行重新排序。因此当调用peek()方法或者poll()方法取出队列中的元素时，并不是取出最先进入队列的元素，而是取出队列中最小的元素。从这个意义上来看，PriorityQueue已经违反了队列的最基本规则：先进先出（FIFO）。

package Text;

import java.util.*;

public class LearnText {
        public static void main(String[] args)
        {
            PriorityQueue pq=new PriorityQueue();
            //下面代码依次向pq中加入四个元素
            pq.offer(6);
            pq.offer(-3);
            pq.offer(9);
            pq.offer(0);
            //输出pq队列，并不是按元素的加入顺序排列
            //而是按元素的大小顺序排列，输出[-3, 0, 9, 6]
            System.out.println(pq);
            //访问队列的第一个元素，其实就是队列中最小的元素：-3
            System.out.println(pq.poll());
        }
}

6.2 Deque接口 

Deque接口是Queue接口的子接口，它代表一个双端队列。

void addFirst(Object e)：将指定元素插入该双端队列的开头。

void addLast(Object e)：将指定元素插入该双端队列的末尾。

Iterator descendingIterator()：返回该双端队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素。

Object getFirst()：获取但不删除双端队列的第一个元素。

Object getLast()：获取但不删除双端队列的最后一个元素。

boolean offerFirst(Object e)：将指定元素插入该双端队列的开头。

boolean offerLast(Object e)：将指定元素插入该双端队列的末尾。

Object peekFirst()：获取但不删除该双端队列的第一个元素；如果此双端队列为空，则返回null。

Object peekLast()：获取但不删除该双端队列的最后一个元素；如果此双端队列为空，则返回null。

Object pollFirst()：获取并删除该双端队列的第一个元素；如果此双端队列为空，则返回null。

Object pollLast()：获取并删除该双端队列的最后一个元素；如果此双端队列为空，则返回null。

Object pop()（栈方法）：pop出该双端队列所表示的栈的栈顶元素。相当于removeFirst()。

void push(Object e)（栈方法）：将一个元素push进该双端队列所表示的栈的栈顶。相当于addFirst(e)。

Object removeFirst()：获取并删除该双端队列的第一个元素。[插图] Object removeFirstOccurrence(Object o)：删除该双端队列的第一次出现的元素o。

ArrayDeque 

与前面使用Stack的运行结果相似，ArrayDeque的性能会更加出色，程序中需要使用“栈”这种数据结构时，推荐使用ArrayDeque或LinkedList，而不是Stack。