Java基础-集合

Java集合

Java基础第二篇-集合

1 集合概述

集合类主要由两个接口派生：Collection和Map

Set:无序集合，不可重复

Queue:队列

List:有序集合，可以重复

2.Collection和Iterator接口

Collection接口是List Set Queue接口的父接口，常用的有以下方法：

boolean add(Object o):添加元素

boolean addAll(Collection c):把集合中所有元素添加到指定集合中,集合对象被改变了，则返回true

void clear(): 清除集合所有元素

boolean contains(Object c):返回集合是否包含指定元素

boolean containsAll(Collection c):返回集合是否包含c中所有元素

boolean isEmpty():返回集合是否为空

boolean remove(Object c):删除指定元素

boolean removeAll(Collection c):从集合中删除集合c包含的所有元素

boolean retainAll(Collection c):从集合中删除集合c不包含的元素

int size():返回集合元素个数

Object[] toArray():把集合转换成数组

一个小例子：

public class CollectionTest {

    public static void main(String[] args) {

        Collection c = new ArrayList();

        c.add("aaa");

        c.add(6);

        System.out.println("c集合的元素个数为：" + c.size());

        c.remove(6);

        System.out.println("c集合元素个数为:" + c.size());

        System.out.println("c集合是否包含'aaa':" + c.contains("aaa"));

        c.add("从零开始学Java");

        Collection books = new HashSet();

        books.add("从零开始学Java");

        books.add("从零开始学Python");

        System.out.println("集合c是否完全包含集合books:" + c.containsAll(books));

        c.removeAll(books);

        System.out.println("c集合去掉books后的元素：" + c);

        books.retainAll(c);

        System.out.println("books集合和c集合的交集元素：" + books);

    }

}

3.Iterator

Iterator:迭代器，主要用于遍历集合中的元素

boolean hasNext()

Object next()

void remove()

例子：

public class IteratorTest {

    public static void main(String[] args) {

        Collection books = new HashSet();

        books.add("aaa");

        books.add("bbb");

        books.add("ccc");

        Iterator it = books.iterator();

        while (it.hasNext()){

            String book = (String) it.next();

            System.out.println(book);

            if (book.equals("aaa")) it.remove();
        }
    }
}

注意：Iterator必须依附于Collection。

4.Set集合

Set集合不允许添加相同元素，判断方法是：equals，因此我们看看以下这个例子

public class SetTest {

    public static void main(String[] args) {

        Set books = new HashSet();

        books.add("aaa");

        boolean result = books.add("aaa");

        System.out.println(result + "--->" + books);
    }
}

打印结果为：

false--->[aaa]

因为这两个String不是同一个对象，==返回结果为false，但是Set中判断方式是equals，所以返回的是true,Set中最终只有一个aaa

HashSet类

通过hashCode()方法得到hashCode值，然后再决定存储位置。

HashSet判断两个元素相等标准是 equals()和hashCode()同时相同

特点：

> 不能保证元素的排列顺序，顺序可能会发生变化

> HashSet不是同步的

> 集合元素值可以是null

举个例子：

public class HashSetTest {

    public static void main(String[] args) {
        HashSet books = new HashSet();
        books.add(new A());
        books.add(new A());
        books.add(new B());
        books.add(new B());
        books.add(new C());
        books.add(new C());
        System.out.println(books);
    }
}
class A
{
    public boolean equals(Object c)
    {
        return true;
    }
}
class B
{
    public int hashCode()
    {
        return 1;
    }
}
class C
{
    public int hashCode() {
        return 2;
    }
    public boolean equals(Object c)
    {
        return true;
    }
}

输出结果：

[collection.A@5e2de80c, collection.B@1, collection.B@1, collection.C@2, collection.A@60e53b93]

两个A对象，两个B对象，一个C对象

说明只有equals()或者hashCode()相等，还是HashSet仍然把他们当成两个对象

TreeSet类

特点：确保集合元素处于排序状态。

常见方法：

    public static void main(String[] args) {

        TreeSet nums = new TreeSet();

        nums.add(5);

        nums.add(2);

        nums.add(10);

        nums.add(-2);

        System.out.println(nums);

        System.out.println("第一个元素：" + nums.first() +" 最后一个元素：" +  nums.last());

        System.out.println("小于4的元素集合：" + nums.headSet(4));

        System.out.println("大于5的元素集合：" + nums.tailSet(5));

        System.out.println("-5到2的集合: " + nums.subSet(-5,2));

    }
}

输出结果：

[-2, 2, 5, 10]
第一个元素：-2 最后一个元素：10
小于4的元素集合：[-2, 2]
大于5的元素集合：[5, 10]
-5到2的集合: [-2]

5 List集合

常见方法：

 public class ListTest {

    public static void main(String[] args) {

        List books = new ArrayList();

        books.add("aaa");
        books.add("bbb");
        books.add("ccc");

        System.out.println(books);

        books.add(1,"ddd"); // 在第二个位置插入ddd
        for (int i=0;i<books.size();i++)

        {
            System.out.println(books.get(i));
        }

        //删除第三个元素
        books.remove(2);

        System.out.println(books);

        //判断指定元素的位置
        System.out.println(books.indexOf("bbb"));

        books.set(1,"eee"); // 将第二个位置替换成eee

        System.out.println(books);
    }
}

6.Queue集合

特点：Queue用于模拟队列这种数据结构，具有FIFO-先进先出的特点。

常见方法：

void add(Object c): 指定元素加入队列尾部

Object element(): 获取队列头部元素

boolean offer(Object c): 将指定元素加入队列尾部

Object peek(): 获取队列头部元素

Object poll(): 获取队列头部元素，并删除

Object remove():删除队列头部元素

7.Map

特点：用于保存具有映射关系的数据，通常以键值对的形式存在.

HashMap和Hashtable实现类

Hashtable是线程安全的，但是HashMap是线程不安全的。

Hashtable不允许使用null作为key和value，但是HashMap可以

注意：key是唯一不可重复的

8.操作集合的工具类：Collections

排序操作：

static void reverse(List list)：反转

static void shuffle(List list):随机排序

static void sort(List list):升序排序

static void sort(List list, Comparator c)：根据Comparator产生的顺序排序

static void swap(List list,int i,int j):将i和j元素交换

static void rotate(List list,int distance):将后distance元素往前移

查找、替换操作

static int binarySearch(List list,Object key)：二分查找(必须保证有序)

static Object max(Collection coll):找出最大值

static Object min(Collection coll):找出最小值

static void fill(List list,Object obj):指定元素obj替换List所有元素

static int frequency(Collection c,Object c):返回指定元素出现次数

static int indexOfSubList(List source,List target):返回子List对象在父List第一次出现的位置

static int lastIndexOfSubList(List source,List target):返回子List对象在父List最后一次出现的位置

static boolean replaceAll(List list,Object oldVal,Object newVal):替换

同步控制

Collections提供了多个synchronizedXxx()方法，用于把集合包装成线程同步的集合，从而解决多线程并发访问的安全问题。

例子：

public class SynchroinizedTest {

    public static void main(String[] args) {

        Collection c = Collections.synchronizedCollection(new ArrayList<>());

        List list = Collections.synchronizedList(new ArrayList<>());

        Set s = Collections.synchronizedSet(new HashSet<>());

        Map m = Collections.synchronizedMap(new HashMap<>());
    }
}