Java集合框架总结

-------------------2013-8-27总结-------------------


补充：自定义对象时，覆盖Object类中的equals方法和Hashcode方法，实现Comparable接口
为什么出现集合（collection）

对象多了用集合存 ，数据多了用对象
只存储对象，长度可变

体系

Collection
　　|-List：元素有序，可重复，该集合有所引
　　|-ArrayLisr ：数组，查询速度快，增删慢，默认长度为10，增加50%，
　　|-LinkedList：双向循环链表，查询速度慢，增删快
　　|-Vector ：数组结构，速度很慢，线程同步，被ArrayList替代了
　　|-Set：元素无序，不可重复
　　|-HashSet：Hash表，线程不同步
　　|-TreeSet ：二叉树 

-------------------List-------------------
注意：equals方法保证元素唯一

各个集合特有方法

（1）Collection

　　增
　　 boolean add(E e) 
　　          确保此 collection 包含指定的元素（可选操作）。 
　　 boolean addAll(Collection<? extends E> c) 
　　          将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 
　　
　　删
　　void clear() 
　　          移除此 collection 中的所有元素（可选操作）。 
　　 boolean remove(Object o) 
　　          从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 
　　 boolean removeAll(Collection<?> c) 
　　          移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 
　　
　　判断
boolean isEmpty() 
          如果此 collection 不包含元素，则返回 true。 
　　 boolean contains(Object o) 
　　          如果此 collection 包含指定的元素，则返回 true。 
　　 boolean containsAll(Collection<?> c) 
　　          如果此 collection 包含指定 collection 中的所有元素，则返回 true。 
　　转成数组
　　 Object[] toArray() 
　　          返回包含此 collection 中所有元素的数组。 
　　<T> T[] 
　　 toArray(T[] a) 
　　          返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。 

（2）List

1、增

void add(String item) 

          向滚动列表的末尾添加指定的项。 

 void add(String item, int index) 

          向滚动列表中索引指示的位置添加指定的项。 

2、删

void remove(int position) 

          从此滚动列表中移除指定位置处的项。 

3、改

set(index,element)

4、查

get(index)

subList(from,to)

ListIterator()

（3）ListIterator

 List特有，操作中不允许使用集合方法操作元素，会发生ConcurrentModificationException
　　增
　　 void add(E e) 
　　          将指定的元素插入列表（可选操作）。 
　　
　　删
　　void remove() 
　　          从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。 
　　
　　改
　　 void set(E e) 
　　          用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。 
　　
　　反向遍历
　　boolean hasPrevious() 
　　          如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。 

（4）Vector（特有取出方式枚举）

 Enumeration<E> elements() 

          返回此向量的组件的枚举。 

（5）Enumeration

（此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。 ）

boolean hasMoreElements() 

          测试此枚举是否包含更多的元素。 

 E nextElement() 

          如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。 

（6）LinkedList

1、增

void addFirst(E e) 

          将指定元素插入此列表的开头。 

 void addLast(E e) 

          将指定元素添加到此列表的结尾。 

2、删

 E removeFirst() 

          移除并返回此列表的第一个元素。 

 boolean removeFirstOccurrence(Object o) 

          从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。 

 E removeLast() 

          移除并返回此列表的最后一个元素。 

 boolean removeLastOccurrence(Object o) 

          从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。 

3、查

 E getFirst() 

          返回此列表的第一个元素。 

 E getLast() 

          返回此列表的最后一个元素。 

后替代方法（出后缀是first和last的方法是1.6出现的，其他1.5出现的）

1、增

boolean offer(E e) 

          将指定元素添加到此列表的末尾（最后一个元素）。 

 boolean offerFirst(E e) 

          在此列表的开头插入指定的元素。 

 boolean offerLast(E e) 

          在此列表末尾插入指定的元素。 

2、删

 E peek() 

          获取但不移除此列表的头（第一个元素）。 

 E peekFirst() 

          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 

 E peekLast() 

          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 

3、查

 E poll() 

          获取并移除此列表的头（第一个元素） 

 E pollFirst() 

          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 

 E pollLast() 

          获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 

一、HashSet

1、元素唯一：通过，Hashcode和equals方法保证元素唯一，当Hash地址一样时，在调用equlas判断，如果不同那就把对象接到相同地址后面，这也是判断和删除的依据。

二、TreeSet

1、元素唯一：comparaTo方法 return 0;

特殊接口：public interface Comparable<T>此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序

复写

int compareTo(T o) 

          比较此对象与指定对象的顺序。 

