JAVA中的集合与排序

一：常见的集合类

　　Collection接口  和   Map接口

Collection

　①：collection是最常见的集合的上级接口。

　②：继承自collection的常用接口有List，Set，都是单列的集合。

　

　　　　　　----在List下面的集合实现类主要有   Arraylist，LinkedList

　　　　　　----在Set下面的主要实现类有 HashSet，TreeSet

　　List和Set的特性和区别：

　　①：首先list和set都是单列集合；

　　②：list里面的元素是有序的可重复的；

　　③：set集合里面的元素是无序的不可重复的；

　　④：list集合可以根据下标获取对应的元素，而set则只能遍历全部集合才能获取对应的元素；

Set：

boolean	add(E o)           如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean	addAll(Collection<? extends E> c)           如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void	clear()           移除 set 中的所有元素（可选操作）。
boolean	contains(Object o)           如果 set 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)           比较指定对象与此 set 的相等性。
int	hashCode()           返回 set 的哈希码值。
boolean	isEmpty()           如果 set 不包含元素，则返回 true。
Iterator<E>	iterator()           返回在此 set 中的元素上进行迭代的迭代器。
boolean	remove(Object o)           如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean	removeAll(Collection<?> c)           移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean	retainAll(Collection<?> c)           仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int	size()           返回 set 中的元素数（其容量）。
Object[]	toArray()           返回一个包含 set 中所有元素的数组。
<T> T[]	toArray(T[] a)           返回一个包含 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

　　

HashSet

 

HashSet底层用的是哈希表，它把对象根据其哈希值存放到对应的区域里。由于这种特性，两个在不同区域的对象会被认为不相同的。

所以如果对象要存放到Hash集合里面，则需要重写对象的hashCode方法，让相等的对象的hashCode的值也相等。

 

TreeSet

 

TreeSet采用的数据结构是红黑树，我们可以让它按指定规则对其中的元素进行排序。它又是如何判断两个元素是否相同呢？除了用equals方法检查两个元素是否相同外，还要检查compareTo方法是否返回为0。

所以如果对象要存放到Tree集合里，需要在重写compareTo时，把相同的对象的比较值定为0，防止相同的元素被重复添加进集合中。

 

Set的排序：

我们有时候需要的是一个有序的集合，所以排序是很有必要的，在Set中使用treeset排序是很有必要的；如下面的代码：

package collections;

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

public class Sets {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Set<Integer> s=new TreeSet<Integer>();
        s.add(1);
        s.add(5);
        s.add(6);
        s.add(8);
        s.add(2);
        s.add(4);
        System.out.println(s.toString());
    }
}

输出的结果为：

 可见，当存储的数据为int类型的时候，treeset是可以自动进行排序的；

那么char类型的呢？？？？？

package collections;

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

public class Sets {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Set<Character> s=new TreeSet<Character>();
        s.add('a');
        s.add('g');
        s.add('e');
        s.add('b');
        s.add('c');
        s.add('d');
        System.out.println(s.toString());
    }
}

 输出的结果为：

可见这是按照字母的顺序去排列的；

那如果是一个不一样的String呢？？？？

package collections;

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

public class Sets {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Set<String> s=new TreeSet<String>();
        s.add("a");
        s.add("g");
        s.add("k");
        s.add("b");
        s.add("c");
        s.add("d");
        System.out.println(s.toString());
    }
}

可见对于String类型来说，也是按照字母的顺序来排列的；

那如果对象里面存放的是一个对象，那该如何进行排序???????????????????????????????????

我么直接存放一个对象，代码如下：

package collections;

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

public class Sets {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Set<Student> s=new TreeSet<Student>();
        s.add(new Student(12,"zz"));
        s.add(new Student(15,"aa"));
        s.add(new Student(11,"bb"));
        s.add(new Student(1,"kk"));
        s.add(new Student(7,"gg"));
        for (Student student : s) {
            System.out.println(student.age+"----"+student.name);
        }
    }
}

你们猜一下运行的结果是什么？？？？？

答案是：

报错，

因为对于一个对象来说，我们没有什么直观的条件去比较，上面报错也说了不能比较这个student对象，那我们该怎么办？？？？？？

当然是重写Comparable的比较方法啦，代码如下：

package collections;

public class Student implements Comparable<Student>{
    public int age;
    public String name;
    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Student o) {
        // TODO Auto-generated method stub
        return this.age-o.age;
    }
}

