JAVA中的集合与排序

一:常见的集合类

  Collection接口  和   Map接口

 

 

Collection

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

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

 JAVA中的集合与排序

      ----在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排序是很有必要的;如下面的代码:
 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<Integer> s=new TreeSet<Integer>();
11         s.add(1);
12         s.add(5);
13         s.add(6);
14         s.add(8);
15         s.add(2);
16         s.add(4);
17         System.out.println(s.toString());
18     }
19 }

输出的结果为:

JAVA中的集合与排序

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

那么char类型的呢?????

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<Character> s=new TreeSet<Character>();
11         s.add('a');
12         s.add('g');
13         s.add('e');
14         s.add('b');
15         s.add('c');
16         s.add('d');
17         System.out.println(s.toString());
18     }
19 }

 

 输出的结果为:
JAVA中的集合与排序

 

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

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

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<String> s=new TreeSet<String>();
11         s.add("a");
12         s.add("g");
13         s.add("k");
14         s.add("b");
15         s.add("c");
16         s.add("d");
17         System.out.println(s.toString());
18     }
19 }

 

JAVA中的集合与排序

 

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

 

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

我么直接存放一个对象,代码如下:

 1 package collections;
 2 
 3 import java.util.Set;
 4 import java.util.TreeSet;
 5 
 6 public class Sets {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Set<Student> s=new TreeSet<Student>();
11         s.add(new Student(12,"zz"));
12         s.add(new Student(15,"aa"));
13         s.add(new Student(11,"bb"));
14         s.add(new Student(1,"kk"));
15         s.add(new Student(7,"gg"));
16         for (Student student : s) {
17             System.out.println(student.age+"----"+student.name);
18         }
19     }
20 }

 

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

答案是:

报错,

JAVA中的集合与排序

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

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

 

 1 package collections;
 2 
 3 public class Student implements Comparable<Student>{
 4     public int age;
 5     public String name;
 6     public Student(int age, String name) {
 7         super();
 8         this.age = age;
 9         this.name = name;
10     }
11     @Override
12     public int compareTo(Student o) {
13         // TODO Auto-generated method stub
14         return this.age-o.age;
15     }
16 }

 

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

JAVA中的集合与排序

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

 

 

-----------------------------------------------------------------------------------------------------------------------------------挫挫的分割线,,,下面开始说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 抽象类

里面的主要方法:

JAVA中的集合与排序

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

主要说一下treemap的排序:

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

代码如下:

 1 package collections;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6 import java.util.List;
 7 import java.util.Map;
 8 import java.util.Map.Entry;
 9 import java.util.TreeMap;
10 public class Sets {
11 
12     public static void main(String[] args) {
13         Map<String , Integer> map=new TreeMap<String, Integer>();//传建一个treemap
14         map.put("aa", 1);
15         map.put("ee", 4);
16         map.put("kk", 3);
17         map.put("pp", 8);
18         map.put("qq", 2);
19         //把treemap转换为list集合利用sort排序
20         List<Map.Entry<String, Integer>> list=new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
21         Collections.sort(list,new Comparator<Map.Entry<String, Integer>>() {
22             @Override
23             public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
24                 // TODO Auto-generated method stub
25                 /*if(o1.getValue()==o2.getValue()){
26                     return 0;
27                 }else if(o1.getValue()==o2.getValue()){
28                     return -1;
29                 }else{
30                     return 1;
31                 }*/
32                 return o2.getValue()-o1.getValue();//倒序
33             }
34         });
35         for (Entry<String, Integer> entry : list) {
36             System.out.println(entry.getKey()+"---"+entry.getValue());
37         }
38     }
39 }

 

运行结果:

JAVA中的集合与排序

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

 

欢迎大家一起说出自己的想法。
上一篇:JSON-lib框架,转换JSON、XML不再困难


下一篇:SSM中(Spring-SpringMVC-Mybatis)(一:概念)