java中Collections(ArrayList LinkedList Vector) HashSet HashMap Collections中sort方法Comparator的重写

一.Collections

继承于Collection接口的有ArrayList、Vector、Linkedlist、HashSet、TreeSet，继承于MAP接口的有HashMap、Hashtable

Collections类里面包括动态、有序、可变大小的一维数组Vector与ArrayList。
Vector与ArrayList，两者唯一的差别是：

  vector自带线程互斥，多个线程对其读写会抛出异常
  arraylist则允许多个线程读写，其他部分是一模一样的，换句话说，如果是单线程在读写，使用Vector与ArrayList没有任何区别，但现在编程基本都用ArrayList，使用Vector有点非主流了。

排序方法

Collections.sort(arraylist);//排序
Collections.reverse(arraylist);//逆序

Vector的使用如下：

常用方法总结：
Vector vector = new Vector();
vector.add(1.6);：单纯的add表示从结尾加入元素
vector.size()：size()能求出vector的所含元素的个数
vector.remove(1);：remove(1)表示删去第1个元素，注意计数从0开始
vector.remove(vector.lastElement());：删去最后一个元素
vector.add(0, 1.8888); ：在第0个位置 加入 1.8888这个元素
vector.set(0, “a”);：把第0个位置这个元素 改为 a

ArrayList使用方法

常用方法总结：
ArrayList arraylist = new ArrayList();

1. arraylist.add(1.0);：单纯的add表示从结尾加入元素
2. arraylist.size();：size()能求出所含元素的个数
3. arraylist.remove(1);：remove(1)表示删去第1个元素，注意计数从0开始
4. arraylist.remove(arraylist.size() - 1);：删去最后一个元素
5. arraylist.add(0, 1.8888); ：在第0个位置 加入 1.8888这个元素
6. arraylist.set(0, 9.0);：把第0个位置这个元素 改为 9.0
7. Collections.sort(arraylist); ：如果arraylist不是抽象类型，则支持排序
8. arraylist.get(i);：得到第i个位置的元素值，注意从0开始计数。

ArrayList LinkedList Vector

这三者都实现了List接口，使用方式也很相似，主要区别在于因为实现方式的不同，所以对不同的操作具有不同的效率。

ArrayList

ArrayList是一个可改变大小的数组。当更多的元素加入到ArrayList中时，其大小将会动态地增长。内部的元素可以直接通过get与set方法进行访问，因为ArrayList本质上就是一个数组。

LinkedList

LinkedList是一个双链表，在添加和删除元素时具有比ArrayList更好的性能。但在get与set方面弱于ArrayList。
LinkedList还实现了Queue接口，该接口比List提供了更多的方法，包括offer（），peek（），poll（）等。

特点

Vector和ArrayList类似，但属于强同步类。如果你的程序本身是线程安全的（thread-safe，没有在多个线程之间共享同一个集合/对象），那么使用ArrayList是更好的选择。

矢量和的ArrayList在更多元素添加进来时会请求更大的空间.Vector每次请求其大小的双倍空间，而ArrayList的每次对大小增长50％。

注意：默认情况下ArrayList的初始容量非常小，所以如果可以预估数据量的话，分配一个较大的初始值属于最佳实践，这样可以减少调整大小的开销

常用方法

1>void add(int index, E element)
在指定位置插入元素，后面的元素都往后移一个元素。

2>boolean addAll(int index, Collection<? extends E> c)
在指定的位置中插入c集合全部的元素，如果集合发生改变，则返回true，否则返回false。
意思就是当插入的集合c没有元素，那么就返回false，如果集合c有元素，插入成功，那么就返回true。

3>E get(int index)
返回list集合中指定索引位置的元素

4>int indexOf(Object o)
返回list集合中第一次出现o对象的索引位置，如果list集合中没有o对象，那么就返回-1

5>ListIterator listIterator(int index)
从指定位置开始，返回此列表元素的列表迭代器（按适当顺序）。
和上面那个迭代器不同的就是多了一个参数，就是能控制迭代器开始的位置。

6>E remove(int index)
删除指定索引的对象

7>E set(int index, E element)
在索引为index位置的元素更改为element元素

8>对List进行排序Collections.sort(list);

二、集合：HashSet

HashSet与数学上的集合概念一模一样。由一个或多个元素所构成的叫做集合。

HashSet具有：
确定性，集合中的元素必须是确定的。
互异性，集合中的元素互不相同。
无序性，集合中的元素没有先后之分。因此HashSet也不得进行排序操作。

常用方法总结：
HashSet hashset = new HashSet();

1. hashset.add(1);：错误理解：单纯的add表示从结尾加入元素；正确理解：在hashset中插入元素“1”，位置不确定！
2. hashset.size():size()能求出所含元素的个数
3. hashset.remove(1);:remove(1)表示删去“1”这个元素
4. hashset.remove(“asd”);:如果没有’asd’这个元素则remove什么都不做
5. HashSet有add()方法与remove()方法，add()所加的元素没有顺序

二元组：HashMap

这里的使用方法和上面的数据基本相同，也很简单，就是put方法来对象进去map，而get能够取走map中的对象，但是试图把二元组HashMap用成三元组是错误的，如果一个对象中含有元素过多，那你应该考虑用类。而不是还在迷恋Java中介乎于普通变量与Class类之间的Collections类。

HashMap就是一个散列表，它是通过“拉链法”解决哈希冲突的。
影响HashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。

容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。
加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

