java集合总结

一：Java集合产生的原因

一方面，面向对 象语言对事物的体现 都是以对象的形式，为了方便对多 个对象的操作，就要对对象进行存储。 另-方面，使用Array存储对 象方面具有一些弊端，大小不能动态改变，而Java 集合就像一 种容器，可以动态地把多 个对象的引用放入容器中。所以，Java集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

二：集合架构体系图

●Java集合可分为Collection和Map两种体系

➢Collection接口:

　　➢Set:元素无序、不可重复的集合--类似高中的"集合”
　　➢List:元素有序，可重复的集合--”动态”数组
➢Map接口:具有映射关系“key-value对” 的集合--类似于高中的“函数”y=f(x) (x1,y1) (x2,y2)

 三：Collection接口

●Collection接口是List、Set 和Queue接口的父接口，该接口里定义的方法既可用于操作Set集合，也可用于操作List和Queue集合。

 3.1：List接口

Java中数组用来存储数据的局限性，List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。List容器中的元素都对应一个整数型的序号记载其在容器中的位置，

可以根据序号存取容器中的元素。JDK API中List接口的实现类常用的有: ArrayList、 LinkedList和Vector。

 

 list集合中的元素或对象（主要是自己的实现类）要重写equals方法，因为equals方法是判断两个对象相等的条件，不重写可能导致相等的对象无法判断相等

package Set;
import org.junit.Test;

import java.util.*;

/*
 * 1.存储对象可以考虑：①数组 ②集合
 * 2.数组存储对象的特点：Student[] stu = new Student[20]; stu[0] = new Student();....
 *    >弊端：①一旦创建，其长度不可变。②真实的数组存放的对象的个数是不可知。
 * 3.集合
 *     Collection接口
 *             |------List接口：存储有序的，可以重复的元素
 *                     |------ArrayList（主要的实现类）、LinkedList（对于频繁的插入、删除操作）、Vector（古老的实现类、线程安全的）
 *             |------Set接口：存储无序的，不可重复的元素
 *                     |------HashSet、LinkedHashSet、TreeSet
 *     Map接口：存储“键-值”对的数据
 *             |-----HashMap、LinkedHashMap、TreeMap、Hashtable(子类：Properties)
 */
public class CollectionTest {
    @Test
    public void testCollection1() {
       //size()方法判断集合的大小，add(Object obj)用来向集合添加元素，addAll(Collection coll),将一个集合中的所有元素添加到另一个集合里面
        // isEmpty()用来判断集合是否为空，clear()用来清空集合里的元素，contains用来判断集合是否包含指定的obj元素，对于自定义类对象要重写equals作为判断的依据
        //containsAll(Collection coll):判断当前集合中是否包含coll中所有的元素,retainAll(Collection coll):求当前集合与coll的共有的元素，返回给当前集合
        //equals判断两个集合中元素是否相同，toArray()变成数组，Arrays.toList()数组变成集合，集合可以通过.iterator()来进行遍历元素，包含next和hasnext方法，也可以增强for循环
        Collection coll = new ArrayList();
        coll.add(1);
        coll.add("hello");
        coll.add(new Person("nihao",12));//添加元素
        System.out.println(coll.size());//判断大小，
        coll.add(1);
        System.out.println(coll.size());//重复的元素可以添加
        ArrayList arrayList = new ArrayList();
        arrayList.add(10);
        coll.addAll(arrayList);//添加一个集合
        System.out.println(coll.isEmpty());//判断是否为空
        boolean b = (boolean) arrayList.remove(Integer.valueOf(10));//删除元素10，注意数字是表示按照下标进行删除，包装类则是安装元素进行删除
        System.out.println(b);
        System.out.println(arrayList.isEmpty());//现在为空
        //coll.clear();//清空元素，
        //System.out.println(coll);
        System.out.println(coll.contains(Integer.valueOf(1)));//包含一个元素
        arrayList.add(1);
        System.out.println(coll.containsAll(arrayList));//包含一个集合
        System.out.println(coll.retainAll(arrayList));//求交集
        System.out.println(coll.equals(arrayList));//判断两个集合是否相同
        System.out.println(arrayList.hashCode());//集合的hashcode值
        arrayList.add(2);
        System.out.println(arrayList.hashCode());//hashcode是对所有元素计算的到的。
        Object []obj = coll.toArray();//集合变成数组
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);
        }
        int[] a = {1,2,3};
        List<int[]> ints = Arrays.asList(a);//数组变成集合
        Iterator iterator = ints.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        for (Object ob:coll){
            System.out.println(ob);
        }
    }
    //ArrayList：List的主要实现类
    /*
     * List中相对于Collection，新增加的方法
     *  void add(int index, Object ele):在指定的索引位置index添加元素ele
        boolean addAll(int index, Collection eles)
        Object get(int index):获取指定索引的元素
        Object remove(int index):删除指定索引位置的元素
        Object set(int index, Object ele):设置指定索引位置的元素为ele
        int indexOf(Object obj):返回obj在集合中首次出现的位置。没有的话，返回-1
        int lastIndexOf(Object obj)：返回obj在集合中最后一次出现的位置.没有的话，返回-1
        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list

        List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index,Object obj))
                    查(get(int index)) 插(add(int index, Object ele)) 长度(size())
     */
    @Test
    public void testArrayList(){
        ArrayList ints = new ArrayList();
        ints.add(1);
        ints.add("a");
        Collection arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add(1);
        System.out.println(arrayList.equals(ints));//判断相等不仅看元素，还要看顺序,
        System.out.println(arrayList.hashCode());//一般hashcode除了要看内容，还要看顺序，因此若hashcode不相等，equals一般也不想等，互等价
        System.out.println(ints.hashCode());
        ints.addAll(0,arrayList);
        System.out.println(ints);
        System.out.println(ints.get(0));
        System.out.println(ints.remove(0));//删除指定位置的元素
        System.out.println(ints.indexOf("a"));//首次出现的位置，
        System.out.println(ints.lastIndexOf("a"));//最后一次出现的位置
        System.out.println(ints.subList(0,2));//返回左闭右开的区间的内容
        System.out.println(ints.set(0,"b"));//指定位置修改
        System.out.println(ints);

    }

}

