Java学习（12）—— 集合

目录

一.Collection

   1.Collcetion中的常用方法

   2.List 

   3.Set

二.Map

    1.HashMap

    2.TreeMap

三.Collections工具类

Collection：存储一个一个的数据		Map：存储一对（key-value）一对的数据
List：元素有序、可重复的集合	Set：元素无序、不可重复的集合

一.Collection

   1.Collcetion中的常用方法

        ①add(Object obj)：将元素obj添加到当前集合中；

        ②size()：获取当前集合的大小

        ③isEmpty()：判断当前集合是否为空

        ④clear()：清空集合元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();

        //add(Object obj):将元素obj添加到集合当前集合中
        collection.add("AA");         //String
        collection.add(123);          //Integer
        collection.add(new Date());
        System.out.println(collection);

        //size():获取当前集合的大小
        System.out.println(collection.size());      //3

        //isEmpty():判断当前集合是否为空
        System.out.println(collection.isEmpty());   //false

        //clear():清空集合元素
        collection.clear();
        System.out.println(collection.size());      //0
        System.out.println(collection.isEmpty());   //true
    }
}

         ⑤addAll(Collection coll)：将coll中的所有元素添加到当前集合中

         ⑥contains(Object obj)：判断当前集合是否包含obj，在判断时会调用obj所在类的equals()，通常情况下向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()

         ⑦containsAll(Collection coll)：判断当前集合是否包含coll中的所有元素

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add(123);
        collection.add(new Date());
        collection.add(new String("BB"));

        Collection collection1 = new ArrayList();
        collection1.add("CC");
        collection1.add(456);

        //addAll(Collection coll):将coll中的所有元素添加到当前集合中
        collection.addAll(collection1);
        System.out.println(collection.size());   //6

        //contains(Object obj)：判断当前集合是否包含obj
        System.out.println(collection.contains(123));    //true
        System.out.println(collection.contains(new String("AA")));  //true，由于String类重写了equals()，所以比较的是内容，不是地址

        //containsAll(Collection coll)：判断当前集合是否包含coll中的所有元素
        Collection collection2 = Arrays.asList(123,456);
        System.out.println(collection.containsAll(collection2));  //true
    }
}

         ⑧remove(Object obj)：将当前集合中的obj移除

         ⑨removeAll(Collection coll)：从当前集合中移出coll包含的所有元素

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);

        System.out.println(collection);    //[AA, BB, 123, 456]

        //remove(Object obj)：将当前集合中的obj移除
        collection.remove(123);
        System.out.println(collection);    //[AA, BB, 456]

        //removeAll(Collection coll)：从当前集合中移出coll包含的所有元素
        Collection collection1 = Arrays.asList("AA","CC");
        collection.removeAll(collection1);
        System.out.println(collection);   //[BB, 456]
    }
}

         ⑩retainAll(Collection coll)：获取当前集合与coll的交集，并将交集返回给当前集合

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);
        System.out.println(collection);    //[AA, BB, 123, 456]

        //retainAll(Collection coll)：获取当前集合与coll的交集，并将交集返回给当前集合
        Collection collection1 = Arrays.asList("AA","CC",123);
        collection.retainAll(collection1);
        System.out.println(collection);   //[AA, 123]
        
    }
}

        ⑪equals(Object obj)：判断当前集合和形参集合中的元素是否相同（值相同且顺序相同）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);

        //equals(Object obj)：判断当前集合和形参集合中的元素是否相同（值相同且顺序相同）
        Collection collection1 = Arrays.asList("AA","BB",123,456);
        Collection collection2 = Arrays.asList("BB","AA",123,456);
        System.out.println(collection.equals(collection1));     //true
        System.out.println(collection.equals(collection2));     //false
    }
}

        ⑫hashCode()：返回当前对象的哈希值

        ⑬toArray()：将集合转化为数组

        ⑭Arrays.asList()：将数组转换为集合

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);

        //hashCode()：返回当前对象的哈希值
        System.out.println(collection.hashCode());

        //toArray()：将集合转化为数组
        Object[] array = collection.toArray();
        System.out.println(Arrays.toString(array));

        //Arrays.asList()：将数组转换为集合
        String[] array1 = new String[]{"AA","BB","CC"};
        System.out.println(Arrays.asList(array1));    //[AA, BB, CC]

        int[] array2 = new int[]{123,456};
        System.out.println(Arrays.asList(array2));   //地址值

        Integer[] array3 = new Integer[]{123,456};
        System.out.println(Arrays.asList(array3));   //[123, 456]
    }
}

        ⑮iterator()：返回Iterator接口的实例，用于遍历集合元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);

        Iterator iterator = collection.iterator();

        while(iterator.hasNext()){        //hasNext():判断集合中是否还有下一个元素
            System.out.println(iterator.next());   //next():指针下移，返回下移后集合上的元素
        }
    }
}

        ⑯iterator()中的remove()：删除集合中的元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);

        Iterator iterator = collection.iterator();

        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("AA".equals(obj)){
                iterator.remove();
            }
        }

        iterator = collection.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

        ⑰foreach循环：遍历集合、数组

