容器

Collection 容器的父接口

一些 collection 允许有重复的元素，而另一些则不允许。
Set子接口:无序的不可重复
   Lis子接口:有序的可重复
   容器可以存储任意类型的数据
   只能存储引用数据类型的数据,自动装箱

代码实例：

	方法
public class CollectionTest {//多态测试collection接口方法
	public static void main(String[] args) {
		Collection coll=new ArrayList();//list有序
		Collection coll2=new ArrayList();
		Collection coll3=new ArrayList();
		//add() 添加指定元素
		coll.add("张三");
		coll.add(123);
		coll.add("张三");
		coll.add("halo");
		coll.add(true);
	
	System.out.println(coll);//重写了string方法
	//addAll(Collection)添加
	coll2.add("xumin");
	coll2.add("halo");
	coll2.add(123);
	System.out.println(coll.addAll(coll2));
	System.out.println(coll);
	//clear.(),isEmpty(),contanis()是否包含元素
	//coll2.clear();
	System.out.println(coll2);
	System.out.println(coll2.isEmpty());
	System.out.println(coll.contains("xumin"));
	//remove 移除，remove移除所有，retainAll求交集
	coll.remove("张三");//移除索引在前对应的object
	System.out.println(coll);
	/*coll.removeAll(coll2);
	System.out.println(coll);*/
	coll.retainAll(coll2);
	System.out.println(coll);
	//size()返回元素数
	System.out.println(coll.size());
	//toArray()
	System.out.println(Arrays.toString(coll.toArray()));
	
	
}
}

遍历
public class CollectionerGodicTest {
	public static void main(String[] args) {
		//1.增强for遍历
		Collection<String> coll=new<String> ArrayList();
		coll.add("halo");
		coll.add("米老鼠");
		coll.add("唐老鸭");
		coll.add("白雪公主");
		coll.add("维尼熊");
		System.out.println(coll);
		//如果没有写泛型，想要输出String时使用String类型的方法，需要强转
		/*for(Object o:coll){
			if(o instanceof String){
				 o=(String)o;
				System.out.println(o+"的长度是"+((String) o).length());
			}else {
				System.out.println(o);
			}
		}
	
	for(String c:coll){
		System.out.println(c+"的长度是"+c.length());
	}*/
	
	//2.迭代器遍历
	Iterator<String> it=coll.iterator();
	while(it.hasNext()){
		System.out.println(it.hasNext());
		System.out.println(it.next());
	}
}
}

List :

接口的特点:有序可重复,有索引
新增了一些根据索引操作的方法 	

代码演示：

方法
public class ListFunctionTest {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList<Integer>();
		list.add(12);
		list.add(3);
		list.add(8);
		list.add(4);
		list.add(21);
		List<Integer> list1=new ArrayList<Integer>();
		list1.add(3);
		list1.add(12);
		list1.add(4);
		list1.add(5);
		list1.add(7);
		System.out.println(list);
		System.out.println(list1);
		/*
		1.void add(int index, E element)指定位置插入内容  
		 void addAll(int index, E element)在此容器指定位置插入指定容器所有内容
		list.add(2, 7);
		System.out.println(list);
		list.addAll(list1);
		System.out.println(list);
		list.addAll(2, list1);
		System.out.println(list);*/
	
	/*2.equals(Object o)比较指定的对象与此列表为平等。 
	System.out.println(list.equals(list1));里面的顺序也完全一致才true*/
	
	/*3.get(int index)返回此列表的元素在指定的位置
	indexOf(Object o)返回第一次出现的指定元素的索引列表,或1如果该列表不包含的元素。
	lastindexof 返回最后一次
	System.out.println(list.get(2));
	System.out.println(list.indexOf(8));
	System.out.println(list.lastIndexOf(4));*/
	
	/*4.set(int index, E element)取代在指定位置上的元素在这个列表指定的元素,即修改元素。
	list.set(2, 6);
	System.out.println(list);*/
}
}

遍历：
public class ListGodicTest {
public static void main(String[] args) {
	List<Double> list=new ArrayList<Double>();
	list.add(2.13);
	list.add(3.14);
	list.add(3.33);
	list.add(4.12);
	
	//1.普通for循环  遍历的时候出现list方法操作时，不会出现并发修改异常，默认顺序操作
	for(int i=0;i<list.size();i++){
		if(list.get(i)==3.14){
			list.add(Math.PI);
			System.out.println("you get Π");
		}
	}
	System.out.println(list);
	
	//2.增强for循环 会出现并发修改异常，出现方法操作时不推荐使用
	/*for(Double d:list){
		if(d==3.14){
			list.add(Math.PI);
			System.out.println("you get Π");
		}
	}
	System.out.println(list);*/
	
	/*3.iterator 调用iterator方法返回iterator容器的迭代器 同时有两个引用操作容器，出现并发异常
	Iterator<Double> it=list.iterator();
	while(it.hasNext()){
		if(it.next()==3.14){
			list.add(Math.PI);
			System.out.println("you get Π");
		}
		System.out.println(list);
	}*/
	
	//4.Listiterator 调用List新增方法Listiterator返回的迭代器使用方法
	ListIterator<Double> it=list.listIterator();
	while(it.hasNext()){
		if(it.next()==3.14){
			it.add(Math.PI);
		}
		System.out.println(list);
	}
}
}

