java-集合框架基本接口

返回的类型是接口，但是接口是不能实例化的，但是接口可以声明一个引用，指向其实现类，也就是说，在实际中返回值都是这个接口的实现类的对象 ---所以方法可以返回一个类

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 

Set接口继承Collection，但不允许重复，使用自己内部的元素排列机制

List接口继承Collection，允许重复，以元素安插的次序来放置元素，不会重新排列

Iterator接口提供了标准化的集合迭代方法，称为迭代器

Map接口定义了所持有的数据以键值对的形式存在，Map中不能有重复的key，拥有自己的内部排列机制

Collection是最基本的集合接口，一个Colletion代表一组Object，即Collection的元素（Elements）。Java JDK提供的类都是继承自Collection的“子接口”如List和Set

Collection主要方法

单元素添加、查询操作

boolean add(Object o) 将对象添加给集合

boolean remove(Object o) 如集合中有与o匹配的对象，删除o

查询操作

int size()

boolean isEmpty() 判断是否有元素存在

boolean contain(Object o) 查找集合中是否含有元素o

Iterator iterator() 返回一个迭代器，用来访问集合中的各个元素

组操作

boolean containsAll(Collection c) 查找集合中是否含有集合c中的所有元素

boolean addAll(Collection c) 将集合c中所有元素添加给该集合

void clear()

void removeAll(Collection c) 从集合中删除集合c中的所有元素

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

Set接口（无特定顺序，元素不可以重复）

HashSet类

HashSet() 构建一个空hash集

HashSet(Collection c) 构建一个hash集，并且添加集合c中所有元素

HashSet(int initialCapacity) 构建一个拥有特定容量的空hash集

HashSet(int int initialCapacity, float loadFactor) 构建一个拥有特定容量和加载因子的空hash集,loadFactor是0.1~1.0之间的一个数

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {        
        Set s = new HashSet();
		s.add(123);
		s.add("abc");
		s.add(new Double(1.2));
		s.add(123);
		System.out.println(s);    //[1.2,abc,123]
	}
}

TreeSet类

TreeSet() 构建一个空的树集

TreeSet(Collection c) 构建一个树集，并且添加集合c中所有元素

TreeSet(Comparator c) 构建一个树集，并且使用特定的比较器对其元素进行排序

TreeSet(SortedSet s) 构建一个树集，添加有序集合s中所有元素，并且使用与有序集合s相同的比较器排序

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {   
                SortedSet st = new TreeSet();
		st.add(new Integer(5));
		st.add(5);
		st.add(3);
		st.add(1);
		System.out.println(st);     //[1,3,5]
	}
}

List接口（允许重复并且有序）

void add(int index,Object element) 在指定位置index上添加元素element

boolean addAll(int index,Collection c) 将集合c的所有元素添加到指定位置index

Object get(int index) 返回List中指定位置的元素

int indexOf(Object o) 返回第一个出现元素o的位置，若未找到，返回-1

int lastIndexOf(Object o) 返回最后一个出现元素o的位置，若未找到，返回-1

Object remove(int index) 删除指定位置上的元素

Object set(int index,Object element) 用元素element取代index上的元素，并且返回旧的元素

ListIterator listIterator() 返回一个列表迭代器，并且用来访问列表中的元素

ListIterator listIterator(int index) 返回一个列表迭代器，用来从指定位置index开始访问列表中的元素

List subList(int fromIndex,int toIndex) 返回从指定位置fromIndex（包含）到toIndex（不包含）范围中各个元素的列表视图

LinkedList类

LinkedList() 构建一个空的链接列表

LinkedList(Collection c) 构建一个链接列表，并且添加集合c的所有元素

void addFirst(Object o) 将对象o添加到列表的开头

void addLast(Object o) 将对象o添加到列表的结尾

Object getFirst() 返回列表开头的元素

Object getLast() 返回列表结尾的元素

Object removeFirst() 删除并返回列表开头元素

Object removeLast() 删除并返回列表结尾元素

ArrayList类

ArrayList类封装了一个动态再分配的Object[]数组

在向ArrayList中添加大量元素的程序中，可以使用ensureCapacity()方法提前增加capacity,可以减少重分配内存的次数

void ensureCapacity(int minCapacity) 将ArrayList对象容量增加，保证容量不小于minCapacity

void trimTosize() 整理ArrayList对象容量为列表当前大小，可以减少ArrayList对象存储空间

Vector类

一种动态数组，元素只能是对象，对象类型可以不同

Object addElement(Object anObject) 添加元素

Object elementAT（int index）根据位置获取元素

