Java集合

Java集合框架图

　　

　　　　Collection接口是Set,List,Quue三大接口的父接口；

　　　1.样例：

　　　　　　

　　　　　　　　

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

/**
 * 
 * @author fengkuirui
 * @date 2017-02-08
 * Collection常用方法练习
 * 
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //添加元素；
        c.add("fengkuirui");
        //虽然集合里不能存放基本类型，此时会自动装箱，变为其包装类;
        c.add(21);
        System.out.println("当前集合c元素个数："+c.size());
        //移除元素
        c.remove(21);
        System.out.println("当前集合c元素个数："+c.size());
        System.out.println("当前集合c包含fengkuirui:"+c.contains("fengkuirui"));
        //添加元素
        c.add("haha！");
        c.add("hehe");
        System.out.println("当前集合c元素个数："+c.size());
        Collection per = new HashSet();
        per.add("fengkuirui");
        per.add("haha");
        System.out.println("c集合是否包含per集合："+c.containsAll(per));
        //用c集合减去per集合的元素
        c.removeAll(per);
        System.out.println("当前集合c元素个数："+c.size());
        c.clear();//清空集合；
        System.out.println("当前集合c元素个数："+c.size());
        per.retainAll(c);//求交集；
        System.out.println("当前per集合元素个数："+per.size());
        System.out.println();
    }
}

　　结果如下：　　

　　

　　2.利用Lambda表达式遍历集合

　　　　样例：

　　　　　　

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

/**
 * 
 * @author fengkuirui
 * @date 2017-02-08
 * 利用Lambda表达式遍历集合；
 */
public class CollectionEach {
    public static void main(String[] args) {
        Collection c = new  HashSet();
        c.add("feng");
        c.add("crazy");
        //c.forEach(obj -> System.out.println("迭代集合; "+obj));//必须jdk8否则不好使；
    }
}

　　　　3.利用Iterator遍历集合元素

　　　　　　常用方法：

　　　　　　

　　　　　　样例：

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

/**
 * 
 * @author fengkuirui
 * @date 2017-02-08
 * 迭代器遍历集合
 * */
public class IteratorTest {
    public static void main(String[] args) {
        Collection c = new  HashSet();
        c.add("feng");
        c.add("crazy");
        Iterator iterator = c.iterator();
        while(iterator.hasNext()){//判断是否还有下一个元素
            String str = (String)iterator.next();//取出下一个元素；
            System.out.println(str);
            if(str.equals("feng")){
                iterator.remove();//移除元素；
                
            }
        }
        System.out.println(c);
    }
}

 　　　　4.利用forEach遍历集合

　　　　样例：

    import java.util.Collection;
    import java.util.HashSet;
    
    /**
     * 
     * @author fengkuirui
     * @date 2017-02-08
     * 利用forEach遍历集合;
     */
    public class ForEachTest {
        public static void main(String[] args) {
            Collection c = new  HashSet();
            c.add("feng");
            c.add("crazy");
            for(Object obj : c){
                String str = (String)obj;
                System.out.println(str);
                if(str.equals("feng")){
                    c.remove(str);
                }
            }
            System.out.println(c);
        }
    }

　　　　5.Predicate和Stream类来操作集合。

　　二、Set集合

　　　　主要特点：无序，不重复；

　　　　　　1.HashSet类

　　　　　　　主要特点：

　　　　　　　　该类是Set接口的典型实现，并且根据Hash算法来进行存储，具有良好的存取和查找功能;

　　　　　　　　不能保证元素的排列顺序，无序；

　　　　　　　　不是同步的，如果多个线程同时访问一个HashSet，假设两个或两个以上的线程来修改HashSet时，则必须通过代码来保证其同步。

　　　　　　　　元素值可以为null;　

　　　　　　　主要方法：

　　　　　　　　

　　　　　　2.LinkedHashSet类

　　　　　　　　该类是HashSet的子类，也是根据hashCode值来决定元素的存储位置，当时其实用链表来维护元素的次序，因为是插入顺序，所以性能低于HashSet；

　　　　　　　　输出和添加的元素顺序一致;

　　　　　　　　主要方法和父类基本一致；

　　　　　　3.TreeSet类

　　　　　　　　TreeSet是SortedSet接口的实现类，其可以保证集合元素处于排序状态。

　　　　　　　　新增方法如下：