ArrayList:

最重要之一：
 List接口的实现类:有序可重复
 ArrayList:
 	底层: 数组(可变数组),数组再内存中是连续的内存空间
 	优点: 查询,随机访问效率高
 	缺点: 增删效率低(改变容量涉及到数组的拷贝)
 	动态扩容:通过调用Arrays.copyOf()方法进行动态扩容,扩容后新容器的大小是原容量的1.5倍
 		第一次添加数据初始容量为10,加载因子(0~1):1 
  新增方法:使用List定义的方法
  线程不安全的容器类
 
 Vector 向量
 	底层实现和特点与ArrayList类似
 	1)Vector线层安全的容器类|同步的,效率较低
 	2)扩容原容量的2倍

代码实例：

ArraysList没有新增方法，和List一样，测试u写入其它类类型，写入自定义类型需要重写equals
 
public class ArraylistTest {
	public static void main(String[] args) {
		ArrayList<Person> per=new ArrayList<Person>();
		per.add(new Person("halo","女",18));
		per.add(new Person("xumis","男",19));
		per.add(new Person("qiqi","女",20));
		Person pe=new Person("xiqia","男",18);
		System.out.println(per);
		//System.out.println(per.indexOf(new Person("xumis","男",19))); 返回-1 比较的是地址，如果需要判断内容需要重写equals内容
		//System.out.println(per.indexOf(new Person("xumis","男",19))); 重写之后返回下标1
		
	}
}

class Person{

private String name;
private String sex;
private int age;

public Person() {
	// TODO Auto-generated constructor stub
}

public Person(String name, String sex, int age) {
	super();
	this.name = name;
	this.sex = sex;
	this.age = age;
}

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 int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}

@Override
public String toString() {
	return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	
}

@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 != other.age)
		return false;
	if (name == null) {
		if (other.name != null)
			return false;
	} else if (!name.equals(other.name))
		return false;
	if (sex == null) {
		if (other.sex != null)
			return false;
	} else if (!sex.equals(other.sex))
		return false;
	return true;
}
}

LinkedList:

底层:双向链表实现
优点:增删效率高
缺点:查询或随机获取效率低
新增方法:新增了一些操作与链表头和链表尾的功能(见名知意的方法使用)

代码实例：

  新增了一些操作于表头和表尾的方法
 
public class LinkedListTest {
	public static void main(String[] args) {
		LinkedList<Integer> link=new LinkedList<Integer>();
		link.add(3);
		link.add(12);
		link.add(14);
		System.out.println(link);
		
		//1.addFirst(E e)offer 插入指定元素在这个列表的开始。
		link.addFirst(19);
		System.out.println(link);
		
	/*2.getFirst() 返回此列表的第一个元素。  
	  E getLast()返回此列表中最后一个元素 */
	System.out.print(link.getFirst());
	System.out.println(link.getLast());
	
	//3.poll()|remove 获取和删除这个列表的头(第一个元素)。
	System.out.println(link.poll());
	System.out.println(link);
	System.out.println(link.removeLast());
	System.out.println(link);
	
	//4.peek()检索,但不删除这个列表的头(第一个元素)。 
	System.out.println(link.peek());
}
}

Set:

无序的不可重复的,null值只能存在一个
  没有新增方法,与Collection中功能相同
  
 遍历: 1.增强for
 	   2.迭代器

代码实例：

public class Settest {
	public static void main(String[] args) {
		Set<Integer> set=new HashSet<Integer>();
		set.add(3);
		set.add(7);
		set.add(14);
		System.out.println(set);
		System.out.println(set);
		
	//if..each遍历
	for(Integer i:set){
		System.out.println(i);
	}
	
	//iterator遍历
	Iterator<Integer> it=set.iterator();
	while(it.hasNext()){
		System.out.println(it.next());
	}
}
}

HashSet:

 底层是由HashMap维护的
 	底层:由哈希表结构存储(数组+链表+红黑树)
 	优点:查询,增加,删除效率较高
 	缺点:无序
  扩容:默认初始容量16,加载因子0.75 ,扩容是原容量的2倍
  
  HashSet存储引用数据类型去重:需要重写hashCode()方法和equals()方法进行自定义类型去重
  	如果不重写hashCode(),可以遇到没有equals方法这一步就医过滤掉不是相同的对象了,直接存储,不会equals方法比较
  	hashCode()相同的对象有可能相同可以不相同,进一步比较equals()
  	hashCode()不相同的对象肯定不相同,过滤掉一写不相同的对象,不需要进一步比较equals方法效率较高

代码实例：

public class HashSetTest {
	public static void main(String[] args) {
		HashSet<Person> hash=new HashSet<Person>();
		hash.add(new Person("halo", "男", 12));
		hash.add(new Person("xumins", "男", 18));
		hash.add(new Person("qiqi", "女", 15));
		hash.add(new Person("qiqi", "女", 15));
		System.out.println(hash);//因为先计算hashcode放入位置，所以如果不通过重写hashcode方法排除内容相同的
		//对象，就会按系统hashcode计算方法因为地址不同而放在不同的位置跳过equals，所以自定义需要重写hashcode方法和equals方法
	}
}