Object insertElement(Object anObject, int index) 在指定位置插入

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {       
                List l1 = new LinkedList();
		List l2 = new ArrayList();
		l1.add("abc");
		l1.add(3);
		l1.add(1,true);
		l2.add(0,3);
		l2.add(123);
		l2.add(true);
		l2.add("abd");
		System.out.println(l1);    //[abc,true,3]
		for(int i = 0; i < l1.size(); ++i){    //遍历元素
          System.out.println(li.get(i)); 
        }     	
    }
}

Iterator接口（能够把Collection对象中的数据一个一个读出来）

boolean hasNext() 判断是否存在下一个可访问的元素

Object next() 返回要访问的下一个元素，如果到达集合尾，则抛出NoSuchElementException异常

void remove() 删除上次访问返回的对象

Iterator对象数据的读取时单向的，读过的数据就不能再次读取。

Iterator和Collection对象是连在一起的，所以不论谁做修改，对方的数据都会被一起修改

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {
                List l = new LinkedList();
		l.add("abc");
		l.add(3);
		l.add(true);
		System.out.println(l);
		Iterator i = l.iterator();
		while(i.hasNext())
		{
			System.out.println(i.next());
			i.remove();
		}
		System.out.println("l.size : " + l.size());    
        //[abc, 3, true]    abc  3   true   l.size : 0
	}
}

For循环遍历

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {
                ArrayList l = new ArrayList();
		l.add("Tom");
		l.add("Kimmy");
		l.add("Emma");
		for(Object obj:l) {
		System.out.println(obj);
    //Tom    Kimmy    Emma
		}
	}
}

Map接口

Map接口不是Collection接口的继承，Map跟Set和List不同的地方在于，Map存放数据时，需要有一个键（key），

这个键会对应到一个指定的值（value），value才是需要存放的对象而key相当于是只想value的索引。

map接口常用方法：

添加和删除操作

Object put(Object key,Object value) 将相互关联的一个键值对放入Map，如果该键值已经存在，那么与此键值相关的新值将取代旧值，如果键原先并不存在，返回null

Object remove(Object key) 从Map中删除与key相关的映射

void putAll(Map m) 参数m为包含需要添加的键值对的Map,该方法讲m中包含的元素添加进调用该方法的Map对象

void clear()

查询操作

Object get(Object key) 获取与key这个键相关的值，没有返回null

boolean containsKey(Object key) 判断Map中是否存在key这个键，存在返回true

boolean containsKey(Object value) 判断Map中是否存在value这个键，存在返回true 

int size() 返回当前Map中键值对的数量

boolean isEmpty() 判断Map中是否有映射存在

HashMap类

负载因子 = 数据量/容量

HashMap() 构建一个空的hashMap

HashMap(Map m) 构建一个hashMap，并且添加m的所有映射

HashMap(int initialCapacity) 构建一个拥有特定容量的空的hashMap

HashMap(int initialCapacity, float loadFactor) 构建一个拥有特定容量和加载因子的空的hashMap

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {
                HashMap hm = new HashMap();
		hm.put(1, "A");
		hm.put(2,"b");
		hm.put(3,"C");
		hm.put(4,"E");
		System.out.println(hm);     //{1=A, 2=b, 3=C, 4=E}
		hm.remove(3);
		hm.put(4, "F");
		System.out.println(hm);    //{1=A, 2=b, 4=F}
		Object o = hm.get(2);
		String s = (String)o;
		System.out.println("key2 = value:" + s);    //key2 = value:b
		
	}
}

TreeMap类

TreeMap没有调优选项，因为该树总处于平衡状态

TreeMap() 构建一个空的TreeMap

TreeMap(Map m) 构建一个TreeMap，并且添加m中所有元素

TreeMap(Comparator c) 构建一个TreeMap,并且使用特定的比较器对键进行排序

TreeMap(SortedMap s) 构建一个TreeMap，添加s中所有映射，并且使用与有序映射s相同的比较器进行排序

泛型

ArrayList<参数化类型> list = new ArrayList<参数化类型>()

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {
    	        ArrayList<String> l = new ArrayList<String>();     //限制只能String类型
		l.add("String");
		l.add("abc");
		l.add("efg");
		//l.add(1);     //注释去掉会报错
		for(String s : l)
			System.out.println(s);
		
	}
}

自定义泛型

如果在定义一个类时使用<T>声明参数类型（T是类型持有者，是Type的缩写，这里也可以使用其他字符），并将成员变量类型、set()方法的参数类型和get()方法的返回值类型都一致声明为T，那么存入的类型在JavaBean初始化时就被限定了，在取出数据时也就不必进行类型转换了

import java.util.*;
public class HelloWorld {
	public static void main(String[] args) {        
                Mybean<Integer> b = new Mybean<Integer>();
		b.setData(1);
		Integer data1 = b.getData();
		System.out.println(data1);    //1
		Mybean<String> m = new Mybean<String>();
		m.setData("abc");
		String data2 = m.getData();
		System.out.println(data2);    //abc
	}
}