3.2 set接口

 

 set集合中的元素或对象（主要是自己的实现类）要重写equals方法，因为equals方法是判断两个对象相等的条件，不重写可能导致相等的对象无法判断相等，

 还要重写hashcode方法，否则会导致所有的对象的hashcode的值都相等，且只能输出一个对象的值。

 

 

linkedhashset要维护指针，所以插入的效率要低一些，但是频繁遍历的效果要好于hashset

 

 要求是同一个类的才能添加到同一个treeset，才能按照统一的标准进行遍历。

package Set;

import org.junit.Test;

import java.util.*;

public class Set {
    @Test
    public void test(){//测试hashset
        HashSet hashSet = new HashSet();
        hashSet.add(123);
        hashSet.add(222);
        hashSet.add("BB");
        System.out.println(hashSet);//存储无顺序，输出也无顺序。
        work work1 = new work("ll",10);
        work work2 = new work("ll",10);
        hashSet.add(work1);
        hashSet.add(work2);
        System.out.println(work1.hashCode());
        System.out.println(work2.hashCode());
        System.out.println(hashSet);//对类对象，只有重写hashCode方法和equals方法后，生成的对象的hash值才可以相同，才能保证set集合的无重复性
    }
    /*
     * LinkedHashSet:使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkedHashSet集合
     * 元素时，是按照添加进去的顺序遍历的！
     *
     * LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
     */
    @Test
    public void test2(){//测试LinkedHashSet()
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(1);
        linkedHashSet.add(2);
        linkedHashSet.add(null);
        Iterator iterator1 = linkedHashSet.iterator();
        while (iterator1.hasNext())//因为测试LinkedHashSet在hashset的基础上添加了链表，因此所有添加的元素连接起来，遍历有序，这是主要的不同
        {
            System.out.println(iterator1.next());
        }

    }
    @Test//自然排序
    public void test3(){//在people类里面重写
        TreeSet set = new TreeSet();
        set.add(new work("liulei",16));
        set.add(new work("ww",12));
        set.add(new work("cc",13));
        for (Object str1:set){
            System.out.println(str1);
        }

    }
    @Test
    public void test4(){//因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象

        Comparator com = new Comparator() {//定制排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof work && o2 instanceof work){
                    work c1 = (work) o1;
                    work c2 = (work) o2;
                    int i = c1.getAge().compareTo(c2.getAge());//小于负值大于正值
                    if(i==0){//相等，继续比较
                        return c1.getName().compareTo(c2.getName());
                    }
                    return i;
                }
                return 0;
            }
        };
        TreeSet set = new TreeSet();
        set.add(new work("liulei",16));
        set.add(new work("ww",12));
        set.add(new work("cc",13));
        for (Object str1:set){
            System.out.println(str1);
        }

    }

}

