Collection集合(接口)、List集合(子接口)、ArrayList集合、LinkedList集合、Vector集合

Collection集合(接口)

	**子接口为List接口和Set接口**

1.基本功能(代码实现+注释)

package com.collection.cn;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		//不加泛型的时候，集合中可以存储任意类型的元素
		c.add("helloworld");
		c.add(123);
		c.add('A');
		c.add("高圆圆");
		//将集合转换成数组进行遍历
		Object[] array = c.toArray();
		for (Object object : array) {
			System.out.println(object);
		}
		//获取集合中元素的个数
		System.out.println(c.size());
		//删除指定的元素
		boolean b = c.remove("helloworld");
		System.out.println(b);
		//判断是否包含某个元素
		boolean d = c.contains(123);
		System.out.println(d);
		//判断集合是否为空
		boolean e = c.isEmpty();
		System.out.println(e);
		System.out.println("----------------------------------------------");
		//集合的高级功能
		//创建两个集合
		Collection c1 = new ArrayList();
		c1.add("hello");
		c1.add("world");
		c1.add("java");
		c1.add("hello");
		Collection c2 = new ArrayList();
		c2.add("abc");
		c2.add("hello");
		c2.add("python");
		//将c1添加到c2集合中
		System.out.println(c1.addAll(c2));
		//使用迭代器遍历c1集合
		Iterator it1 = c1.iterator();
		while(it1.hasNext()) {
			String s=(String)it1.next();
			System.out.println(s);
		}
		//判断c1是否包含c2中的元素
		System.out.println(c1.containsAll(c2));
		//在c1集合中删除重复的c2的一个元素就算删除
		System.out.println(c1.removeAll(c2));
	}
}

List集合(是collection接口的子接口)

1.特点：
1)有序，存储和取出一致；
2)该集合允许元素重复。
2.list集合遍历方式及添加元素：

package com.list.cn;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		//添加元素
		list.add("hello");
		list.add("javaEE");
		list.add("hello");
		list.add("python");
		list.add("php");
		//Collction集合专有遍历
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			String st=(String)it.next();
			System.out.println(st);
		}
		System.out.println("------------------------");
		//List集合专有遍历
		ListIterator<String> ito = list.listIterator();
		//正向遍历
		while(ito.hasNext()) {
			String s = (String)ito.next();
			//向集合中添加元素
			if ("php".equals(s)) {
				ito.add("高圆圆");
			}
		}
		System.out.println(list);
		System.out.println("-------------------------");
		//逆向遍历
		while(ito.hasPrevious()) {
			String s1 = (String)ito.previous();
			System.out.println(s1);
		}
		System.out.println("-------------------------");
		//for循环遍历
		for (int i = 0; i < list.size(); i++) {
			String str = (String)list.get(i);
			if ("php".equals(str)) {
				list.add("赵又廷");
			}
		}
		System.out.println(list);
		System.out.println("-------------------------");
		//增强for遍历(没有加泛型)
		for (String str : list) {
			System.out.println(str);
		}
	}
}

3.并发修改异常
并发：在同一个时间点上同时发生。
并行：在同一时间段内同时发生。
集合中出现的异常：ConcurrentModificationException并发修改异常
使用迭代器遍历集合，在同时使用集合对象操作元素，就会出现这个异常，迭代器遍历集合元素，集合添加元素，而对于迭代器对象并不知道存在一个新元素！
如何解决：
1)迭代器遍历集合、迭代器添加元素：ListIterator存在添加功能
2)集合遍历，集合添加：普通for循环：(size()和get(int index)相结合)

泛型

1.泛型是jdk5提供的新特性。---->应用在类上、方法上、接口上 ----> 格式：<引用数据类型>
2.泛型就是模拟数组的定义格式：在创建集合对象的时候就已经将集合中存储的类型规定好了！
3.泛型的好处：
1)将运行时期异常提前到了编译时期；
2)解决了黄色警告线的问题；
3)避免了强类型转换；
4)提高了程序的安全性。
4.泛型的高级通配符：
<?>:表示可以存储任意的java类型(包括自定义类型)以及Object类型。
<? extends E> :向下限定，可以存储E类型以及它的子类。
<? super E>:向上限定，可以存储E类型以及它的父类。

ArrayList

1.ArrayList是一个大小可变的数组实现，底层数据结构是一个数组，查询快，增删慢。默认容量是10，扩容性是1.5倍。在线程方面，是一个线程不安全的类，单线程执行效率高。
2.ArrayList集合中的基本功能：

package com.arraylist.cn;
import java.util.ArrayList;
public class ArrayListTest {
	public static void main(String[] args) {
		//创建ArrayList集合对象
		ArrayList<String> array = new ArrayList<String>();
		//给集合中添加元素内容
		array.add("高圆圆");
		array.add("赵又廷");
		array.add("吴倩");
		array.add("张新城");
		array.add("马云");
		array.add("吴倩");
		//如果此列表中包含此元素，旧返回true，否则返回false
		boolean ct = array.contains("吴倩");
		System.out.println(ct);
		//如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 
		array.ensureCapacity(20);
		//返回此列表中指定位置上的元素。 
		String str = array.get(2);
		System.out.println(str);
		//返回此列表第一个元素出现的索引，没有此元素则返回-1
		int of = array.indexOf("吴倩");
		System.out.println(of);
		//移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。 
		boolean re = array.remove("吴倩");
		System.out.println(re);
		//用指定的元素替代此列表中指定位置上的元素。
		String set = array.set(3, "孙俪");
		System.out.println(set);
		//将此 ArrayList 实例的容量调整为列表的当前大小。
		array.trimToSize();
		System.out.println("-------------");
		//遍历数组
		for (String st : array) {
			System.out.println(st);
		}
	}
}

