集合

概念：集合是Java API所提供的一系列类，可以用于动态存放多个对象。集合只能存对象集合与数组的不同在于，集合是大小可变的序列，而且元素类型可以不受限定，只要是引用类型。(集合中不能放基本数据类型，但可以放基本数据类型的包装类)，集合类全部支持泛型，是一种数据安全的用法。

集合的继承关系

Collection

Collection接口的常用方法（其实现子类都可以使用）

方法名	作用
int size()	返回此collection中的元素数。
boolean isEmpty()	判断此collection中是否包含元素。
boolean contains(Object obj)	判断此collection是否包含指定的元素。
boolean contains(Collection c)	判断此collection是否包含指定collection中的所有元素。
boolean add(Object element)	向此collection中添加元素。
boolean addAll(Collection c)	将指定collection中的所有元素添加到此collection中
boolean remove(Object element)	从此collection中移除指定的元素。
boolean removeAll(Collection c)	移除此collection中那些也包含在指定collection中的所有元素。
void clear()	移除些collection中所有的元素。
boolean retainAll(Collection c)	仅保留此collection中那些也包含在指定collection的元素。
Iterator iterator()	返回在此collection的元素上进行迭代的迭代器。
Object[] toArray()	把此collection转成数组。

List接口

List接口是Java集合框架中的一个接口，继承自Collection接口。List接口用于表示一个有序、可重复的集合，可以通过索引（位置）来访问和修改其中的元素。List接口的常用实现类包括ArrayList、LinkedList和Vector等。

相对于Collection接口新增的方法

方法名	功能
public Object get(int index)	根据下标，返回列表中的元素
public Object add(int index, Object element)	在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话）和所有后续元素向右移动
public Object set(int index, Object element)	用指定元素替换列表中指定位置的元素
public Object remove(int index)	移除列表中指定位置的元素

List接口实现类

• ArrayList
  ​ 数据结构：一维数组
  ​ 特点：存储数据
• LinkedList
  ​ 数据结构：双向列表
  ​ 特点：队列模式、栈模式
• Vector
  ​ 数据结构：一维数组
  ​ 特点：线程安全
• Stack
  ​ 继承关系：class Stack extends Vector，底层为栈
  ​ 特点：栈模式

ArrayList

代码实现：

public class Test02 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		//添加数据
		list.add("吴彦祖");
		list.add("谢霆锋");
		list.add("刘宪华");
		list.add("彭于晏");
		list.add("周杰伦");
		//设置指定下标上的元素
		list.set(1, "王力宏");
		//获取指定下标上的元素
		String str = list.get(1);
		System.out.println("获取指定下标上的元素：" + str);//王力宏
		//获取元素个数
		int size = list.size();
		System.out.println("获取元素个数：" + size);//5
		//在指定下标上添加元素
		list.add(2, "薛之谦");
		ArrayList<String> newList1 = new ArrayList<>();
		Collections.addAll(newList1, "aaa","bbb","ccc","ccc");//利用集合工具类（Collections）批量添加元素
		list.addAll(newList1);//将newList1中所有的元素都添加到list集合里末尾的位置
		ArrayList<String> newList2 = new ArrayList<>();
		Collections.addAll(newList2, "xxx","xxx","yyy","yyy","zzz","zzz");//利用集合工具类（Collections）批量添加元素
		list.addAll(3, newList2);//将newList2中所有的元素都添加到list集合里指定下标的位置
		//清空集合里所有的元素
		//list.clear();
		System.out.println("判断集合中是否包含指定元素：" + list.contains("王力宏"));//true
		System.out.println("判断集合中是否包含指定集合：" + list.containsAll(newList1));//true
		System.out.println("获取元素在集合中第一次出现的下标：" + list.indexOf("ccc"));//12
		System.out.println("获取元素在集合中最后一次出现的下标：" + list.lastIndexOf("ccc"));//13
		
		//没有-true，有-false
		System.out.println("判断集合里是否没有元素：" + list.isEmpty());//false
		list.remove(9);//通过下标删除元素
		list.remove("刘宪华");//通过数据删除元素
		list.removeAll(newList1);//将list中有newList1的元素全部删除(去除交集)
		list.retainAll(newList2);//将list中有newList2的元素全部保留(保留交集)
		List<String> subList = list.subList(1, 4);//从开始下标处(包含)截取到结束下标处(排他)的元素，返回新的集合
		//将集合转换为数组
		Object[] array1 = subList.toArray();
		System.out.println(Arrays.toString(array1));//[xxx, yyy, yyy]
		
		//将集合转换为指定类型的数组
		String[] array2 = new String[3];
		subList.toArray(array2);
		System.out.println(Arrays.toString(array2));//[xxx, yyy, yyy]
		System.out.println("-----------------------------------------");
		//遍历集合 -- for循环
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("-----------------------------------------");
		//遍历集合 -- foreach
		for (String element : list) {
			System.out.println(element);
		}
		System.out.println("-----------------------------------------");
		//遍历集合 -- Iterator
		Iterator<String> it = list.iterator();
		while(it.hasNext()){//判断是否有可迭代的元素
			String next = it.next();//获取下一个元素
			System.out.println(next);
		}
		System.out.println("-----------------------------------------");
		//遍历集合 -- ListIterator
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){//判断是否有可迭代的元素
			String next = listIterator.next();//获取下一个元素
			System.out.println(next);
		}
	}
}