HashMap的主要对外接口
clear()：clear() 的作用是清空HashMap。它是通过将所有的元素设为null来实现的。
containsKey()：containsKey() 的作用是判断HashMap是否包含key。
containsValue()：containsValue() 的作用是判断HashMap是否包含“值为value”的元素。
entrySet()、values()、keySet()：它们3个的原理类似，这里以entrySet()为例来说明。entrySet()的作用是返回“HashMap中所有Entry的集合”，它是一个集合。
get()：get() 的作用是获取key对应的value。
put()：put() 的作用是对外提供接口，让HashMap对象可以通过put()将“key-value”添加到HashMap中。若要添加到HashMap中的键值对对应的key已经存在HashMap中，则找到该键值对；然后新的value取代旧的value，并退出！若要添加到HashMap中的键值对对应的key不在HashMap中，则将其添加到该哈希值对应的链表中，并调用addEntry()。addEntry() 的作用是新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。
putAll()：putAll() 的作用是将”m”的全部元素都添加到HashMap中。
remove()：remove() 的作用是删除“键为key”元素。

总结：
void clear()
Object clone()
boolean containsKey(Object key)
boolean containsValue(Object value)
Set<Entry<K, V>> entrySet()
V get(Object key)
boolean isEmpty()
Set keySet()
V put(K key, V value)
void putAll(Map<? extends K, ? extends V> map)
V remove(Object key)
int size()
Collection values()

四、使用技巧

在创造一个新的Vector,Arraylist好，HashSet也好，HashMap也好，完全可以写成：
Collection a= new ArrayList();
List a= new Vector();

Collections中sort方法Comparator的重写

sort方法：其中的一个参数是接口！！！ 定义好排序规则，设置好返回值，马上变成排序利器！
注意现实：比较器Comparator是一个接口！
设定比较规则，即自定义比较器Comparator：
//自己定义的类结构
class Student {
【Java】Collections中sort方法Comparator的重写
import java.util.*;
//以下是学生类Student定义，有点类似C语言的结构体啊！^_
class Student {
public int s_no;
public String s_name;
public int s_class;
}

public class compareTest {
public static void main(String[] args) {
//存放学生类的动态数组的初始化
ArrayList studentArr = new ArrayList();
Student s1 = new Student();
s1.s_no = 3;
s1.s_name = “a”;
s1.s_class = 102;
studentArr.add(s1);
Student s2 = new Student();
s2.s_no = 2;
s2.s_name = “b”;
s2.s_class = 101;
studentArr.add(s2);
Student s3 = new Student();
s3.s_no = 1;
s3.s_name = “c”;
s3.s_class = 103;
studentArr.add(s3);
//初始化之后先打印以下这个动态数组
System.out.println(“排序前：”);
for (int i = 0; i < studentArr.size(); i++) {
System.out
.println(“我是” + studentArr.get(i).s_class + “班的”
+ studentArr.get(i).s_name + “学号是”
+ studentArr.get(i).s_no);
}
//对于Comparator接口的重写
//这个接口就一个抽象函数，给出的参数与返回值都是定死的。
Collections.sort(studentArr, new Comparator() {
public int compare(Object o1, Object o2) {
//你首先设置你要比较的东西
//具体是把参数中的Object强制转换成你要比较的东西，这里是两个Student类
//这里的s1,s2与上面的s1,s2一点关系都没有，只是抽象的前者与后者的关系
Student s1 = (Student) o1;
Student s2 = (Student) o2;
//如果前者的学号大于后者的学号，就是前者大于后者，返回1系统就会识别是前者大于后者
if (s1.s_no > s2.s_no) {
return 1;
}
//小于同理
if (s1.s_no < s2.s_no) {
return -1;
}
//如果返回0则认为前者与后者相等
return 0;
}
});
//比较完毕再输出以学号排序之后的结果
System.out.println(“按学号升序排序后：”);
for (int i = 0; i < studentArr.size(); i++) {
System.out
.println(“我是” + studentArr.get(i).s_class + “班的”
+ studentArr.get(i).s_name + “学号是”
+ studentArr.get(i).s_no);
}
//以下是以班级排序的过程
Collections.sort(studentArr, new Comparator() {
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
if (s1.s_class > s2.s_class) {
return 1;
}
if (s1.s_class < s2.s_class) {
return -1;
}
return 0;
}
});
System.out.println(“按班级升序排序后：”);
for (int i = 0; i < studentArr.size(); i++) {
System.out
.println(“我是” + studentArr.get(i).s_class + “班的”
+ studentArr.get(i).s_name + “学号是”
+ studentArr.get(i).s_no);
}
}
}

public int s_no;  
public String s_name;  
public int s_class;  

}
//待排序的对象实例
ArrayList studentArr = new ArrayList();
//重新写比较器
//Comparator接口，两个对象要使用compareTo方法比较大小，就必须实现Comparator接口的compare方法;
//比如String就实现了这个方法，所以可以直接使用compareTo进行比较。
//sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。
Collections.sort(studentArr, new Comparator() {
@Override
public int compare(Object o1, Object o2){
//你首先设置你要比较的东西
//具体是把参数中的Object强制转换成你要比较的东西，这里是两个Student类
//这里的s1,s2与上面的s1,s2一点关系都没有，只是抽象的前者与后者的关系
Student s1 = (Student) o1;
Student s2 = (Student) o2;
//如果前者的学号大于后者的学号，就是前者大于后者，返回1系统就会识别是前者大于后者
if (s1.s_no > s2.s_no) {
return 1;
}
//小于同理
if (s1.s_no < s2.s_no) {
return -1;
}
//如果返回0则认为前者与后者相等
return 0;
}
});