import java.util.ArrayList;
import java.util.Collection;

public class Test{
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("AA");
        collection.add("BB");
        collection.add(123);
        collection.add(456);

        //for(集合元素的类型 局部变量 : 集合对象)
        for(Object obj : collection){
            System.out.println(obj);
        }


        int[] array = new int[]{1,2,3};
        //for(数组元素的类型 局部变量 : 数组对象)
        for(int i : array){
            System.out.println(i);
        }
    }
}

   2.List 

        ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[ ]存储；

        LinkedList：底层使用双向链表存储，对于频繁插入和删除操作，此实现类效率高；

        Vector： 作为List接口的古老实现类；线程安全，效率低；底层使用Object[ ]存储；

        除了Collection中的方法以外，还有以下常用方法：

             ①add(int index, Object element)：在index位置插入element元素

             ②addAll(int index, Collection coll)：在index位置开始插入coll中的所有元素

             ③get(int index)：获取index位置的元素

             ④indexOf(Object obj)：返回obj在集合中首次出现的位置

             ⑤lastIndexOf(Object obj)：返回obj在集合中末次出现的位置

             ⑥remove(int index)：移除指定index位置的元素，并返回此元素

             ⑦set(int index, Object element)：将index位置的元素设置为element

             ⑧subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex-1位置的子集合，[fromIndex, toIndex)

//以ArrayList为例
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(12);
        list.add(13);
        list.add("AA");
        list.add("BB");
        list.add(13);

        System.out.println(list);      //[12, 13, AA, BB, 13]

        //add(int index, Object element)：在index位置插入element元素
        list.add(4,"CC");
        System.out.println(list);     //[12, 13, AA, BB, CC, 13]

        //addAll(int index, Collection coll)：在index位置开始插入coll中的所有元素
        Collection collection = Arrays.asList(1,2,3);
        list.addAll(collection);
        System.out.println(list);     //[12, 13, AA, BB, CC, 13, 1, 2, 3]

        //get(int index)：获取index位置的元素
        System.out.println(list.get(1));    //13

        //indexOf(Object obj)：返回obj在集合中首次出现的位置
        System.out.println(list.indexOf(13));    //1

        //lastIndexOf(Object obj)：返回obj在集合中末次出现的位置
        System.out.println(list.lastIndexOf(13));   //5

        //remove(int index)：移除指定index位置的元素，并返回此元素
        Object obj = list.remove(6);
        System.out.println(obj);            //1
        System.out.println(list);           //[12, 13, AA, BB, CC, 13, 2, 3]

        //set(int index, Object element)：将index位置的元素设置为element
        list.set(4,"DD");
        System.out.println(list);          //[12, 13, AA, BB, DD, 13, 2, 3]

        //subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合,[fromIndex, toIndex)
        System.out.println(list.subList(2,4));   //[AA, BB]
    }
}

   3.Set

        Set存储无序的、不可重复的数据；使用的都是Collection中的方法

        向Set中添加的数据，其所在的类一定要重写hashCode()和equals()

        HashSet：作为Set接口的主要实现类；线程不安全的

        LinkedHashSet：是HashSet的子类，使用链表存储数据；对于频繁的遍历操作，其效率大于HashSet

        TreeSet：可以按照添加对象的指定属性进行排序；向TreeSet中添加的数据要求是同一个的类的对象

//以HashSet为例
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test{
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("AA");
        set.add("BB");
        set.add(123);
        set.add(456);
        set.add(123);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());    //无序性、不可重复性
        }
    }
}

