再次出发：collection接口

collection接口

list接口：有序的，允许多个空；常用方法ArrayList、Vector、LinkedList

• ArrayList线程不安全，适合单线程，删除增加不方便
• Vector线程安全，在单线程下效率低，删除增加不方便
• LinkedList使用双向链表方式，适合插入删除，性能高，
• 如何选择ArrayList、Vector、LinkedList？
• 1、安全性，选择Vector
• 2、是否频繁插入删除 ，选择LinkedList
• 3、是否存储后遍历，选择ArrayList

set接口：无序，不允许重复， HashSet、TreeSet、LinkedHashSet

• HashSet：无序
• TreeSet：重写comparator方法可以定义输出顺序，但会删除重复
• LinkedHashSet:可以按添加顺序输出
• 如何选择HashSet、TreeSet、LinkedHashSet？
• 1、如果要排序，选择TreeSet
• 2、如果不要排序和顺序，则选择HashSet
• 3、如果不要排序，但要顺序，选择LinkedHashSet

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

/**
 * collection接口 
 * list接口：有序的，允许多个空；常用方法ArrayList、Vector、LinkedList
 * ArrayList线程不安全，适合单线程，删除增加不方便 
 * Vector线程安全，在单线程下效率低，删除增加不方便
 * LinkedList使用双向链表方式，适合插入删除，性能高，
 * 如何选择ArrayList、Vector、LinkedList？  1、安全性    2、是否频繁插入删除  3、是否存储后遍历
 * 
 * @author wuzl
 *
 */
public class test01 {

	public static void arrayList() {
		// 使用集合最好存相同类型元素，不同元素处理起来比较麻烦
		List<String> list = new ArrayList<>();
		list.add("wuzl");
		list.add("is");
		list.add("a good boy!");
		// 遍历集合
		int size = list.size();
		for (int i = 0; i < size; i++) {
			System.out.println(list.get(i));
		}

		System.out.println(list.contains("wu"));// 判断list里是否含有某元素

		System.out.println("-------");
		String[] str = list.toArray(new String[] {});// 转换成数组
		for (String s : str) {
			System.out.println(s);
		}

		System.out.println("-------");
		list.remove("is");// 删除某元素
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

	}

	public static void vector() {
		Vector<String> v = new Vector<>();
		v.add("wuzl");
		v.add("is");
		v.add("a good boy!");
		// 遍历集合
		int size = v.size();
		for (int i = 0; i < size; i++) {
			System.out.println(v.get(i));
		}
	}

	
	public static void linkedList() {
		LinkedList<String> link = new LinkedList<>();
		link.add("wuzl");
		link.add("is");
		link.add("a good boy!");
		// 遍历集合
		int size = link.size();
		for (int i = 0; i < size; i++) {
			System.out.println(link.get(i));
		}
	}
	public static void main(String[] args) {
		arrayList();
		vector();
		linkedList();
	}

}

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * set接口：无序，不允许重复， HashSet、TreeSet、LinkedHashSet 
 * HashSet：无序
 * TreeSet：重写comparator方法可以定义输出顺序，但会删除重复
 *  LinkedHashSet:可以按添加顺序输出
 * 如何选择HashSet、TreeSet、LinkedHashSet？  
 * 1、如果要排序，选择TreeSet  
 * 2、如果不要排序和顺序，则选择HashSet
 * 3、如果不要排序，但要顺序，选择LinkedHashSet
 * 
 * @author wuzl
 *
 */
public class test02 {

	public static void hashSet() {
		Set<String> set = new HashSet<>();
		set.add("wu");
		set.add("zhi");
		set.add("lei");

		String[] str = set.toArray(new String[] {});
		for (String s : str) {
			System.out.println(s);
		}
	}

	public static void treeSet() {

	}

	public static void linkedHashSet() {
		LinkedHashSet<String> lhs = new LinkedHashSet<String>();
		lhs.add("wu");
		lhs.add("zhi");
		lhs.add("lei");

		for (String str : lhs) {
			System.out.println(str);
		}
	}

	public static void main(String[] args) {
		hashSet();
		System.out.println("----------");
		linkedHashSet();

	}

}