java集合

集合简介：集合是一个类，集合大致可分为3中体系set（无序，不可重复的集合）、List（有序，重复的集合）、map（映射关系的集合）、Java5后加入Queue（队列集合）。集合中保存的数据是对象（其实平常所以的对象多指对象的引用）。

·集合概念：
集合跟数组类似。区别是数组元素可存储基本类型和对象类型，而集合中存储的值只能是对象（其实都是对象的引用变量），数组中存储的数据长度不可变，但集合中存储的对象数据多少可以随时添加与删除。

·集合中放置的都是[color=blue]Object类型[/color]，因此取出来的值也都是Object类型，所有最后取出来的值要强制转换成真正的类型（就是放进去是什么类型取出来还是什么类型）。

·MAP：map保存的是key --> value 对，map里的key不能重复。

·[color=blue]集合类位于java.util.* [/color]下

Java集合：
[color=blue]

常用集合类： List（ArrayList， LinkedList，vector），Set（HashSet，TreeSet）
Map（HashMap， TreeMap,hashtable）[/color]


·访问集合元素：
[color=blue]1、Set集合无序不重复，所以只能根据元素本身来访问到它。
2、List集合有序重复，所以可以根据元素的索引来访问到它。
3、Map 映射，根据key来访问值。
[/color]
·Collection和Iterator接口
·通过上图可以看出，[color=blue]Collection是Set，queue和List的父接口[/color]。


Collection接口的方法：
boolean [color=blue]add[/color](Object o) 向集合中加入一个对象的引用
void clear()：删除集合中所有的对象，即不再持有这些对象的引用
boolean isEmpty()判断集合是否为空
[color=blue]boolean contains(Object o)[/color] 判断集合中是否持有特定对象的引用
[color=blue]Iterartor iterator()[/color]返回一个Iterator对象，可以用来遍历集合中的元素
[color=blue]boolean remove(Object o)[/color]从集合中删除一个对象的引用
int size() 返回集合中元素的数目
[color=blue]Object[] toArray()[/color] 返回一个数组，该数组中包括集合中的所有元素

关于：Iterator() 和toArray() 方法都用于集合的所有的元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。

·Iterator：为集合的迭代器，用来迭代集合的所有元素。所有集合都实现了Iterator接口的iterator方法。

·Iterator接口方法：
[color=blue]1、 boolean hasNext() ：如果集合中还有下一个元素则返回true，用在for while循环的条件判断中。
2、 Object next() ：返回集合中的下一个元素。
3、 void remove() ：删除集合中上一次next()返回的元素。[/color]

·遍历集合：Iterator，while，增强for遍历集合。

例子：
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class IteratorTest
{
public static void main(String[] args)
{
Collection c = new HashSet();
c.add("a");
c.add("b");
c.add("c");

[color=blue] Iterator it = c.iterator();[/color]

//使用while语句与iterator
while([color=blue]it.hasNext()[/color])
{
[color=blue] String sit = (String)it.next(); [/color]
System.out.println(sit);
}

System.out.println("-----------------");

//使用for与iterator
for(Iterator itfor = c.iterator(); itfor.hasNext();)
{
String sitfor = (String)itfor.next();
System.out.println(sitfor);
}

System.out.println("--------------------");

//使用foreach语法
for(Object s : c)
{
String sfor = (String)s;
System.out.println(sfor);
}
}
}

·Set

·Set接口与 collection接口基本上完全一样，set没有提供任何额外方法，Set不允许包含重复元素。Set 常用的包含HashSet与TreeSet。HashSet底层是有HashMap实现的。

·HashSet:

特点：
1、无序。
2、不允许相同值添加到集合中。


存放的是对象的引用，没有重复对象

Set set=new HashSet();  

String s1=new String("hello");  

String s2=s1;  

String s3=new String("world");  

set.add(s1);  

set.add(s2);  

set.add(s3); 

System.out.println(set.size());//打印集合中对象的数目 为 2。

·存储原理：存入一个元素时调用该对象的hashCode()方法获得hashCode值，根据HashCode值决定该对象存储的位置，所以存储与读取该元素时会很快，一下就能定位到元素的位置.

·HashSet底层是使用HashMap实现的。当使用add方法将对象添加到Set集合中时，实际上是Map对象的key，而Map key对应的value我们没有用到。

·HashSet判断重复元素有两个条件：
使用equal判断两个对象是否为true并且两个对象的hashcode值相同，则判定为同一个对象就不能添加进集合，否则如果不能同时满足两个条件就能将元素添加进集合。

