JAVA_JCF(Java Collection Framework)学习笔记(二)

List接口共性方法

Collection

|-------List:元素是有序的，元素可以重复，因为该集合体系有索引。

     |------ArrayList:底层的数组结构使用的是数组结构。特点：查询速度快，但是增删稍慢，线程不同步。

     |------LinkedList:底层使用的链表结构。特点：增删速度快，查询慢。

     |------Vector：底层是数组结构，线程同步，被ArrayList替代了。

|-------Set:元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复。

     |-------HashSet:底层数据结构是哈希表.线程是非同步的

保证元素唯一性的原理，判断元素的hashCode值是否相同

如果相同还会继续判断元素的equals方法，是否为true

     |-------TreeSet：可以对Set集合中的元素进行排序

底层数据结构是二叉树

保证元素唯一性的依据：compareTo方法return 0

由于List内部使用的数组结构存储元素，所以很多操作都涉及到与索引相关。

所以凡是操作角标的方法都是该体系的特有方法。

@Test
	public void testList(){

		//由于List是接口，使用ArrayList具体实现类
		List<String> list1 = new ArrayList<String>();
		list1.add("java01");
		list1.add("java02");
		list1.add("java03");
		list1.add("java04");
		
		//由于List是接口，使用ArrayList具体实现类
		List<String> list2 = new ArrayList<String>();
		list2.add("java01");
		list2.add("java02");
		list2.add("java06");
		list2.add("java08");
		
		//get(int)
		System.out.println("=== > get(int) " + list1.get(1));
		//set(int)
		list1.set(1, "java002");
		System.out.println("=== > set(int) " + list1.get(1));
		//add(int ,E)
		list1.add(1, "java0002");
		System.out.println("=== > add(int ,E) " + list1.get(1));
		//remove(int)
		list1.remove(1);
		System.out.println("=== > remove(int) " + list1.get(1));
		//indexOf(Object)
		System.out.println("=== > indexOf(Object) " + list1.indexOf("java08"));
		//lastIndexOf(Object)
		System.out.println("=== > lastIndexOf(Object) " + list1.lastIndexOf("java08"));
		//subList(int, int)(前闭后开原则 )
		System.out.println("=== > subList(int ,int)" + list1.subList(0,	3));
		//=========================输出结果===============================//
//		=== > get(int) java02
//		=== > set(int) java002
//		=== > add(int ,E) java0002
//		=== > remove(int) java002
//		=== > indexOf(Object) -1
//		=== > lastIndexOf(Object) -1
//		=== > subList(int ,int)[java01, java002, java03]
	}

List集合特有的ListIterator迭代器

List集合特有的迭代器。ListIterator是Iterator的子接口。

需要注意的是：使用迭代器对集合进行迭代时不可以通过集合对象的方法操作集合中的元素，否则会抛出java.util.ConcurrentModificationException异常。

所以，使用迭代器时，只能用迭代器的方法操作元素，但是Iterator得方法是有限的，只能对元素进行判断 取出 删除的操作。

如果想要其他的操作如添加 修改 就需要使用其子接口ListIterator

该接口是通过listIterator方法返回迭代器。

@Test
	public void testListIterator(){

		//由于List是接口，使用ArrayList具体实现类
		List<String> list1 = new ArrayList<String>();
		list1.add("java01");
		list1.add("java02");
		list1.add("java03");
		list1.add("java04");
		System.out.println(list1);
		
		//获取迭代器
		ListIterator<String> iterator = list1.listIterator();
		while(iterator.hasNext()){
			String next = iterator.next();
			if ("java02".equals(next)) {
				iterator.set("java002");
			}
		}
		
		System.out.println(list1);
		//===========输出结果==================//
//    	[java01, java02, java03, java04]
//	    [java01, java002, java03, java04]

		
	}

Vector(听说不重要)

枚举就是Vector特有的取出方式

发现枚举和迭代器很像

其实枚举和迭代器是一样的

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举郁郁而终了。

@Test
	public void testVector(){

		Vector<String> vector = new Vector<String>();
		vector.add("java01");
		vector.add("java02");
		vector.add("java03");
		vector.add("java04");
		vector.add("java05");
		
		Enumeration<String> elements = vector.elements();
		while(elements.hasMoreElements()){
			System.out.println(elements.nextElement());
		}
		
	}

LinkedList(链表结构)

LinkedList特有方法linkedList:

addFirst();

addLast();

getFirst();

getLast();

获取元素，但是不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，并且删除元素。如果集合中没有元素，会出现NoSuchElementException

在jdk1.6出现了替代方法

offerFirst();

offerLast();

peekFirst();

peekLast();

获取元素，但是不删除元素。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

获取元素，并且删除元素。如果集合中没有元素，会返回null。

使用LinkedList简单模拟一个堆栈或者队列的数据结构

堆栈：先进后出

队列：先进先出

import java.util.LinkedList;

/**
 * 基于LinkedList的队列
 * 
 * @author JiangMinyan
 * 
 */
public class Queue {

	private LinkedList<String> linkedList;
	
	public Queue() {
		linkedList = new LinkedList<String>();
	}
	
	public void add(String e){
		linkedList.addFirst(e);
	}
	
	public String get(){
		return linkedList.removeLast();//改成linkedList.removeFirst();就是堆栈
	}
	
	public boolean isEmpty(){
		return linkedList.isEmpty();
	}
	
}

@Test
	public void testQueue() {

		Queue queue = new Queue();
		queue.add("java01");
		queue.add("java02");
		queue.add("java03");
		queue.add("java04");

		while (!queue.isEmpty()) {
			System.out.println(queue.get());
		}
	}

ArrayList(数组结构)

使用ArrayList添加自定义对象，并且去重。

使用contains方法进行判断时，其内部使用元素对象的equals方法进行比较。

Person类：

public class Person {

	private String name;
	private String age;

	public Person() {
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAge() {
		return age;
	}

	public void setAge(String age) {
		this.age = age;
	}

	@Override <span style="color:#ff0000;">//重写类的equals方法</span>
	public boolean equals(Object obj) {

		System.out.println(this.name + "...equals");
		
		if (!(obj instanceof Person)) {
			return false;
		}
		Person person = (Person) obj;
		return this.name.equals(person.getName());
	}

	@Override
	public String toString() {
		return this.name + ":" + this.age;
	}

@Test
	public void testArrayList() {

		ArrayList<Person> persons = new ArrayList<Person>();
		persons.add(new Person("java01", "20"));
		persons.add(new Person("java02", "22"));
		persons.add(new Person("java02", "25"));
		persons.add(new Person("java02", "23"));
		sop(persons);

		persons = singleElement(persons);
		sop(persons);

	}

	/**
	 * ArrayList去重 (List集合判断元素是否相同，依据的是元素的equals方法)
	 */
	private ArrayList<Person> singleElement(ArrayList<Person> persons) {

		ArrayList<Person> newPersons = new ArrayList<Person>();

		for (Person person : persons) {
			if (!newPersons.contains(person)) {
				newPersons.add(person);
			}
		}
		return newPersons;
	}