集合、泛型

一、集合

  集合即Java实例类库中存在的一套完整的容器类，基本类型有：List、Set、Queue、Map。

Class	初始大小	加载因子	扩容倍数	底层实现	Code	是否线程安全	同步方式
ArrayList	10	1	1.5倍+1	Object数组	int newCapacity = oldCapacity + (oldCapacity >> 1)+1;">>"右移符号，所以是除以2，所以新的容量是就的1.5倍+1Arrays.copyOf 调用 System.arraycopy 扩充数组	线程不安全	-
Vector	10	1	2倍	Object数组	int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);capacityIncrement默认为0，所以是加上本身，也就是2*oldCapacity，2倍大小Arrays.copyOf 调用 System.arraycopy 扩充数组	线程安全	synchronized
HashSet	16	0.75f	2倍	HashMap	add方法实际调用HashMap的方法put	线程不安全	-
HashMap	16	0.75f	2倍	Map.Entry	void addEntry(int hash, K key, V value, int bucketIndex) {if ((size >= threshold) && (null != table[bucketIndex])) {resize(2 * table.length);hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex);}	线程不安全	-
Hashtable	11	0.75f	2倍+1	Hashtable.Entry数组	int newCapacity = (oldCapacity << 1) + 1;if (newCapacity - MAX_ARRAY_SIZE > 0) { if (oldCapacity == MAX_ARRAY_SIZE) return; newCapacity = MAX_ARRAY_SIZE;}	线程安全	synchronized

1、List集合

  List接口在Collection基础上添加了大量的方法，可以在List的中间插入和移除元素。

1、ArrayList

  ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高。
常用方法：

方法名	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

2、LinkedList

  LinkedList采用链表存储方式，插入、删除元素时效率比较高。
常用方法：

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

2、Set集合

Set接口存储一组唯一，无序的对象。
HashSet是Set接口常用的实现类。
Set中存放对象的引用。
Set接口不存在get()方法。
如何遍历Set集合呢？
方法1： 通过迭代器Iterator实现遍历
获取Iterator ：Collection 接口的iterator()方法
Iterator的方法
boolean hasNext(): 判断是否存在另一个可访问的元素
Object next(): 返回要访问的下一个元素

Iterator iterator = sets.iterator();
		while(iterator.hasNext()){//迭代器中是否存在下一个元素 boolean
			System.out.println(iterator.next());
		}

方法2： 增强型for循环

for (Student student : sets) {
			System.out.println(student);
}

3、Map集合

方法名	说明
Object put(Object key, Object val)	以“键-值”对的方式进行存储
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove(Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在由指定的键映射的“键-值对”，返回true

4、泛型集合

泛型集合可以约束集合内的元素类型 。
典型泛型集合ArrayList、HashMap、表示该泛型集合中的元素类型泛型集合中的数据不再转换为Object。

import java.util.Comparator;

	public class Pet implements Comparator{
		private String name;
		private String sex;
		private Integer id;
		
	
	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public String getSex() {
		return sex;
	}


	public void setSex(String sex) {
		this.sex = sex;
	}


	public Integer getId() {
		return id;
	}


	public void setId(Integer id) {
		this.id = id;
	}


	public Pet(String name, String sex, Integer id) {
		super();
		this.name = name;
		this.sex = sex;
		this.id = id;
	}
	

	public Pet() {
		super();
		// TODO Auto-generated constructor stub
	}


	@Override
	public int compare(Pet o1, Pet o2) {
		if (o1.getId()==o2.getId()) {
			if (o1.getName().equals(o2.getName())) {
				return -o1.getSex().compareTo(o2.getSex());
			}else {
				return -o1.getName().compareTo(o2.getName());
			}
		}else {
			return o1.getId().compareTo(o2.getId());
		}
	}
	
	public String toString() {
		return "Pet [name=" + name + ", id=" + id + "sex" + sex +"]";
	}
		
//两个对象的hashCode值相同，两个对象equals方法不一定返回true
//两个对象的equals返回为true，则hashCode一定相同
	public boolean  equals(Object obj) {
		if (obj instanceof Pet) {
			Pet pet = (Pet)obj;
			if (pet.getId()==this.getId()) {
				if (pet.getName().equals(this.getName())) {
					if (pet.getSex().equals(this.getSex())) {
						return true;
					}else {
						return false;
					}
				}else {
					return false;
				}
			}else {
				return false;
			}
		}
		return false;
	}
	public int hashCode() {
		return 1;
		
	}
}
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Lian01 {
	public static void main(String[] args) {
		List list = Arrays.asList(new Pet("豆豆", "男", 001),
				new Pet("旺财", "男", 002),
				new Pet("妞妞", "女", 001),
				new Pet("豆豆", "女", 001));
		Set set = new HashSet();
		set.add(new Pet("jack","男",01));
		set.add(new Pet("marry","女",01));
		set.add(new Pet("bob","男",02));
		set.add(new Pet("jack","男",01));
		for (Pet pet : set) {
			System.out.println(pet);
		}
		Collections.sort(list, new Pet());
		for (Pet pet : list) {
			System.out.println(pet);
		}
	}
	
}