对于自然排序，people里面实验Comparable，重写compareTo方法

package Set;

public class Person implements Comparable{
    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Person() {
        super();
    }
    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    //static int init = 1000;
    @Override
    public int hashCode() {//return age.hashCode() + name.hashCode();û�����Ľ�׳�Ժá�
        final int prime = 31;
        int result = 1;
        result = prime * result + ((age == null) ? 0 : age.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
        //return init++;//����������
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age == null) {
            if (other.age != null)
                return false;
        } else if (!age.equals(other.age))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    //����TreeSet�����Person��Ķ���ʱ�����ݴ˷�����ȷ�������ĸ��������С�

    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p = (Person)o;
            //return this.name.compareTo(p.name);
            //return -this.age.compareTo(p.age);
            int i = this.age.compareTo(p.age);
            if(i == 0){
                return this.name.compareTo(p.name);
            }else{
                return i;
            }
        }
        return 0;
    }
    
}

自然排序

@Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p = (Person)o;
            //return this.name.compareTo(p.name);
            //return -this.age.compareTo(p.age);
            int i = this.age.compareTo(p.age);
            if(i == 0){
                return this.name.compareTo(p.name);
            }else{
                return i;
            }
        }
        return 0;
    }

定制排序

 Comparator com = new Comparator() {//定制排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof work && o2 instanceof work){
                    work c1 = (work) o1;
                    work c2 = (work) o2;
                    int i = c1.getAge().compareTo(c2.getAge());//小于负值大于正值
                    if(i==0){//相等，继续比较
                        return c1.getName().compareTo(c2.getName());
                    }
                    return i;
                }
                return 0;
            }
        };

3.3.Queue

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。队列是一种先进先出的数据结构，元素在队列末尾添加，在队列头部删除。Queue接口扩展自Collection，并提供插入、提取、检验等操作。上图中，方法offer表示向队列添加一个元素，poll()与remove()方法都是移除队列头部的元素，两者的区别在于如果队列为空，那么poll()返回的是null，而remove()会抛出一个异常。方法element()与peek()主要是获取头部元素，不删除。接口Deque，是一个扩展自Queue的双端队列，它支持在两端插入和删除元素，因为LinkedList类实现了Deque接口，所以通常我们可以使用LinkedList来创建一个队列。PriorityQueue类实现了一个优先队列，优先队列中元素被赋予优先级，拥有高优先级的先被删除。

四：Map接口

 

 3.1 hashmap

 3.2 Linkedhashmap

 3.3 Treemap

 3.4 Hashtable

 3.5 properties

 @Test
    public void Test5() throws IOException {
        Properties pros = new Properties();
        pros.load(new FileInputStream(new File("D:/config.txt")));
        String user = pros.getProperty("user");
        System.out.println(user);
    }

五：Collections工具类

 

 

package com.atguigu.java;

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

import org.junit.Test;

/*
 * 操作Collection以及Map的工具类：Collections
 * 
 * 面试题：区分Collection与Collections
 * 
 */
public class TestCollections {
    /*
     *  Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        Object min(Collection)
        Object min(Collection，Comparator)
        int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
        void copy(List dest,List src)：将src中的内容复制到dest中
        boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

     */
    @Test
    public void testCollections2(){
        List list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add(12);
        list.add(78);
        list.add(456);
        Object obj = Collections.max(list);
        System.out.println(obj);
        int count = Collections.frequency(list, 4567);
        System.out.println(count);
        //实现List的复制
        //List list1 = new ArrayList();//错误的实现方式
        List list1 = Arrays.asList(new Object[list.size()]);
        Collections.copy(list1, list);
        System.out.println(list1);
        //通过如下的方法保证list的线程安全性。
        List list2 = Collections.synchronizedList(list);
        System.out.println(list2);
    }
    /*
     *  reverse(List)：反转 List 中元素的顺序
        shuffle(List)：对 List 集合元素进行随机排序
        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        
     */
    @Test
    public void testCollections1(){
        List list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add(12);
        list.add(78);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        Collections.swap(list, 0, 2);
        System.out.println(list);
    }
}