标签：
学习内容：集合框架简介；Collection集合及其子类；Map集合及其子类；集合工具类和数组工具类；
一、集合框架简介
1，集合的特点
集合的出现是用于存储对象。所以集合也是一个容器。
数组也是一个容器，也可以存储对象，但是长度固定；集合长度是可变的。
还有，数组中可以存储基本数据类型和引用数据类型（对象），而集合仅仅可以存储引用数据类型（对象）且集合中可以存储不同类型的对象。
2，Collection集合这个大家庭
Collection :List,Set
Map:Hashtable,HashMap,TreeMap
工具类 Arrays Collections
迭代器 Iterator ListIterator
二、 Collection 集合及其子类
1， Collection :
List:存储的元素是有序的（存放和取出的顺序一致），并且元素可以重复（因为元素有索引嘛）
|--- ArrayList:底层实现的数据结构是数组，对其里面的元素增删频繁的话，效率略低，查找比较快。
|--- LinkedList:底层实现的数据结构是链表，对其里面的元素增删频繁的话，效率高，查找比较慢。
|--- Vector:底层实现的数据结构是数组，这个对象是同步的，并且她还有一个特有的取出方式--枚举
Set:存储的元素是无序的，元素不可以重复。set集合的功能和collection的功能基本上一致的。
|---HashSet:底层实现的方式是哈希表
|---TreeSet:底层实现的方式是二叉树。这个集合有个特点，她可以实现所存的元素排序。
2，各个子类对象如何保证里面所存的元素的唯一性呢？
1）对于List集合的子类，他是通过复写Object类中的equals（）方法来建立自己独有的比较方式来判断该集合中存放的元素是否相同。
2）对于HashSet这个子类对象，她要保证所存元素不是重复，根据的是覆写Object类中的hashcode（）和equals（）方法来建立自己独有的比较方式来保证元素的不重复。
3）对于TreeSet这个子类对象，她保证元素唯一性的方式有点特殊。是通过compareTo（）或者compare（）方法来的返回值来保证的
3，迭代器
对于Collect集合有一个特殊的遍历方法，就是迭代器Iterator，里面有三个方法，hasNext（）判断是否还有元素迭代，next（）取出元素，remove（）从迭代器指向的集合移除指向的最后一个元素。但是对于List家族，她还有一个自己特有的迭代器ListIterator,她可以在迭代过程中对元素进行很多操作。
4，TreeSet集合中怎么使元素具备比较性？
一种方式是在定义元素时，让其复写Comparable接口中的public int compareTo（Object obj)方法，让元素自身具备比较性。另外一种方式，定义一个类实现Comparator接口，复写其中的public int compare（Object o1,Object o2）这个方法，建立对应的比较方式，然后再建立这个类的对象作为参数传递给集合来实现集合中元素的比较。
另外还要注意一点：当Comparable和Comparator同时存在的话，以Comparator的比较方式为准。
5,Collection集合举例
1），需求：自定义Student对象，存储到ArrayList集合中，里面的Student不能重复，判断重复的标准是姓名和年龄一样为同一个人。代码如下：
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
class Student{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean equals(Object obj){
Student st = (Student)obj;
return this.age == st.age&&this.name == st.name;
}
}
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList<Student> al = new ArrayList<Student>();
al.add(new Student("lisi",25));
al.add(new Student("lisi",25));
al.add(new Student("zhangsan",25));
al.add(new Student("zhangsan",77));
al.add(new Student("zhangsan",25));
System.out.println("原集合为：");
show(al);
al = singleElement(al);
System.out.println("更新后集合为：");
show(al);
}
public static void show(ArrayList<Student> al){
Iterator<Student> it = al.iterator();
while(it.hasNext())
{
Student st = it.next();
System.out.println(st.getName()+":"+st.getAge());
}
}
public static ArrayList<Student> singleElement(ArrayList<Student> al){
ArrayList<Student> a = new ArrayList<Student>();
Iterator<Student> itr = al.iterator();
while(itr.hasNext())
{
Student st = itr.next();
if(!(a.contains(st)))
{
a.add(st);
}
}
return a;
}
}
2）需求：定义一个学生类，将他存入TreeSet集合中，相同年龄和姓名的视为同一个元素，元素的大小以姓名为主要判断条件，当姓名相同时，以年龄为次要判断条件。
package Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
class Person2 implements Comparable{
private String name;
private int age;
public Person2(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int compareTo(Object o) {
// TODO Auto-generated method stub
try {
if(!(o instanceof Person2))
throw new Exception("不是人类");
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println(e.getMessage());
}
Person2 p = (Person2)o;
int num = this.getName().compareTo(p.getName());
if(num == 0)
return this.getAge()-p.getAge();//new Integer(this.getAge()).compareTo(new Integer(p.getAge()));
return num;
}
}
class MyComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
Person2 p1 = (Person2)o1;
Person2 p2 = (Person2)o2;
int num = new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
if(num == 0)
return p1.getName().compareTo(p2.getName());
return num;
}
}
public class TreeSetTest1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet ts = new TreeSet(new MyComparator());
ts.add(new Person2("D",21));
ts.add(new Person2("C",22));
ts.add(new Person2("B",23));
ts.add(new Person2("A",21));
Iterator it = ts.iterator();
while(it.hasNext())
{
Person2 p = (Person2)it.next();
System.out.println(p.getName()+"......"+p.getAge());
}
}
}
三、Map集合及其子类
1，概述
Map集合存储的是键值对，一对一往里面存储，而且要保证键的唯一性。
2，Map这个大家庭和Map家庭成员的特点
Map
|--Hashtable:底层是哈希表数据结构，不可以存入Null键null值，该集合是线程同步的，出现于JDK1.0，效率比较低。键要复写hashCode（）和equals（）方法
|--HashMap:底层是哈希表数据结构，允许使用Null键和null值，该集合是不同步的，出现于JDK1.2,效率高。键也要复写hashCode（）和equals（）方法
|--TreeMap：底层是二叉树数据结构，可以用于给map集合的键进行排序。要么元素实现Comparable接口，要么建立一个实现了Comparator接口的类作为参数传递给集合。
3，Map集合的两种取出方式
一）使用集合的keySet（）方法，将Map集合中的键全部取出放入Set集合中，然后使用Set集合的迭代器将里面的键出去，然后通过键再取出Map集合中的值。
2）使用集合的entrySet（）方法，将Map集合中键和值的关系取出放入到Map.Entry这个对象中，这个对象也存放在Set集合中，然后通过Set集合的迭代器，将里面存储的键和值的关系取出，然后通过关系取出键和值。
4，示例
需求：定义一个学生类，将他存入HashMap集合中,学生对象做键，学生地址做值，相同年龄和姓名的视为同一个元素，元素的大小以姓名为主要判断条件，当姓名相同时，以年龄为次要判断条件。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.xml.crypto.dsig.spec.HMACParameterSpec;
class Student implements Comparable<Student>{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int hashCode(){
return this.name.hashCode()+age*77;
}
public boolean equals(Object obj){
try{
if(!(obj instanceof Student))
throw new Exception("不是学生对象，无法比较");
}
catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
@Override
public int compareTo(Student st) {//建立姓名的比较方式 然后参考的是年龄
// TODO Auto-generated method stub
int num = this.getName().compareTo(st.getName());
if(num == 0)
return new Integer(this.getAge()).compareTo(new Integer(st.getAge()));
return num;
}
}
public class HashMapTest1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
HashMap<Student,String> hs = new HashMap<Student,String>();
hs.put(new Student("lisi",34),"zhengzhou");
hs.put(new Student("wangwu",32),"tianjin");
hs.put(new Student("maiz",23),"wulumuqi");
hs.put(new Student("wanger",34),"wuhan");
hs.put(new Student("lisi",34),"zhengzhou");
//第一种取出方式
Set<Student> keySet = hs.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext()){//打印出来的结果是无序的
Student st = it.next();
String str = hs.get(st);
System.out.println(st.getName()+":"+st.getAge() +"....."+str);
}
//第二种取出方式
Set<Map.Entry<Student,String>> entrySet = hs.entrySet();
Iterator<Map.Entry<Student,String>> itr = entrySet.iterator();
while(itr.hasNext()){
Map.Entry<Student,String> mp = itr.next();
Student s = mp.getKey();
String ss = mp.getValue();
System.out.println(s.getName()+":"+s.getAge() +"..."+ss);
}
}
}
四、集合工具类和数组工具类；
集合工具类Collections完全在collection上进行操作或者返回collection的静态方法组成，如果为此类的方法提供的collection或者类对象为null，这这个方法会抛出NullPointerException（空指针异常）。里面的方法多种多样，都是操作集合collection的
数组工具类Arrays中的方法也都是静态的，对可以对数组进行各种各样的操作。
注：java5.0之后出现的新特性，例如，泛型，静态导入，可变参数，增强for循环等
Java学习日记num9
标签：
原文地址：http://www.cnblogs.com/Rebecca-gg/p/4466331.html