import java.util.Iterator;
import java.util.TreeSet;

public class Test{
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(13);
        treeSet.add(12);
        treeSet.add(14);
        //treeSet.add("AA") 不能添加不同类的对象

        Iterator iterator = treeSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());    //按照从小到大的顺序排列
        }
    }
}

import java.util.Iterator;
import java.util.TreeSet;

public class Test{
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new User("Tom",12));
        treeSet.add(new User("Bob",13));
        treeSet.add(new User("Joe",11));

        Iterator iterator = treeSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());   //按照姓名排序
        }
    }
}

class User implements Comparable{
    String name;
    int age;

    public User(){

    }

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
            return this.name.compareTo(user.name);
        }else{
            throw new RuntimeException("输入类型错误");
        }
    }
}

二.Map

       Map：存储key - value 对，是无序的，其中key不能重复

                 HashMap：是Map的主要实现类；线程不安全、效率高；存储的key和value可以是null

                                    LinkedHashMap：作为HashMap的子类；底层使用双向链表存储

                TreeMap：按照key-value对中的key对数据进行排序，实现排序遍历；

                Hashtable：作为Map的古老实现类；线程安全、效率低；存储的key和value不能是null

                                    properties：常用来处理配置文件，key和value都是String型

    1.HashMap

         ①put(Object key, Object value)：将指定的key-value添加到(或修改)当前Map对象中

         ②putAll(Map map)：将map中的所有key-value存放在当前Map对象中

         ③remove(Object key)：移出指定key的key-value对，并返回value

         ④clear()：清空当前Map对象中的所有数据

import java.util.HashMap;
import java.util.Map;

//以HashMap为例
public class Test{
    public static void main(String[] args) {
        Map map = new HashMap();

        //put(Object key, Object value)：将指定的key-value添加到(或修改)当前Map对象中
        map.put("Tom",22);
        map.put("Bob",21);
        map.put("Joe",26);
        map.put("Tom",23);    //相当于修改

        System.out.println(map);    //{Joe=26, Tom=23, Bob=21}

        //putAll(Map map)：将map中的所有key-value存放在当前Map对象中
        Map map1 = new HashMap();
        map1.put("Mike",25);
        map1.put("John",24);
        map.putAll(map1);
        System.out.println(map1);    //{Mike=25, John=24}
        System.out.println(map);     //{Joe=26, Mike=25, Tom=23, Bob=21, John=24}


        //remove(Object key)：移出指定key的key-value对，并返回value
        Object value = map.remove("John");
        System.out.println(value);  //24
        System.out.println(map);    //{Joe=26, Mike=25, Tom=23, Bob=21}

        //clear()：清空当前Map对象中的所有数据
        map1.clear();
        System.out.println(map1);   //{}
    }
}

        ⑤get(Object key)：获取指定key对应的value

        ⑥containsKey(Object key)：判断是否包含指定的key

        ⑦containsValue(Object value)：判断是否包含指定的value

        ⑧size()：返回map中包含key-value对的个数

        ⑨isEmpty()：判断当前map是否为空

        ⑩equals(Object obj)：判断当前map和参数obj是否相等

import java.util.HashMap;
import java.util.Map;

//以HashMap为例
public class Test{
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("Tom",22);
        map.put("Bob",21);
        map.put("Joe",26);
        System.out.println(map);    //{Joe=26, Tom=22, Bob=21}


        //get(Object key)：获取指定key对应的value
        System.out.println(map.get("Joe"));    //26

        //containsKey(Object key)：判断是否包含指定的key
        System.out.println(map.containsKey("Bob"));    //true

        //containsValue(Object value)：判断是否包含指定的value
        System.out.println(map.containsValue(22));     //true

        //size()：返回map中包含key-value对的个数
        System.out.println(map.size());           //3

        //isEmpty()：判断当前map是否为空
        System.out.println(map.isEmpty());       //false

        //equals(Object obj)：判断当前map和参数obj是否相等
        Map map1 = new HashMap();
        map1.put("Tom",22);
        map1.put("Bob",21);
        map1.put("Joe",26);
        System.out.println(map.equals(map1));    //true
    }
}

        ⑪keySet()：返回所有key构成的Set集合

        ⑫values()：返回所有value构成的Collection集合

        ⑬entrySet()：返回所有key-value对构成的Set集合

