java 集合框架1 List集合

---

  集合是对象的容器，定义了对多个对象进行操作的常用方法，可实现数组的功能。
  与数组区别：数组长度固定，集合长度不固定；数组可以存储基本类型和引用类型，集合只能存储引用类型。
  Collection体系集合。

	Collection<Interface>
List<Interface>		Set<Interface>
ArrayList		HashSet
Vector		LinkedHashSet
LinkedList		SortedSet <Interface>
		TreeSet

  Collection 代表一组任意类型的对象，无序、无下标。

Collection col = new ArrayList();
// 添加元素
col.add("javase");
col.add("javaee");
col.add("javame");

// 增强for foreach 遍历
for (Object object : col) {
	String text = (String) object;
	System.out.println(text);
}

// 迭代器1
Iterator ite = col.iterator();
while(ite.hasNext()) {
	Object obj = ite.next();
	String text = (String) obj;
	System.out.println(text);
}

// 迭代器2
for (Iterator iterator = col.iterator(); iterator.hasNext();) {
	Object object = iterator.next();
	String text = (String) object;
	System.out.println(text);
}

Collection col2 = new ArrayList();
col2.add("java1");
// 添加集合中的元素
col.addAll(col2);
// 删除集合中的对象，相同值只删除最前的
col.remove("java1");
// 从当前集合删除两个集合中共有的对象，相同值都删除，目标集合不变。
col.removeAll(col2);
// 清空集合
col.clear();
// 包含元素
System.out.println(col.contains("javase"));
// 包含目标集合中的所有元素
System.out.println(col.containsAll(col2));
// 元素个数
System.out.println(col.size());

  迭代器遍历中删除元素。

// 迭代器
Iterator ite = col.iterator();
while(ite.hasNext()) {
	Object obj = ite.next();
	String text = (String) obj;
	if (text.equals("javase")) {
		ite.remove();
	}
}

  List 集合有序、有下标、元素可以重复。

public class Worker {

	private String name;
	private Integer age;
	private Double money;
	
	public Worker() {
		
	}
	
	public Worker(String name, Integer age, Double money) {
		this.name = name;
		this.age = age;
		this.money = money;
	}

	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 Double getMoney() {
		return money;
	}

	public void setMoney(Double money) {
		this.money = money;
	}
}

import java.util.ArrayList;
import java.util.List;
public class Test {

	public static void main(String[] args) {
		
		Worker w1 = new Worker("张三", 18, 3000.0);
		Worker w2 = new Worker("李四", 20, 5000.0);
		Worker w3 = new Worker("王五", 22, 10000.0);
		//
		List l1 = new ArrayList();
		l1.add(w1);
		l1.add(w2);
		l1.add(w3);
		
		Worker w4 = new Worker("赵六", 24, 3300.0);
		// 在下标位置插入元素
		l1.add(1, w4);

		Worker w5 = new Worker("深7", 24, 3300.0);
		Worker w6 = new Worker("葵8", 24, 3300.0);
		List l2 = new ArrayList();
		l2.add(w5);
		l2.add(w6);
		// 在下标位置插入集合中的所有元素
		l1.addAll(1, l2);
		//截取一段元素，包含fromIndex，不包含endIndex
		List l3 = l1.subList(0, 3);
		
		for (int i = 0; i < l1.size(); i++) {
			//获取下标位置的值
			Object object = l1.get(i);
			Worker wk = (Worker)object;
			System.out.println(wk);
		}		
	}
}

  ArrayList 数组结构实现，查询快、增删慢，运行效率快、线程不安全。

import java.util.ArrayList;
ArrayList list = new ArrayList();

  Vector 数组结构实现，查询快、增删慢，运行效率慢、线程安全。

Vector v = new Vector();
v.add("javase");
v.add(0, "javaee");
//Enumeration Iterator
Enumeration en =  v.elements();
//en.hasMoreElements()  ==>hasNext()
while (en.hasMoreElements()) {
//en.nextElement()===>next()
	String type = (String) en.nextElement();
	System.out.println(type);
}

  LinkedList 链表结构实现，增删快，查询慢。它是双向链表结构，每个元素节点，都纪录着本身元素的值，还有前一个元素节点，后一个元素节点。

LinkedList list = new LinkedList();		
list.add("javase");
list.add(0, "javaee");
//LInkedList 特有方法
// 添加
list.addFirst("he");
list.addLast("llo");
// 删除
list.removeFirst();
list.removeLast();

  泛型。
  Java 泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。好处是提高代码的重用性，防止类型转换异常，提高代码的安全性。
  泛型类。

public class Demo <T> {

	private T t;
	
	public Demo() {
	}
	
	// 泛型入参
	public void show(T t) {
		this.t = t;
		System.out.println(t);
	}

	// 泛型返回值
	public T showRes() {
		return t;
	}
	
	public void show() {
		System.out.println(t);
	}

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}
}

public class Test1 {

	public static void main(String[] args) {
		
		Demo<String> demo1 = new Demo<String>();
		demo1.show("ffff");
		System.out.println(demo1.showRes());
		
		Demo<Integer> demo2 = new Demo<Integer>();
		demo2.show(12);
		System.out.println(demo2.showRes());
	}
}

  泛型接口。

public interface Demo <T> {
	T method(T t);
}

public class Student implements Demo<String> {

	public Student() {
		
	}

	@Override
	public String method(String t) {
		System.out.println(t);
		return "接收到了";
	}

}

public class Test {
	public static void main(String[] args) {
		Student stu = new Student();
		System.out.println(stu.method("传入")) ;	
	}
}

  泛型类和泛型接口结合。

public class Student<T> implements Demo<T> {

	public Student() {
		
	}

	@Override
	public T method(T t) {
		System.out.println(t);
		return t;
	}
}

public class Test {
	public static void main(String[] args) {
		Student<String> stu = new Student<String>();
		System.out.println(stu.method("传入")) ;		
	}
}

  泛型方法。

public class Test1 {
	public static void main(String[] args) {
		System.out.println(method1("传入"));
	}
	
	public static <T> T method1(T t) {
		return t;
	}
}

  Colletions工具类。

public class Test {
	public static void main(String[] args) {
		List<Integer> l1 = new ArrayList<Integer>();
		l1.add(5);
		l1.add(12);
		l1.add(66);
		l1.add(15);
		l1.add(43);
		//排序升序
		Collections.sort(l1);
		//反转
		Collections.reverse(l1);
		//打乱
		Collections.shuffle(l1);
		
		List<String> l2 = new ArrayList<String>();
		l2.add("c");
		l2.add("ab");
		l2.add("aa");
		l2.add("b");
		l2.add("a");
		// 字符串也可以排序
		Collections.sort(l2);
	}
}

---