2、元素排序

方式方法一：

让元素自身具有比较性，实现Coparable接口，覆盖compareTo方法也称元素自然排序或默认顺序

方式二：

当元素本身不具备比较性，或者不是所需的。这时让集合自身具备，集合初始化时，就具备比较性，构造时，传入比较器对象。定义一个类实现Comparator接口，覆盖compare()方法。

-------------------Map-------------------

Map
　　|-Hashtable : 哈希表，不允许null健和null值，同步，1.0，低
　　|-HashMap ：哈希表，允许null健和null值，不同步，1.2，高
　　|-TreeMap : 二叉树，给map健排序，不同步，和Set很像，Set底层使用Map
特点：键值对，一对一对向里存，健必须唯一

常用方法：

添加

 V put(K key, V value) ,新value替换原来的value,返回原来的

          将指定的值与此映射中的指定键关联（可选操作）。 

 void putAll(Map<? extends K,? extends V> m) 

          从指定映射中将所有映射关系复制到此映射中（可选操作）。 

删

void clear() 

          从此映射中移除所有映射关系（可选操作）。 

V remove(Object key) 

          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 

获取

 int size() 

          返回此映射中的键-值映射关系数。 

 Collection<V> values() 

          返回此映射中包含的值的 Collection 视图。 

V get(Object key) 

          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 

Set<Map.Entry<K,V>> entrySet() 

          返回此映射中包含的映射关系的 Set 视图。 

Set<K> keySet() 

          返回此映射中包含的键的 Set 视图。 

2、取出方法

（1）keySet方法：将Map中的所有建存入set中，在用get方法

（2）entrySet方法: 将key和value封装成Map.Entry对象，里面包含Key和Value

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>();
		
		map.put("01", "lisi");
		map.put("03", "wanger");
		map.put("01", "lisi");
		print2(map);
	}
	
	//keySet取出方法
	public static void print1(Map<String, String> map) {
		Set<String> keySet = map.keySet();
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String key = it.next();
			System.out.println(key + ": " + map.get(key));
		}
	}
	
	//entrySet取出方式
	public static void print2(Map<String, String> map) {
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, String>> it = entrySet.iterator();
		while(it.hasNext()) {
			Map.Entry<String, String> entry = it.next();
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}
	}
}

3、一对多关系

（不过开发中，学号都封装在学生对象中）

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 一个班级是一个HashMap,key-学号，value-学生对象
 * 将班级再存入HashMap, key-班级名称，value-班级HashMap
 * @author renpingqing
 */
public class TestMap1 {
	public static void main(String[] args) {
		//预热班级
		HashMap<String,Student1> yrb = new HashMap<String,Student1>();
		
		yrb.put("01", new Student1("lisi"));
		yrb.put("03", new Student1("wanger"));
		yrb.put("02", new Student1("li"));
		
		//冲刺班级
		HashMap<String,Student1> ccb = new HashMap<String,Student1>();
		
		ccb.put("03", new Student1("ersi"));
		ccb.put("05", new Student1("wanger"));
		ccb.put("02", new Student1("li"));
		
		//将班级添加到一个集合中，
		HashMap<String,HashMap<String,Student1>> classs = 
				new HashMap<String,HashMap<String,Student1>>();
		
		classs.put("预热班", yrb);
		classs.put("冲刺班", ccb);
		
		print(classs);
	}
	
	//遍历
	public static void print(HashMap<String,HashMap<String,Student1>> map) {
		Set<Map.Entry<String, HashMap<String, Student1>>> entrySet1 = map.entrySet();
		Iterator<Map.Entry<String, HashMap<String, Student1>>> it1 = entrySet1.iterator();
		
		while(it1.hasNext()) {
			Map.Entry<String, HashMap<String, Student1>> mapEntry1 = it1.next();
			
			System.out.println(mapEntry1.getKey());
			
			HashMap<String,Student1> map1 = mapEntry1.getValue(); 
			
			Set<Map.Entry<String, Student1>> entrySet2 = map1.entrySet();
			
			Iterator<Map.Entry<String, Student1>> it2 = entrySet2.iterator();
			
			while(it2.hasNext()) {
				Map.Entry<String, Student1> map2 = it2.next();
				
				System.out.println("  " + map2.getValue().getName());
			}
		}
	}
}

//学生对象
class Student1 {
	private String name;