import java.util.*;

//以HashMap为例
public class Test{
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("Tom",22);
        map.put("Bob",21);
        map.put("Joe",26);
        System.out.println(map);    //{Joe=26, Tom=22, Bob=21}


        //遍历所有的key集
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有的value集
        Collection collection = map.values();
        for(Object obj : collection){
            System.out.println(obj);
        }

        //遍历所有的key-value对
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();

        //方式一
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }

        //方式二
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=" + value);
        }

    }
}

  2.TreeMap

                向TreeMap中添加key-value，要求key必须是同一个类创建的对象，因为要自动按照key-value对中的key对数据进行排序

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class Test{
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap();
        User user = new User("Tom",22);
        User user1 = new User("Bob",21);
        User user2 = new User("Joe",25);
        User user3 = new User("Mike",24);
        treeMap.put(user,96);
        treeMap.put(user1,92);
        treeMap.put(user2,98);
        treeMap.put(user3,93);

        Set keySet = treeMap.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = treeMap.get(key);
            System.out.println(key + ":" + value);
        }

    }
}

class User implements Comparable{
    String name;
    int age;

    public User(){

    }

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
            return this.name.compareTo(user.name);
        }else{
            throw new RuntimeException("输入类型错误");
        }
    }
}

三.Collections工具类

        Collections是操作Collection和Map的工具类

        ①reverse(List)：反转List中元素的顺序

        ②shuffle(List)：对List集合元素进行随机排序

        ③sort(List)：根据元素的自然顺序对List集合元素进行升序排序

        ④sort(List, Compartor)：根据指定的Compartor产生的顺序对List集合元素进行排序

        ⑤swap(List,int i ,int j)：将List集合中第i处元素与第j处元素进行交换

        ⑥max(Collection) / min(Collection)：根据元素的自然顺序，返回给定集合中的最大(小)元素

        ⑦max(Collection,Compartor) / min(Collection,Compartor)：根据Compartor指定的顺序，返回给定集合中的最大(小)元素

        ⑧frequency(Collection, Object)：返回指定集合中指定元素的出现次数

        ⑨copy(List dest, List list)：将list中的数据复制到dest中

        ⑩replaceAll(List list, Object oldValue, Object newValue)：使用newValue替换list中所有的oldValue

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

public class Test{
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(13);
        list.add(12);
        list.add(25);
        list.add(10);
        System.out.println(list);    //[13, 12, 25, 10]

        //reverse(List)：反转List中元素的顺序
        Collections.reverse(list);
        System.out.println(list);    //[10, 25, 12, 13]

        //shuffle(List)：对List集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);   //[25, 12, 13, 10]

        //sort(List)：根据元素的自然顺序对List集合元素进行升序排序
        Collections.sort(list);
        System.out.println(list);   //[10, 12, 13, 25]

        //swap(List,int i ,int j)：将List集合中第i处元素与第j处元素进行交换
        Collections.swap(list,1,3);
        System.out.println(list);      //[10, 25, 13, 12]

        //max(Collection) / min(Collection)：根据元素的自然顺序，返回给定集合中的最大(小)元素
        System.out.println(Collections.max(list));     //25

        //frequency(Collection, Object)：返回指定集合中指定元素的出现次数
        System.out.println(Collections.frequency(list,12));  //1

        //copy(List dest, List list)：将list中的数据复制到dest中
        //List dest = new ArrayList(); //这样会抛异常Source does not fit in dest
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list);
        System.out.println(dest);    //[10, 25, 13, 12]

        //replaceAll(List list, Object oldValue, Object newValue)：使用newValue替换list中所有的oldValue
        Collections.replaceAll(list,10,19);
        System.out.println(list);   //[19, 25, 13, 12]
    }
}

         Collections类中提供了多个synchronizedXxx()方法，该方法可以使指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

import java.util.*;

public class Test{
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(13);
        list.add(12);
        list.add(25);
        list.add(10);
        
        List list1 = Collections.synchronizedList(list);    //返回的list1即为线程安全的list


        Map map = new HashMap();
        map.put("Tom",22);
        map.put("Bob",21);
        map.put("Joe",26);
        map.put("Tom",23);

        Map map1 = Collections.synchronizedMap(map);      //返回的map1即为线程安全的map
    }
}