例：泛型是一个具体类(Student),遍历ArrayList集合并去掉重复的元素。
注意：contains()底层依赖于equals()方法，如果没有写Object中的equals方法，默认比较的是地址值是否相同。

package com.generic.cn;
import java.util.ArrayList;
public class GenericTest {

	public static void main(String[] args) {
		ArrayList<Student> list=new ArrayList<Student>();
		list.add(new Student("tom",23,"男"));
		list.add(new Student("jack",24,"男"));
		list.add(new Student("jack",24,"男"));
		list.add(new Student("marry",22,"女"));
		list.add(new Student("tom",22,"男"));
		list.add(new Student("lady",24,"男"));
		list.add(new Student("jack",23,"男"));
		list.add(new Student("jack",23,"男"));
		//toArray遍历集合
		Object[] array = list.toArray();
		for (int i = 0; i < array.length; i++) {
			System.out.println(list.get(i));
		}
		System.out.println("----------------------------");
		//删除重复元素
		ArrayList<Student> newlist = new ArrayList<Student>();
		//遍历旧集合
		for (Student stu : list) {
			if (!newlist.contains(stu)) {
				newlist.add(stu);
			}
		}
		//遍历新集合
		for (Student st : newlist) {
			System.out.println(st.getName()+"---"+st.getAge()+"---"+st.getSex());
		}
	}
}
class Student implements Comparable<Student>{
	private String name;
	private Integer age;
	private String sex;
	public Student() {
		super();
	}
	public Student(String name, Integer age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	@Override
	public int compareTo(Student s) {
		int num=this.age-s.age;
		int num1=(num==0)?(this.name.compareTo(s.name)):num;
		int num2=(num1==0)?(this.sex.compareTo(s.sex)):num1;
		return num2;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(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

1. LinkedList底层数据结构是一种链接列表，查询慢、增删快，是一个线程不安全的类，执行效率高！
2. 特有功能：

package com.linkedlist.cn;
import java.util.LinkedList;
public class LinkedListTest {
	public static void main(String[] args) {
		LinkedList<Integer> list = new LinkedList<Integer>();
		//添加元素
		list.add(23);
		list.add(34);
		list.add(6);
		list.add(38);
		list.add(50);
		//遍历
		for (Integer it : list) {
			System.out.print(it+" ");
		}
		System.out.println();
		//将指定元素插入此列表的开头。 
		list.addFirst(52);
		//将指定元素添加到此列表的结尾。 
		list.addLast(63);
		//获取列表开头
		Integer first = list.getFirst();
		System.out.println(first);
		//获取列表末尾
		Integer last = list.getLast();
		System.out.println(last);
		//获取但不移除此列表的头（第一个元素）。 
		Integer peek = list.peek();
		System.out.println(peek);
		//获取并移除此列表的头（第一个元素） 
		Integer poll = list.poll();
		System.out.println(poll);
		//从此列表所表示的堆栈处弹出一个元素。换句话说，移除并返回此列表的第一个元素。 
		Integer pop = list.pop();
		System.out.println(pop);
		//将元素推入此列表所表示的堆栈。换句话说，将该元素插入此列表的开头。
		list.push(520);
		//将此列表中指定位置的元素替换为指定的元素。 
		Integer set = list.set(2, 10);
		System.out.println(set);
		//返回此列表的元素数。 
		System.out.println(list.size());
	}
}

3.需求:使用LinkedList模拟栈结构的特点：先进后出
自定义一个栈集合类,里面使用LinkedList集合的功能:
添加元素add—>每次往该集合中第一个位置添加元素
获取元素get—>每次获取的是以前的元素

package com.linkedlist.cn;
import java.util.LinkedList;
public class LinkedListDemo {

	//声明一个LinkedList变量
	private LinkedList<Object> list;
	//构造方法
	public LinkedListDemo() {
		list=new LinkedList<Object>();
	}
	//添加功能
	public void add(Object obj) {
		list.addFirst(obj);
	}
	//获取功能
	public Object get() {
		return list.removeFirst();
	}
	//判断功能
	public boolean isEmpty() {
		return list.isEmpty();
	}
	
	public static void main(String[] args) {
		//创建对象
		LinkedListDemo demo = new LinkedListDemo();
		//添加元素内容
		demo.add(23);
		demo.add(20);
		demo.add(7);
		demo.add(34);
		demo.add(55);
		demo.add(47);
		while(!demo.isEmpty()) {
			System.out.println(demo.get());
		}
	}
}

Vector集合

1. Vector集合底层数据结构是一种对象数组，查询快，增删慢。是一个线程安全的类，执行效率低。
2. 特有功能：

package com.vector.cn;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {

	public static void main(String[] args) {
		//创建vector集合对象
		Vector<String> v = new Vector<String>();
		v.add("权志龙");
		v.add("李连杰");
		v.add("成龙");
		v.add("权志龙");
		v.add("高圆圆");
		Enumeration<String> em = v.elements();
		//判断是否包含很多元素
		while(em.hasMoreElements()) {
			// Object nextElement():获取下一个元素	
			String s = em.nextElement();
			System.out.println(s);
		}
		System.out.println("-------------------------");
		//增强for
		for (String str : v) {
			System.out.println(str);
		}
	}
}