LinkedList

特有方法：

方法	功能
void addFirst(E e)	将指定元素插入到次列表的开头
void addLast(E e)	将指定元素添加到此列表的结尾
E getFirst()	返回此列表的第一个元素
E getLast()	返回此列表的最后一个元素
E removeFirst()	移除并返回此列表的第一个元素
E removeLast()	移除并返回此列表的最后一个元素
E pop()	从此列表所表示的堆栈处弹出一个元素
void push(E e)	将元素推入此列表所表示的堆栈

独有方法的代码实现：

public class Test02 {
	public static void main(String[] args) {
		LinkedList<String> list = new LinkedList<>();
		list.add("王力宏");
		list.add("薛之谦");
		list.add("周杰伦");
		list.add("abc");
		list.add("abc");
		list.add("AAA");
		list.add("abc");
		list.add("abc");
		//添加到头部
		list.addFirst("aaa");
		list.offerFirst("bbb");
		list.push("ccc");
		//添加到末尾
		list.addLast("xxx");
		list.offer("yyy");
		list.offerLast("zzz");
		System.out.println("获取第一个元素：" + list.element());
		System.out.println("获取第一个元素：" + list.getFirst());
		System.out.println("获取第一个元素：" + list.peek());
		System.out.println("获取第一个元素：" + list.peekFirst());
		System.out.println("获取第一个元素：" + list.pop());
		System.out.println("获取最后一个元素：" + list.getLast());
		System.out.println("获取最后一个元素：" + list.peekLast());
		//删除第一个元素
		list.poll();
		list.pollFirst();
		list.removeFirst();
		//删除最后一个元素
		list.pollLast();
		list.removeLast();
		//删除第一次出现的元素
		list.removeFirstOccurrence("abc");
		//删除最后一次出现的元素
		list.removeLastOccurrence("abc");
		//倒序遍历
//		Iterator<String> descendingIterator = list.descendingIterator();
//		while(descendingIterator.hasNext()){
//			String next = descendingIterator.next();
//			System.out.println(next);
//		}
		
		for (String element : list) {
			System.out.println(element);
		}
	}
}

LinkedList实现队列模式

public class Test03 {
	public static void main(String[] args) {
		LinkedList<String> list = new LinkedList<>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		while(!list.isEmpty()){
			//String element = list.pollFirst();
			String element = list.removeFirst();
			System.out.println(element);
		}
		System.out.println("集合的元素个数为：" + list.size());//0
	}
}

LinkedList实现栈模式

public class Test04 {
	public static void main(String[] args) {
		LinkedList<String> list = new LinkedList<>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		while(!list.isEmpty()){
			String element = list.removeLast();
			System.out.println(element);
		}
		System.out.println("集合的元素个数为：" + list.size());//0
	}
}

Vector

vector的使用同ArrayList一致，不再赘述，这里只阐述一下Vector的以往实现方式

public class Test02 {
	/**
	 * 知识点：Vector老的方法
	 * 理解：Vector属于元老级别的集合类(JDK1.0)，JDK1.2开始才有集合框架的概念，
	 * 		为了将Vector保留下来，Java的设计者让Vector多实现了List接口
	 */
	public static void main(String[] args) {
		Vector<String> v = new Vector<>();
		v.addElement("aaa");
		v.addElement("bbb");
		v.addElement("ccc");
		v.addElement("ddd");
		v.addElement("eee");
		v.removeElementAt(0);//根据下标删除元素
		v.removeElement("bbb");//根据数据删除元素
		Enumeration<String> elements = v.elements();
		while(elements.hasMoreElements()){
			String nextElement = elements.nextElement();
			System.out.println(nextElement);
		}
	}
}

Stack

代码实现：

public class Test01 {
	/**
	 * 继承关系：class Stack extends Vector
	 * 特点：栈模式	
	 */
	public static void main(String[] args) {
		Stack<String> stack = new Stack<>();
		//将元素添加到栈顶
		stack.push("aaa");
		stack.push("bbb");
		stack.push("ccc");
		stack.push("ddd");
		stack.push("eee");
		System.out.println("获取栈顶元素：" + stack.peek());
		System.out.println("获取元素到栈顶的距离：" + stack.search("bbb"));//4 - 从1开始数
		//判断集合是否为空内容
		while(!stack.empty()){
			//删除栈顶元素，并返回
			String pop = stack.pop();
			System.out.println(pop);
		}	
	}
}