　　　　　　　　　　Comparator comparatora(); 如果采用了定制排序，则该方法返回定制排序所使用的Comparator,如果使用了自然排序，则返回null;

　　　　　　　　　　Object first();返回首元素

　　　　　　　　　　Object last();返回最后一个元素

　　　　　　　　　　Object lower(Object e);返回位于集合中位于指定元素之前的元素

　　　　　　　　　　Object higher(Object e);返回位于集合中位于指定元素之后的元素

　　　　　　　　　　SortedSet subSet(Object fromElement, Object toElement);返回from fromEleemnt to toElement的Set子集；

　　　　　　　　　　SortedSet headSet(Object toElement);返回小于toElement的Set子集

　　　　　　　　　　SortedSet tailSet(Object from Element);返回大于或等于fromElement的元素集合

　　　　　　4.List集合

　　　　　　　　4.1List接口和ListIterator接口

　　　　　　　　　具体用法看代码：

　　　　　　　　　　

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

/**
 * 
 * @author fengkuirui
 * @date 2017-02-08
 * List用法;
 */
public class ListTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(100);
        list.add(400);
        //安位置插入
        list.add(1,230);
        for(int i=0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        //删除第三个元素
        list.remove(2);
        System.out.println(list);
        //判断当前元素是否在在首位
        System.out.println(list.indexOf("100"));
        System.out.println(list.subList(1, 3));
        
    }
}

　　结果如下：

　　　　　　

　　　　总结：List的元素可以重复，并且具有连续的索引序号,查找速度较快;

　　　　　　4.2ArrayList和Vector实现类;

　　　　　　　　ArrayList和Vector类是List接口的典型实现，支持List的所有功能;

　　　　　　　　Vector & ArrayList 的主要区别 
　　　　　　　　　　1） 同步性:Vector是线程安全的，也就是说是同步的 ，而ArrayList 是线程序不安全的，不是同步的。 
　　　　　　　　　　2）数据增长:当需要增长时,Vector默认增长为原来一倍 ，而ArrayList却是原来的50%  ，这样,ArrayList就有利于节约内存空间。 
     　　　　　　　　　  如果涉及到堆栈，队列等操作，应该考虑用Vector，如果需要快速随机访问元素，应该使用ArrayList 。

　　　　5.Queue集合

　　　　　　模拟队列的一种数据结构，先进先出FIFO;

　　　　　　主要方法：

　　　　　　　　

　　　　　　5.1PriorityQueue实现类

　　　　　　　　优先队列，根据队列元素的大小值进行重新排序。

　　　　　　　　主要方法：

　　　　　　　　　　

　　　　　　　　样例：

　　　　　　　　　　

import java.util.PriorityQueue;

/**
 * 
 * @author fengkuirui
 * @date 2017-02-08
 * 优先队列测试;
 */
public class PriorityQueueTest {
    public static void main(String[] args) {
        PriorityQueue pq = new PriorityQueue();
        pq.offer(12);
        pq.offer(-12);
        pq.offer(1);
        System.out.println(pq);
        System.out.println(pq.poll());
    }
}

　　　5.3LisnedList实现类

　　　　　　链表思想;

　　　6.Map集合

　　　　　Map保存具有映射关系的数据——键值对，　　　　　

 　　　

　　　　扩展知识：

　　　　　　1. Hashtable & HashMap 
　　　　　　　　Hashtable和HashMap它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。

　　　　　　2. ArrayList & LinkedList

　　　　　　　　ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录，

　　　　　　所以，它更象一个链表结构，所以，它们在性能上有很大的差别：   

      　　　　　　从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，

　　　　　　所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；

　　　　　　而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，

　　　　　　所以,当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。

 

 

　　　　　　Collection 是对象集合， Collection 有两个子接口 List 和 Set,

---

　　　　　　List 可以通过下标 (1,2..) 来取得值，值可以重复,而 Set 只能通过游标来取值，并且值是不能重复的

　　　　　　ArrayList ， Vector ， LinkedList 是 List 的实现类

　　　　　　ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的

　　　　　　LinkedList 是线程不安全的，底层是由链表实现的

---

　　　　　　Map 是键值对集合

　　　　　　HashTable 和 HashMap 是 Map 的实现类

　　　　　　HashTable 是线程安全的，不能存储 null 值

　　　　　　HashMap 不是线程安全的，可以存储 null 值