	public Student1(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student1 other = (Student1) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

-------------------2013-07-18以前总结-------------------

一、集合和数组区别：

1、集合：长度可变，只能存储对象，不同类型的对象

2、数组：长度固定

二、体系结构

Collection
		|--List
			|--ArrayList 数组，查询速度快，增删速度慢，线程不同步
			|--LinkedList	链表，查询慢，增删快
			|--Vector	数组，线程同步
		|--Set
			|--HashSet 哈希表，是通过元素的hashCode和equals方法，线程不同步
				如果，元素的hashCode相等，才调用equals方法
				注意：对于判断和删除都是依赖元素hashCode和equals方法
			|--TraceSet 元素无序，存储自定义对象时，必须保证对象的可比较性，
				
				第一种方式排序：让元素本身具备可比较性，即实现Comparable接口
				覆盖compareTo方法,底层数据结构是二叉树，保证元素的唯一性是compareTo的返回结果
				这种排序称为自然排序或者默认排序
				
				第二种：当元素本身不具备可比较性或者，自身的比较性不是
				我们所需要的，这时就让集合基本可比较性，在集合初始化时
				就有了比较方法
				
	为什么会出现这么多容器：
		因为每个容器的对数据存储方式不一样，即数据结构

三、Map接口详解：存储的是键值对，键必须唯一

常用方法：

1、增

V put(K key, V value) 

          将指定的值与此映射中的指定键关联（可选操作）。

          当键相同时，用新值替换旧值，并返回原来的值

     void putAll(Map<? extends K,? extends V> m) 

          从指定映射中将所有映射关系复制到此映射中（可选操作）。 

2、删

void clear() 

          从此映射中移除所有映射关系（可选操作）。 

     V remove(Object key) 

          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 

3、判断

boolean containsKey(Object key) 

          如果此映射包含指定键的映射关系，则返回 true。

     boolean equals(Object o) 

          比较指定的对象与此映射是否相等。

     boolean isEmpty() 

          如果此映射未包含键-值映射关系，则返回 true。   

4、获取

V get(Object key) 

          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

     int size() 

          返回此映射中的键-值映射关系数。 

     Collection<V> values() 

          返回此映射中包含的值的 Collection 视图。 

     重点：

     Set<Map.Entry<K,V>> entrySet() 

          返回此映射中包含的映射关系的 Set 视图。 

     Set<K> keySet() 

          返回此映射中包含的键的 Set 视图。 

二、体系结构

Map
|--Hashtable:底层是哈希表，必须实现 hashCode 方法和 equals 方法。jdk1.0 效率低
不能存储null值和键，线程同步
|--HashMap：底层是哈希表，允许使用 null 值和 null 键。不同步jdk1.2 效率高
|--TreeMap ：底层是二叉树，线程不同步，键排序
和set很像，其他set底层就是使用了Map集合

例1：TreeSet用比较构造器实现->按字符串长度排序

import java.util.*;

/*
	TreeSet
	按照字符串长度排序。小在前面
	
	用容器本身，即比较器
*/

class StringLengthSort {
	public static void main(String[] args) {
//		TreeSet ts = new TreeSet(new MyComparator());

		//内部类实现
		TreeSet ts = new TreeSet(new Comparator() {
			public int compare(Object o1, Object o2) {
				String s1 = (String)o1;
				String s2 = (String)o2;

				int num = s1.length() - s2.length();
				if (num == 0) {
					return s1.compareTo(s2);
				}
				return num;
			}
		});

		ts.add("abcd");
		ts.add("d");
		ts.add("dddcd");
		ts.add("abc");
		ts.add("aaa");

		Iterator it = ts.iterator();
		while(it.hasNext()) {
			out(it.next());
		}
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

//比较器
class MyComparator implements Comparator {
	public int compare(Object o1, Object o2) {
		String s1 = (String)o1;
		String s2 = (String)o2;

		int num = s1.length() - s2.length();
		if (num == 0) {
			return s1.compareTo(s2);
		}
		return num;
	}
}

例2：TreeSet排序->用比较构造器实现

import java.util.*;

/*
	TreeSet第二种排序：
		当元素本身不具备可比较性或者，自身的比较性不是
		我们所需要的，这时就让集合基本可比较性，在集合初始化时
		就有了比较方法

	具体实现：
		定义一个比较器即，实现comparator，重写compare方法，将该
		对象传入构造器方法

	现在是存储顺序输出，用构造器实现姓名顺序输出
*/

//人类
class Person implements Comparable {
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
	
	//覆盖compareTo方法，使对象具有可比较性
	public int compareTo(Object obj) {
//		return 1;
		return -1; //倒序输出
//		return 0; //只能存储进去第一个元素
	}
}

//main
class TreeSetSort {
	public static void main(String[] args) {
		
		TreeSet ts = new TreeSet(new Mycompare());

		//存储自定义对象
		ts.add(new Person("lisi",12));
		ts.add(new Person("lis",12));
		ts.add(new Person("lii",13));
		ts.add(new Person("lsi",14));
	
		Iterator it = ts.iterator();
		while(it.hasNext()) {
			Person p = (Person)it.next();
			out(p.getName() + "..." + p.getAge());
		}
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

//比较器,按照年龄排序
class Mycompare implements Comparator {
	public int compare (Object o1, Object o2) {
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		
//		return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));

		/*	
			if (p1.getAge() > p2.getAge()) {
				return 1;
			}

			if (p1.getAge() < p2.getAge()) {
				return -1;
			}

			return 0;
		*/
	}
}

例3：TreeSet原理详解->二叉树

import java.util.*;
/*
	二叉树：值小的在节点左边。大的在节点右边，相等的只留一个	
	需求：
		用TreeSet实现取出和存储顺序一样
*/

//人类
class Person implements Comparable {
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
	
	//覆盖compareTo方法，使对象具有可比较性
	public int compareTo(Object obj) {
		return 1;
//		return -1; //倒序输出
//		return 0; //只能存储进去第一个元素
	}
}


//main
class TreeDataStructure {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();

		//存储自定义对象
		ts.add(new Person("lisi",12));
		ts.add(new Person("lis",12));
		ts.add(new Person("lii",13));
		ts.add(new Person("lsi",14));
	
		Iterator it = ts.iterator();
		while(it.hasNext()) {
			Person p = (Person)it.next();
			out(p.getName() + "..." + p.getAge());
		}
	} 

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例4：TreeSet存储自定义对象

import java.util.*;

/*	TreeSet:
	元素无序，存储自定义对象时，必须保证对象的可比较性，即实现Comparable接口
	覆盖compareTo方法
*/	

//人类
class Person implements Comparable {
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
	
	//覆盖compareTo方法，使对象具有可比较性
	public int compareTo(Object obj) {
		if (!(obj instanceof Person)) {
			throw new RuntimeException("不是人对象！");
		}
		Person p = (Person)obj;

		if (this.age > p.age) {
			return 1;
		}

		if (this.age == p.age) {
			return this.name.compareTo(p.name);
		}

		return -1;
	}
}

//main
class TreeTest {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		/*
		像字符串这类的元素可以直接存储
		ts.add("Java01");
		ts.add("Java02");
		ts.add("Java03");
		*/

		//存储自定义对象
		ts.add(new Person("lisi",12));
		ts.add(new Person("lis",12));
		ts.add(new Person("lii",13));
		ts.add(new Person("lsi",14));
	
		Iterator it = ts.iterator();
		while(it.hasNext()) {
			Person p = (Person)it.next();
			out(p.getName() + "..." + p.getAge());
		}
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例5：用ArrayList实现队列和栈功能

import java.util.*;
/*
	用ArrayList模拟
	堆栈：先进后出
	队列：先进先出
	Author：renpingqing
	Date:2013年7月17日 17:33:11

*/

//堆栈

class MyQueue {
	
	private LinkedList al;

	//构造函数
	public MyQueue() {
		al = new LinkedList();
	}
	
	//增加
	public void add(Object obj) {
//		al.add(obj); //堆栈
		al.addFirst(obj); //队列
	}
	
	//获取
	public Object get() {
		return al.removeLast();
	}
	
	//是否为空
	public boolean isNull() {
		return al.isEmpty();
	}

}

class QueueTest {
	public static void main(String[] args) {
		MyQueue m = new MyQueue();

		m.add("java1");
		m.add("java2");
		m.add("java3");

		while(!m.isNull()) {
			out(m.get());
		}
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例6：ArrayList存储自定义元素并去重

import java.util.*;

/*
	存储自定义元素的容器，并去重
	Author：renpingqing
	Date：2013年7月17日 18:07:34

	思路：
		1、首先定义一容器
		2、存储元素的时候，判断该容器中是否有该元素
	注意：ArrayList判断元素重复是调用该对象的equals方法
*/

//人类
class Person {
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	//复写equals
	public boolean equals(Object obj) {
		if (obj instanceof Person) {
			Person p = (Person)obj;
			return this.name.equals(p.name) && this.age == p.age;
		}
		return false;
	} 
 

}

//main

class SingleTest {
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		
		//添加数据
		al.add(new Person("李四",12));
		al.add(new Person("张三",12));
		al.add(new Person("李四",12));
		al.add(new Person("王武",30));

		out(al);
		
		al = singleElement(al);
		System.out.println();

		out(al);
	}

	//输出元素
	public static void out(ArrayList arr) {
		//迭代器
		Iterator it = arr.iterator();

		while(it.hasNext()) {
			Object obj = it.next();
			
			//因为存储时对象向上转型成Object，所以使用时，要向下转型
			if (obj instanceof Person) {
				Person p = (Person)obj;

				out(p.getName() + "..." + p.getAge());
			}
			
			
		}
	}

	//去重（相同姓名，相同年龄视为同一个人）
	public static ArrayList singleElement(ArrayList al) {
		ArrayList a = new ArrayList();

		Iterator it = al.iterator();

		while(it.hasNext()) {
			Object obj = it.next();
			if (obj instanceof Person) {
				Person p = (Person)obj;
				if (!a.contains(p)) { //contains是调用该对象的equals方法，我们必须复写
					a.add(p);
				}
			}
		}
		return a;
	} 

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例7：HashSet只能存储单一元素原理详解

import java.util.*;

/*
	HashSet存储自定义元素，
	Author；renpingqing
	Date：2013年7月17日 18:44:32
	
	结论：HashSet存储和删除时，是先调用HashCode方法，如果相同，
	则在调用equlas方法
*/
//人类
class Person {
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	//复写equals
	public boolean equals(Object obj) {
		
		if (obj instanceof Person) {
			Person p = (Person)obj;
			HashSetTest.out(this.name + "...equlas..." + p.name); //测试用
			return this.name.equals(p.name) && this.age == p.age;
			
		}
		return false;
	}

	//复写hashCode
	public int hashCode() {
		HashSetTest.out(this.name + "...hashCode"); //测试用
		return name.hashCode() + age * 7;
//		return 39;
	}
	
}

//main
class HashSetTest {
	public static void main(String[] args) {
		HashSet hs = new HashSet();

		//添加数据
		hs.add(new Person("李四",12));
		hs.add(new Person("张三",12));
		hs.add(new Person("李四",12));
		hs.add(new Person("王武",30));

		out("");
		out(hs);
		
	}

	//输出元素
	public static void out(HashSet arr) {
		//迭代器
		Iterator it = arr.iterator();

		while(it.hasNext()) {
			Object obj = it.next();
			
			//因为存储时对象向上转型成Object，所以使用时，要向下转型
			if (obj instanceof Person) {
				Person p = (Person)obj;

				out(p.getName() + "..." + p.getAge());
			}
			
			
		}
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例8：ArrayList存储自定义元素并去重

import java.util.*;

/*
	存储自定义元素的容器，并去重
	Author：renpingqing
	Date：2013年7月17日 18:07:34

	思路：
		1、首先定义一容器
		2、存储元素的时候，判断该容器中是否有该元素
	注意：ArrayList判断元素重复是调用该对象的equals方法
*/

//人类
class Person {
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	//复写equals
	public boolean equals(Object obj) {
		if (obj instanceof Person) {
			Person p = (Person)obj;
			return this.name.equals(p.name) && this.age == p.age;
		}
		return false;
	} 
 

}

//main

class SingleTest {
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		
		//添加数据
		al.add(new Person("李四",12));
		al.add(new Person("张三",12));
		al.add(new Person("李四",12));
		al.add(new Person("王武",30));

		out(al);
		
		al = singleElement(al);
		System.out.println();

		out(al);
	}

	//输出元素
	public static void out(ArrayList arr) {
		//迭代器
		Iterator it = arr.iterator();

		while(it.hasNext()) {
			Object obj = it.next();
			
			//因为存储时对象向上转型成Object，所以使用时，要向下转型
			if (obj instanceof Person) {
				Person p = (Person)obj;

				out(p.getName() + "..." + p.getAge());
			}
			
			
		}
	}

	//去重（相同姓名，相同年龄视为同一个人）
	public static ArrayList singleElement(ArrayList al) {
		ArrayList a = new ArrayList();

		Iterator it = al.iterator();

		while(it.hasNext()) {
			Object obj = it.next();
			if (obj instanceof Person) {
				Person p = (Person)obj;
				if (!a.contains(p)) { //contains是调用该对象的equals方法，我们必须复写
					a.add(p);
				}
			}
		}
		return a;
	} 

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例9：集合转成数组

例9：集合转成数组
import java.util.*;

/*
	ArrayList转成数组
	好处：限制对元素的操作，不需要增删

	<T> T[] toArray(T[] a) 
          按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；
		  返回数组的运行时类型是指定数组的运行时类型。 
	结论：
		1、制定的数组多长为恰当
			当制定类型的数组长度小于集合size那么，该方法会在内部自动开辟一个
		与该size相同的数组
			当制定的数组长度大于集合的size时，就不开辟数组，
		而是使用该数组，没有使用的位置为null，因为数组自动初始化

		由此可以看看出制定的数组大小和size相同时，性能最优
*/

class ArrayListToArray
{
	public static void main(String[] args) {
		ArrayList<String> arr = new ArrayList<String>();

		arr.add("java");
		arr.add("fgava");
		arr.add("jffa");
		arr.add("aa");

		String[] a =  arr.toArray(new String[arr.size()]);

		out(a);
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}

	//输出
	public static void out(String[] s) {
		for(int i=0;i<s.length;i++) {
			System.out.print(s[i] + " ");
		}
	}
}

例10：数组转成集合

import java.util.*;

/*
	Collections.asList()方法实例
	结论：
		1、如果数组中的元素是对象，那么变成集合时，
		数组中的元素直接转成集合中的元素
		2、如果数组中的元素是基本类型，那么会将该数组作为
		集合中的元素，即现在集合中存储的是一个数组
*/

class AsList 
{
	public static void main(String[] args) {
		String[] arr1 = {"Java","gg","aa","cd"};
		
		List<String> al = Arrays.asList(arr1);

		out(al); //[Java, gg, aa, cd]
		int[] nums = {1,5,7,3,8};

		List<int[]> a2 = Arrays.asList(nums);
		out(a2); //[[I@55f33675]

		Integer[] n = {1,5,7,3,8};
		List<Integer> a3 = Arrays.asList(n);
		out(a3); //[1, 5, 7, 3, 8]

	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例11：对集合的元素反转->reverseOrder

import java.util.*;

/*
	static <T> Comparator<T> reverseOrder() 
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
	static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
          返回一个比较器，它强行逆转指定比较器的顺序。 

	测试：
*/

//mian 
class ReverseTest
{
	public static void main(String[] args) {
		reverseElement();
	}

	//元素反转
	public static void reverseElement() {

		//将StrLenComparator()比较器构造器反转
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));

		ts.add("Java");
		ts.add("c++");
		ts.add("aaaff");
		ts.add("c");
		ts.add("ef");
		ts.add("aa");

		out(ts);


	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

//字符串长度排序比较器
class StrLenComparator implements Comparator<String> {
	public int compare(String s1, String s2) {
		int num = s1.length() - s2.length();

		if (num == 0) {
			return s1.compareTo(s2);
		}
		return num;
	}
}

例12：将集合中一部分元素替换成制定元素->fill升级版

import java.util.*;
        /*
        fill方法测试

	练习：将集合中一部分元素替换成制定元素
*/

//mina 
class FillTest {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("Java");
		list.add("c++");
		list.add("aaa");
		list.add("c");
		list.add("ef");
		list.add("aa");

		out(list);

		selfFill(list, "ccc", 1, 4);

		out(list);
	}

	//将集合中一部分元素替换成制定元素
	public static void selfFill(ArrayList<String> list, String key, int start, int end) {
		for (int i=start;i<end;i++) {
			list.set(i, key);
		}
	}

	//full方法测试
	public static void fillTest() {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("Java");
		list.add("c++");
		list.add("aaa");
		list.add("c");
		list.add("ef");
		list.add("aa");

		out(list);

		Collections.fill(list, "Java");

		out(list);
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

例13：ArrayList元素去重

import java.util.*;

/*
	去除ArrayList中的重复元素
	Author：renpingqing 
	Date:2013年7月17日 17:57:04
*/

class ArrayListSingleElement {
	public static void main(String[] args) {
		ArrayList a = new ArrayList();

		a.add("Java1");
		a.add("Java2");
		a.add("Java1");
		a.add("Java3");

		out(a);
		
		a = SingleElement(a);

		out(a);
	}

	//去重方法
	public static ArrayList SingleElement(ArrayList arr) {

		ArrayList al = new ArrayList();

		Iterator it = arr.iterator();
		
		while (it.hasNext()) {
			Object obj = it.next();
			if (!al.contains(obj)) {
				al.add(obj);
			}
		}
		return al;
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}