我们在student对象上实现Comparable接口，重写里面的比较方法，这写的是按照年龄age去正序比较 运行结果如下

如果想比较里面的 名字，或者按照倒序排列，反过来写就好了，你们可以试一试；

-----------------------------------------------------------------------------------------------------------------------------------挫挫的分割线，，，下面开始说List----------------------------------------------------------------------------------------------------------------------------------------------

List

List 接口继承了 Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

常用的方法如下：

boolean	add(E o)           向列表的尾部追加指定的元素（可选操作）。
void	add(int index, E element)           在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extends E> c)           追加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extends E> c)           将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear()           从列表中移除所有元素（可选操作）。
boolean	contains(Object o)           如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)           比较指定的对象与列表是否相等。
E	get(int index)           返回列表中指定位置的元素。
int	hashCode()           返回列表的哈希码值。
int	indexOf(Object o)           返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。
boolean	isEmpty()           如果列表不包含元素，则返回 true。
Iterator<E>	iterator()           返回以正确顺序在列表的元素上进行迭代的迭代器。
int	lastIndexOf(Object o)           返回列表中最后出现指定元素的索引，如果列表不包含此元素，则返回 -1。
ListIterator<E>	listIterator()           返回列表中元素的列表迭代器（以正确的顺序）。
ListIterator<E>	listIterator(int index)           返回列表中元素的列表迭代器（以正确的顺序），从列表的指定位置开始。
E	remove(int index)           移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o)           移除列表中出现的首个指定元素（可选操作）。
boolean	removeAll(Collection<?> c)           从列表中移除指定 collection 中包含的所有元素（可选操作）。
boolean	retainAll(Collection<?> c)           仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element)           用指定元素替换列表中指定位置的元素（可选操作）。
int	size()           返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex)           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[]	toArray()           返回以正确顺序包含列表中的所有元素的数组。
<T> T[]	toArray(T[] a)           返回以正确顺序包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

 实现list的两个常用的集合有      ayyarlist  linkedlist

arraylist 与linkedlist的区别

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList遍历全部再确定。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

总结：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：：

Collection是集合接口
    |————Set子接口:无序，不允许重复。
    |————List子接口:有序，可以有重复元素。

    区别：Collections是集合类

    Set和List对比：
    Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。
    List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

    Set和List具体子类：
    Set
     |————HashSet：以哈希表的形式存放元素，插入删除速度很快。

    List
     |————ArrayList：动态数组
     |————LinkedList：链表、队列、堆栈。

 

------------------------------------------------------------------------------------------------挫挫的分割线，，，下面开始说Map---------------------------------------------------------------------------------------------------------

map：

实现Map集合的     常用的主要有   HashMap 类和 TreeMap 类

Map 有以下特点：

• 没有重复的 key
• 每个 key 只能对应一个 value, 多个 key 可以对应一个 value
• key,value 都可以是任何引用类型的数据，包括 null
• Map 取代了古老的 Dictionary 抽象类

里面的主要方法：

hashmap我们基本天天用就不说了-------->>>>>>>>可看博客为：http://blog.csdn.net/zhangqj_/article/details/53486115

主要说一下treemap的排序：

如果只是实现Comparator的隐藏类进行排序，只能按照key去排序，但是这样的话远远不能满足我们的需求，还是按照value去排序的比较多，那么我们可以让其先转化为list集合再利用sort方法进行排序；

代码如下：

package collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
public class Sets {

    public static void main(String[] args) {
        Map<String , Integer> map=new TreeMap<String, Integer>();//传建一个treemap
        map.put("aa", 1);
        map.put("ee", 4);
        map.put("kk", 3);
        map.put("pp", 8);
        map.put("qq", 2);
        //把treemap转换为list集合利用sort排序
        List<Map.Entry<String, Integer>> list=new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
        Collections.sort(list,new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                /*if(o1.getValue()==o2.getValue()){
                    return 0;
                }else if(o1.getValue()==o2.getValue()){
                    return -1;
                }else{
                    return 1;
                }*/
                return o2.getValue()-o1.getValue();//倒序
            }
        });
        for (Entry<String, Integer> entry : list) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
    }
}

运行结果：

很明显，集合已经按照倒序排列了，如果要正序可以该表写法，当然也能利用key进行排序，使用key去compare就好了；