Java常用集合

Java集合框架层次结构

Collection接口

collection接口：所有集合的父接口
常用的方法

方法	含义
boolean add(Object)	集合中加入一个对象，成功返回true
boolean addAll(Collection)	集合中加入另一个集合对象
boolean remove(Object)	从集合中删除对象
boolean removeAll(Collection)	清空集合
boolean containsAll(Collection)	判断集合内是否含有子集
int size()	集合内容量
boolean isEmpty()	集合是否为空
boolean contains(Object)	集合内是否含有参数对象
Iterator iterator()	产生迭代器
Object[] toArray()	返回一个包含所有元素的对象数组

• set接口
  特点：无序，不重复（唯一）
• set接口的实现类
• HashSet：遍历集合中元素，不关心元素顺序，性能高 ，基于hash算法。set集合在存储两个对象时，使用equals方法判断两个对象是否相同，如果相同返回true
  介绍完特点上部分源码
  HashSet源码：

//HashSet通过对象来计算hashcode
public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
    //常用的两个构造方法
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }
    //生成一个迭代器
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

• TreeSet：按照升序排列遍历集合中元素，性能低，基于红黑树
  使用treeSet存储的对象想要排序，这个对象必须实现Comparable接口，treeSet使用Comparable接口中compareTo方法排序并且判断对象是重复
  TreeSet部分源码及实现接口

//调用Comparable接口
public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
//默认升序排序
public TreeSet(SortedSet<E> s) {
        this(s.comparator());
        addAll(s);
    }
    //add方法
    public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }
 //addAll方法
 public  boolean addAll(Collection<? extends E> c) {
        // Use linear-time version if applicable
        if (m.size()==0 && c.size() > 0 &&
            c instanceof SortedSet &&
            m instanceof TreeMap) {
            SortedSet<? extends E> set = (SortedSet<? extends E>) c;
            TreeMap<E,Object> map = (TreeMap<E, Object>) m;
            Comparator<?> cc = set.comparator();
            Comparator<? super E> mc = map.comparator();
            if (cc==mc || (cc != null && cc.equals(mc))) {
                map.addAllForTreeSet(set, PRESENT);
                return true;
            }
        }
        return super.addAll(c);
    }
//查看comparatale源码，抽象方法compareTo
public int compareTo(T o);
//后续补充

• list接口
  有序可重复；每个List中的元素对应一个整数型序号，根据序号（index）存取容器中元素。

• ArrayList
  以数组的形式连续保持元素（内存结构类似顺序存储中线性表结构）
  

• LinkedList
  以链表结构保持集合中元素
  

• ArrayList和LinkedList得比较
  1.是否保证线程安全：ArrayList和LinkedList都不是同步得，也就是不保证线程安全。
  2.底层数据结构：ArrayList底层使用Object数组；LinkedList底层使用得是双向链表（JDK1.8）
  3.插入和删除是否受元素位置影响
  ArrayList：add(E e)在列表末尾追加；add(int index,E element)；影响插入或删除元素得前后元素位置。
  LinkedList：add(E e)方法得插入删除元素不受元素位置影响；add(int index,E element);方法受指定插入元素位置影响。
  4.ArrayList适合随机查询的场合，LinkedList元素的插入和删除操作性高
  5.内存消耗上：ArrayList得空间浪费主要体现在为list列表结尾留出一定容量空间；LinkedList空间浪费主要体现在为每个元素存储为空间大小都比ArrayList多。

Map接口

• 以键/值对这样成对的对象组，通过键操作值
• Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的
• 底层数据结构：
  HashMap JDK1.8前由数组和链表组成，数组是HashMap的主体，链表是为了解决哈希冲突而存在的。JDK1.8之后是当链表长度大于8时，链表转化为红黑树，减少搜索时间。
  常用方法

方法	含义
Object put(Object key,Object value)	将指定的值与此映射中的指定键相关联
void putAll(Map t)	将映射t中所有映射关系复制到此映射中
Object get(Object key)	返回此映射中映射到指定键的值
Object remove(Object key)	若存在此键的映射关系,将其从映射中移除
boolean containsKey(Object key)	若此映射包含指定键的映射关系，返回 true
boolean containsValue(Object value)	若此映射为指定值映射一个或多个键,返回 true
int size()	返回此映射中的键-值映射对数
boolean isEmpty()	若此映射未包含键-值映射关系,返回 true
Set keySet()	返回此映射中包含的键的 set 集合
Collection values()	返回此映射中的所有值对象的Collection集合

• HashMap构造方法
  
• Demo

/**
 * 
 */
package test2;

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

/**
 * @author xiaochen
 *
 */
public class HashMapDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map m1 = new HashMap();
		Map m2 = new HashMap();
		m1.put("one", new Integer(1));
		m1.put("two", new Integer(2));
		m1.put("three", new Integer(3));
		m2.put("A", new Integer(1));
		m2.put("B", new Integer(2));
		System.out.println(m1.size());
		System.out.println(m1.containsKey("one"));
		System.out.println(m2.containsValue(new Integer(1)));
		if(m1.containsKey("Two")) {
			int i = ((Integer) m1.get("two")).intValue();
			System.out.println(i);
		}
		Map m3 = new HashMap(m1);
		m3.putAll(m2);
		System.out.println(m3);
	}

}

Iterator迭代器

• Iterator对象称作迭代器，用于对集合内的元素进行遍历操作
• 所有实现了Collection接口的集合类都有一个iterator( )方法，返回一个实现了Iterator接口的对象
• Iterator使用中只能单向移动
• 常用方法

方法	含义
Object next()	返回游标右边的元素并将游标移动到下一个位置
boolean hasNext()	判断游标右边是否有元素
void remove()	删除游标左边的元素，在执行完next之后，该操作只能执行一次

• 实现过程
  
  实例：

/**
 * 
 */
package test2;

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

/**
 * @author xiaochen
 *
 */
public class IteractorDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet<Integer> set = new HashSet<Integer>();
		for(int i = 0; i<6;i++) {
			set.add(new Integer(i));
		}
		//获得游标
		Iterator<Integer> it = set.iterator();
		//循环遍历  hasNext()检查游标右边的元素是否存在
		while(it.hasNext()) {
		//返回游标右边的元素并移动游标到下一个元素位置
			Integer j = (Integer)it.next();
			System.out.println(j);
		}
		System.out.println(set);
	}

}