出现的情况：
1、hashCode值相同equal相同则为同一对象，不会存入集合。
2、hashCode值相同equal值false，可以存入集合。保存在相同位置，用链式结构保存多个对象。因为HashSet通过hashCode值定位元素位置，如果hashcode值相同那么会影响性能。
3、hashCode值不同equal值true，可以存入集合。存到了不同的位置。
4、hashCode值不同equal值false，可以存入集合。存到不同位置。实际当中，当元素的hashCode值相同时，equal值一定要保持为true。如果重新hashCode，那么一定要对应的重写equal。

·LinkedHashSet
LinkedHashSet存储位置也是由hashCode值来决定的，但是他使用链表来维护元素的次序，遍历LinkedHashSet时，HashSet会以存入的次序取出元素。

·TreeSet

·Set集合无序但是TreeSet是有序的，TreeSet使元素值处于排序状态（由小到大）。TreeSet实现SortedSet接口。

·Set元素不能重复TreeSet也一样，TreeSet判断是不是同一个元素：通过equals比较返回true，并且通过compareTo方法或compare比较返回0

·TreeSet比其他Set多了几个方法：
Comparatorcomparator() ：返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回null
Object first() :返回Set中第一个元素（最小的）。
Object last() :返回Set中最大的一个元素。
Object lower(Object e) : 返回Set中小于e的元素。
Object higher(Object e) :返回Set中大于e的元素。
SortedSet subSet(fromElement,toElement) :返回Set中fromElement(包含本身)到toElement(不包含本身)的元素。
SortedSet headset(toElement) : 返回toElement前面的元素。
SortedSet tailSet(fromElement) : 返回fromElement后面的元素。


例子a：

import java.util.Set;
import java.util.TreeSet;

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

        ts.add(-1);  
        ts.add(-3);  
        ts.add(12);  
        ts.add(1);  

        System.out.println(ts); // 打印结果 [-3, -1, 1, 12]
        System.out.println(ts.first());   // -3
        System.out.println(ts.last()); // 12
        System.out.println(ts.subSet(1,12)); // [1]
    }  
}  

·TreeSet支持两种排序算法，自然排序和定制排序:

·自然排序：就是升序。

·Comparable接口中包含compareTo(Objectobj)方法，实现该接口类的对象就可以比较大小，比如:a.compareTo(b) 返回负数表示对象a小于对象b，返回0表示a与b相当，返回正数表示a大于b。一些常用类已经实现了该接口的该方法，如：Ingeger数字类，Dage日期类，String字符类，Charater类，Boolean类。

·Comparator接口包含compare(To1, T o2)方法也叫比较器，例如TreeSet类有一个构造器接受Comparator的比较器，比较器是自己定义的比较大小的规则，当compare方法返回负数时表示o1对象小于o2对象，返回0时表示o1与o2相等，返回正数时表示o1大于o2。compare用在自定义的类中需要自己定义排序规则如正序倒序等，比如自己创建一个类类中创建TreeSet集合，此时就能定义一个排序规则的类，然后将这个类的compare比较器传给TreeSet接受Comparator类型参数的构造器就好了，后面有一个例子。

自然排序列子：
上面例子a就是自然排序。因为Integer类实现了compareTo接口都是按照自然排序来的。

自定义排序：
反排序：
import java.util.*;

public class TreeSetTest3
{
public static void main(String[] args)
{
TreeSet s = new TreeSet(new MyComparator()); //因为集合是带泛型声明的，这里没有赋予泛型实参，所以默认就是Object类型的。

s.add("A"); //这里面的类型是Object的子类
s.add("C");
s.add("B");

for(Object si : s) //这里的si和s都是Object类型的，并不是String类型的
{
String sic = (String)si; //所以这里需要进行强制类型转换
System.out.println(sic); //这样才能输出正确的结果，不然会报错类型错误
}
}
}

class MyComparator implements Comparator //TreeSet构造器传入的Comparator类，实现compare方法
{
public int compare(Object a, Object b)
{
String a1 = (String)a;
String b1 = (String)b;
return b1.compareTo(a1); //这里是String类的Comparable接口的compareTo方法。这里b1比a1就是反排序，a1比b1就是自然排序了。
}
}

·如果用自定义的类型的数据的话，那么不能比较两个对象类型的大小，因为自定义类型没有实现compara方法，可以自行实现一个compara比较器后就能进行自定义排序了，否则没有比较器会报错的。