java collection （二）

1。集合的概念：

（1）现实生活中：很多的事物凑在一起。

（2）数学中的集合：具有共同属性的事物的总体。

（3java 中的集合类： 是一种工具类，就像是容器，存储任意数量的具有共同属性的对象。（集合中只能存放对象类型）

2.集合的作用：

（1）在类的内部，对数据进行组织；

（2）简单而快速的搜索大数量的条目；

（3）有的集合接口（Collection 子接口），提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素；

（4）有的集合接口（map 子接口），提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型。

3.集合与数组的对比———为何选择集合而不是数组：

（1）数组的长度是固定的，集合的长度可变。

（2）数组只能通过下标访问元素，类型固定，而有的集合（map 子接口）可以通过任意类型查找所映射的具体对象。

4.Collection接口，子接口以及实现类

接口不能定义对象，实现类才可以实例化。

例如：

List li2=new ArrayList();

Map <String,String> map2=new HashMap<>();

Set<Integer> set=new HashSet();

4.1Collection 接口

（1）是LIst.Set 和Queue接口的父接口。

（2）定义了可用于操作List.Set和Queue的方法——增删该查

5.List接口

5.1List接口及其实现类——ArrayList

(1)List是元素有序并且可以重复的集合，被称为序列。

（2）List可以精确的控制每一个元素的插入位置或删除某个位置元素。

（3）ArrayLis——数组序列，是List的一个重要实现类。

（4）ArrayList 底层是由数组实现的。

注意：对象存入集合都变成object 类型取出时需要类型转换。

5.2List 增加元素

（1）add:添加一个元素；

例如：

List li= new ArrayList();

public   static void addStudent ( List li){

for (int i=0;i<5;i++){

Coure crs=new Coure(i+1,i+"年级语文");

Student stu = new Student (i+1,"小张"+i,crs);

//一条一条的添加

li.add(stu);

}

（2）addAll:将一个集合中的所有元素添加到另一个集合中；

例如：

List li2=new ArrayList();

for (int i=0;i<5;i++){

Coure crs=new Coure(i+6,i+"年级语文");

Student stu = new Student (i+6,"小张"+i,crs);

li2.add(stu);

}

//望集合中添加另一个集合的数据

li.addAll(li2);

5.3 List 获取元素

（1）get 方法： 通过位置获取元素

public static void deleteData(List li){

//移除一个元素

li.remove(0);

li.remove(li.get(0));

//移除一个集合

List li2=new ArrayList();

li2.add(li.get(0));

li2.add(li.get(1));

li2.add(li.get(2));

li.removeAll(li2);

}

5.4 List 遍历元素

（1）for 循环遍历，通过下标取值。

例如：

public static void deleteData(List li){

//移除一个元素

li.remove(0);

li.remove(li.get(0));

//移除一个集合

List li2=new ArrayList();

li2.add(li.get(0));

li2.add(li.get(1));

li2.add(li.get(2));

li.removeAll(li2);

（2）for each 遍历（实质上就是迭代器的简写）

例如：

 public static void  printList2(List li){
           System.out.println("================================");
           System.out.println("我是通过for each 循环遍历的");
           for (Object obj: li){
               Student item=(Student ) obj;
               System.out.println("学生id:"+item.getId()+",学生姓名:"+item.getName()+",学生课程："
               +item.getCoure().getName());
           }
       }

（3）迭代器（Iterator）：只能用来遍历集合；

例如：

 public static void  printList3(List li){
           System.out.println("================================");
           System.out.println("我是通过 iterator 循环遍历的");
           Iterator <Object> it=li.iterator();
           while(it.hasNext()){
               Student item=(Student )it.next() ;
               System.out.println("学生id:"+item.getId()+",学生姓名:"+item.getName()+",学生课程："
               +item.getCoure().getName());
           }
       }

5.5 List 修改元素
set 方法：通过位置修改；

例如：

public static void changeData(List li){
        Coure crs= new Coure(12,"11年级语文");
        Student stu = new Student (12,"王小花",crs);
        li.set(1, stu);
    }

5.6 List 删除元素

（1）remove

li.remove(0);//删除li 集合中下标为0的元素

（2）removeAll

li.removeAll(li2);  //删除li 集合中 li2集合中的所有元素。

（3）remove 和removeAll 的实例代码：

public static void deleteData(List li){
        //移除一个元素
        li.remove(0);
        li.remove(li.get(0));
            //移除一个集合
        List li2=new ArrayList();
        li2.add(li.get(0));
        li2.add(li.get(1));
        li2.add(li.get(2));

        li.removeAll(li2);
}

（4）关于ArrayList  方法引用代码

package com.j1702.list;
import java.util.*;

public class TestList {
    public static void main(String[] args) {
        /*
         * 定义一个 List 集合对象， 用于存放5个学生的信息数据
         */
       List li= new ArrayList();

       addStudent(li);
       changeData(li);
      printList(li);

      //deleteData(li);
//      printList1(li);
//      printList2(li);
//      printList3(li);

    }

    //修改list数据
    public static void changeData(List li){
        Coure crs= new Coure(12,"11年级语文");
        Student stu = new Student (12,"王小花",crs);
        li.set(1, stu);
    }
    //删除list 数据
    public static void deleteData(List li){
        //移除一个元素
        li.remove(0);
        li.remove(li.get(0));
            //移除一个集合
        List li2=new ArrayList();
        li2.add(li.get(0));
        li2.add(li.get(1));
        li2.add(li.get(2));

        li.removeAll(li2);
        //如果新建一个 具有 相同属性的student 对象 ，能够传入移除码？
        /**
         * 学生id:11,学生姓名：张全蛋，学生课程：11年级语文
         */
        Coure  crs =new Coure (11,"11年级语文");
        Student stu= new Student (11,"张全蛋",crs);

        li.remove(stu);//删除不掉
    }

     //遍历输出list
      public static void  printList(List li){
           System.out.println("================================");
           System.out.println("我是通过for && get 循环遍历的");
           for (int i=0;i<li.size();i++){
               Student item=(Student )li.get(i);
               System.out.println("学生id:"+item.getId()+",学生姓名:"+item.getName()+",学生课程："
               +item.getCoure().getName());
           }
       }

       public static void  printList1(List li){
           System.out.println("================================");
           System.out.println("我是通过for && toArray 循环遍历的");
           for (int i=0;i<li.size();i++){
               Student item=(Student )li.toArray()[i];
               System.out.println("学生id:"+item.getId()+",学生姓名:"+item.getName()+",学生课程："
               +item.getCoure().getName());
           }
       }
       public static void  printList2(List li){
           System.out.println("================================");
           System.out.println("我是通过for each 循环遍历的");
           for (Object obj: li){
               Student item=(Student ) obj;
               System.out.println("学生id:"+item.getId()+",学生姓名:"+item.getName()+",学生课程："
               +item.getCoure().getName());
           }
       }

       public static void  printList3(List li){
           System.out.println("================================");
           System.out.println("我是通过 iterator 循环遍历的");
           Iterator <Object> it=li.iterator();
           while(it.hasNext()){
               Student item=(Student )it.next() ;
               System.out.println("学生id:"+item.getId()+",学生姓名:"+item.getName()+",学生课程："
               +item.getCoure().getName());
           }
       }

     //象list 中添加5条数据
    public   static void addStudent ( List li){
        for (int i=0;i<5;i++){
            Coure crs=new Coure(i+1,i+"年级语文");
            Student stu = new Student (i+1,"小张"+i,crs);
            //一条一条的添加
            li.add(stu);
        }
        List li2=new ArrayList();
        for (int i=0;i<5;i++){
            Coure crs=new Coure(i+6,i+"年级语文");
            Student stu = new Student (i+6,"小张"+i,crs);
            li2.add(stu);

        }
        //望集合中添加另一个集合的数据
        li.addAll(li2);
        //向指定的位置添加一条数据
        Coure crs= new Coure(11,"11年纪的语文");
        Student stu= new Student(11,"张全蛋",crs);
        li.add(5,stu);
        //如果在末尾位置添加一个字符串会出现什么问题？
        //li.add("我是字符串，我想添加到li里面");
        //如果在20的位置添加一个数据会出现什么问题？
        //li.add(20,stu);
        //如果在-1的位置添加一个数据会出现什么问题？
        //li.add(-1,stu);
    }

    }

// Student 类
package com.j1702.list;

public class Student {
    private  Integer id;//学生id
    private String name;//学生姓名
    private Coure coure;//学生课程
      Student(Integer id,String name,Coure coure){//有参构造方法
          this.id=id;
          this.name=name;
          this.coure=coure;
      }

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Coure getCoure() {
        return coure;
    }
    public void setCoure(Coure coure) {
        this.coure = coure;
    }

}

// Coure 课程类
package com.j1702.list;

public class Coure {
    private  Integer id;//课程id
    private String name;//课程名称

    public Coure (Integer id,String name){//有参构造方法
        this.id=id;
        this.name=name;
    }
    //getter &&  setter
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override//自动生成方法 右键 ->source    -> hashCode() && equals()
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Coure other = (Coure) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

6. 集合中的泛型：

（1）集合中的元素，可以是任意类型的对象（对象的引用）

如果把某个对象放入集合，则会忽略他的类型。而把他当做Object 处理

（2）泛型则是规定了某个集合只可以存放特定类型的对象

a.会在编译期间进行类型检查

b.可以直接按指定类型获取集合元素。

7.泛型集合中可以放入泛型子类对象实例

（1）泛型集合中的限定类型不能使用基本数据类型。

（2）可以通过使用包装类限定允许存入的基本数据类型。

例如：

List<int> li=new ArrayList<int>();//不可以使用基础类型（类型转换错误）

List<Integer> li=new ArrayList<Integer>();//会自动把int 转换为integer 包装类型

8.set 接口
8.1 Set 接口及其实现类——HashSet

(1)Set 是元素无序（放进去的顺序和输出的顺序不一样）并且不可以重复的集合。

set 中多次添加同一对象，只会保留一个。set 中可以添加null,但是也只能又一个null。

（2）HashSet——哈希集，是Set 的一个重要实现类。

（3）set 代码实例：

package com.j1702.set;
import java.util.*;

import com.j1702.list.Coure;

public class TestSet {

public static void main(String[] args) {
Set<Integer> set2=new HashSet();
set2.add(1);
set2.add(89);
set2.add(23);
set2.add(102);
set2.add(46);
set2.add(21);
set2.add(9);
set2.add(64);
set2.add(null);
set2.add(null);
System.out.println("set 接口 无序不能重复"+"==================");
for( Integer integer: set2){
System.out.println(integer);
}

List<Integer> li2=new ArrayList();
li2.add(1);
li2.add(89);
li2.add(23);
li2.add(102);
li2.add(46);
li2.add(21);
li2.add(9);
li2.add(64);
li2.add(null);
li2.add(null);
System.out.println("List 接口 有序（放入顺序） 可以重复"+"==================");
for( Integer integer: set2){
System.out.println(integer);
}

//1 创建了一个 set 实例对象
Set<Integer> set=new HashSet();
//    2.添加数据
set.add(1);
set.add(4);
set.add(3);
set.add(2);
set.add(5);
//3.输出
for(Integer integer : set){
System.out.println(integer);
}
testConttains();
}

public static void testConttains(){
Set<Coure> set_cr= new HashSet<Coure>();
//创建元素对象
Coure cr1=new Coure (1,"语文");
Coure cr2=new Coure (3,"数学");
Coure cr3=new Coure (2,"外语");
Coure cr4=new Coure (4,"综合");
//添加set
set_cr.add(cr1);
set_cr.add(cr2);
set_cr.add(cr3);
set_cr.add(cr4);
//测试 set 中的contains 方法

// Coure 类中必须要有hashcode（）&& equals()方法 判断才为true，否则为false
Coure cr=new Coure (4,"综合");
if(set_cr.contains(cr)){
System.out.println("list 中包含综合课");
}else{
System.out.println("list 中不包含综合课");
}

}

}

// Coure 课程类
package com.j1702.set;
import java.util.*;

import com.j1702.list.Coure;

public class TestSet {

public static void main(String[] args) {
Set<Integer> set2=new HashSet();
set2.add(1);
set2.add(89);
set2.add(23);
set2.add(102);
set2.add(46);
set2.add(21);
set2.add(9);
set2.add(64);
set2.add(null);
set2.add(null);
System.out.println("set 接口 无序不能重复"+"==================");
for( Integer integer: set2){
System.out.println(integer);
}

List<Integer> li2=new ArrayList();
li2.add(1);
li2.add(89);
li2.add(23);
li2.add(102);
li2.add(46);
li2.add(21);
li2.add(9);
li2.add(64);
li2.add(null);
li2.add(null);
System.out.println("List 接口 有序（放入顺序） 可以重复"+"==================");
for( Integer integer: set2){
System.out.println(integer);
}

//1 创建了一个 set 实例对象
Set<Integer> set=new HashSet();
//    2.添加数据
set.add(1);
set.add(4);
set.add(3);
set.add(2);
set.add(5);
//3.输出
for(Integer integer : set){
System.out.println(integer);
}
testConttains();
}

public static void testConttains(){
Set<Coure> set_cr= new HashSet<Coure>();
//创建元素对象
Coure cr1=new Coure (1,"语文");
Coure cr2=new Coure (3,"数学");
Coure cr3=new Coure (2,"外语");
Coure cr4=new Coure (4,"综合");
//添加set
set_cr.add(cr1);
set_cr.add(cr2);
set_cr.add(cr3);
set_cr.add(cr4);
//测试 set 中的contains 方法

// Coure 类中必须要有hashcode（）&& equals()方法 判断才为true，否则为false
Coure cr=new Coure (4,"综合");
if(set_cr.contains(cr)){
System.out.println("list 中包含综合课");
}else{
System.out.println("list 中不包含综合课");
}

}

}

（4） set 和list 的区别

* 1.set 无序（放进去的顺序和输出的顺序不一样），
* 2.list 有序（放进去的顺序和输出的顺序一样）
* 3.set 元素不可以重复，list 可以重复
9. Map 接口

9.1 map 接口

（1）map 提供了一种映射关系，其中的元素是以键值对（key-value）的形式存存储的，能够实现根据key快速查找value。

（2）map 中的键值对以Entry（条目）类型的对象实例形式存在

（3）键（key 值）不可重复，value值可以重复。

（4）每个键最多只能映射到一个值。

9.2 HashMap 类

（1）HashMap 是Map的一个重要实现类，也是最常用的，基于哈希表实现。

（2）HashMap中的Entry 对象是无序排列的

（3） key 值和value 值都可以为null,但是一个HashMap只能有一个key值为null 的映射（key值不可以重复）

9.3HashMap中的增删该查与遍历

package com.j1702.map;

import java.util.*;

import java .util.Map;

import java .util.Map.Entry;

import java.util.Set;

import com.j1702.list.Coure;

public class TestMap {

public static void main(String[] args) {

// TODO Auto-generated method stub

Map <String,String> map=new HashMap<>();

map.put("name", "张三");

map.put("age", "22");

map.put("weight", "40");

map.put("dgree", "本科");

map.put("address", "成都煤炭");

//如何输出map 中的元素？

System.out.println("姓名："+map.get("name")+"年龄"+map.get("age")+"体重"+map.get("weight")

+"学历："+map.get("dgree")+",地址："+map.get("address"));

//如何通过遍历输出 map 中的值

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

Set <String> keys =map.keySet();

for(String string : keys){

System.out.println(string+":"+map.get(string)+",");

}

//entry 实例遍历

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

Set<Map.Entry<String, String> > entrys=map.entrySet();

for(Entry<String,String>entry : entrys){

System.out.println(entry.getKey()+":"+entry.getValue()+",");

}

testContains(map);

}

//测试 contains

public static void testContains(Map <String,String> map){

System.out.println("map 中包含 name 这个 key "+map.containsKey("name"));

Map <String,String> map2=new HashMap<>();

System.out.println("map 中 包含 张三 这个值"+map.containsValue("张三"));

System.out.println("请输入名字：");

Scanner scan = new Scanner (System.in);

String str=scan.next();

System.out.println("map 中的包含 张三这个值"+map.containsValue(str));

}

}

9.3我们将这 Object的这两个方法覆盖，以正确比较 Map 对象的等价性。

equals(Object o)	比较指定对象与此 Map的等价性
hashCode()	返回此 Map的哈希码

9.3.1上面两种方法的重写代码如下：

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((id == null) ? 0 : id.hashCode());

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override//自动生成方法 右键 ->source    -> hashCode() && equals()

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Coure other = (Coure) obj;

if (id == null) {

if (other.id != null)

return false;

} else if (!id.equals(other.id))

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

equals 和 hashcode ()方法在eclipse 中的快捷生成方式为

9.4 hashmap 的常用方法

clear()	从 Map中删除所有映射
remove(Object key)	从 Map中删除键和关联的值
put(Object key, Object value)	将指定值与指定键相关联
clear()	从 Map中删除所有映射
putAll(Map t)	将指定 Map中的所有映射复制到此 map

9.5代码实例

 1 import java.util.HashSet;
 2 import java.util.Set;
 3
 4 /**
 5  * 学生类
 6  * @author lenovo
 7  *
 8  */
 9 public class Student {
10
11     public String id;
12
13     public String name;
14
15     public Set<KeCheng> kecheng;
16
17     public Student(String id,String name){
18         this.id = id;
19         this.name = name;
20         this.kecheng = new HashSet<KeCheng>();
21     }
22
23 }

然后再创建一个MapTest的测试类，演示Map的使用方法，并且创建一个演示put()方法和keySet()方法的成员方法

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.Scanner;
 4 import java.util.Set;
 5
 6 public class MapTest {
 7
 8     //创建一个Map属性用来承装学生对象
 9     public Map<String,Student> student;
10
11     /*
12      * 在构造器中初始化学生属性
13      */
14     public MapTest(){
15         this.student = new HashMap<String,Student>();
16     }
17
18     /*
19      * 添加方法：输入学生ID，判断是否被占用，
20      * 如果未被占用，则输入姓名，创建新学生对象，添加到student中
21      */
22     public void testPut(){
23         //创建一个Scanner对象，输入学生ID
24         Scanner sc = new Scanner(System.in);
25         int i = 0;
26         while(i<3){
27             System.out.println("请输入学生ID：");
28             String stuID = sc.next();
29             Student stu = student.get(stuID);
30             if(stu == null){
31                 System.out.println("请输入学生姓名：");
32                 String stuName = sc.next();
33                 Student newStudent = new Student(stuID,stuName);
34                 student.put(stuID, newStudent);
35                 System.out.println("成功添加学生："+student.get(stuID).name);
36                 i++;
37             }else{
38                 System.out.println("该学生ID已被占用！");
39                 continue;
40             }
41
42         }
43     }
44
45     /*
46      * 测试Map的keySet方法
47      */
48     public void testKeySet(){
49         //通过keySet方法，返回Map中所有“键”的Set集合
50         Set<String> keySet = student.keySet();
51         //取得student的容量
52         System.out.println("总共有"+student.size()+"个学生；");
53         //遍历keySet，取得每一个键，再调用get方法取得每个键对应的value
54         for (String stuID : keySet) {
55             Student stu = student.get(stuID);
56             if(stu != null){
57                 System.out.println("学生："+stu.name);
58             }
59         }
60     }
61
62     public static void main(String[] args) {
63
64         MapTest mt = new MapTest();
65         mt.testPut();
66         mt.testKeySet();
67     }
68
69 }

运行main方法后的结果如下：

请输入学生ID：
1
请输入学生姓名：
Tom
成功添加学生：Tom
请输入学生ID：
2
请输入学生姓名：
Jack
成功添加学生：Jack
请输入学生ID：
3
请输入学生姓名：
Lily
成功添加学生：Lily
总共有3个学生；
学生：Tom
学生：Jack
学生：Lily

使用Map中的remove()方法删除Map中的映射

 1 /*
 2      * 删除Map中的映射
 3      */
 4     public void testRemove(){
 5         Scanner sc = new Scanner(System.in);
 6         while(true){
 7             System.out.println("请输入要删除的学生ID：");
 8             String stuID = sc.next();
 9             //判断输入的ID是否存在对应的学生对象
10             Student stu = student.get(stuID);
11             if(stu == null){
12                 System.out.println("输入的学生ID不存在！");
13                 continue;
14             }
15             student.remove(stuID);
16             System.out.println("成功删除学生"+stu.name);
17             break;
18         }
19         testEntrySet();
20     }

使用entrySet()方法遍历Map

 1     /*
 2      * 通过entrySet来遍历Map
 3      */
 4     public void testEntrySet(){
 5         //通过entrySet返回Map中所有的键值对
 6         Set<Entry<String,Student>> entrySet = student.entrySet();
 7         for(Entry<String,Student> entry:entrySet){
 8             System.out.println("取得键："+entry.getKey());
 9             System.out.println("对应的值为："+entry.getValue().name);
10         }
11     }

使用put()方法来修改Map中已存在的映射

 1 /*
 2      * 使用put方法修改Map中已有的映射
 3      */
 4     public void testModify(){
 5         System.out.println("请输入要修改的学生ID：");
 6         Scanner sc = new Scanner(System.in);
 7         while(true){
 8             String id = sc.next();
 9             Student stu = student.get(id);
10             if(stu == null){
11                 System.out.println("ID不存在！");
12                 continue;
13             }
14             System.out.println("当前学生是："+stu.name);
15             System.out.println("请输入新的学生：");
16             String name = sc.next();
17             Student newStu = new Student(id,name);
18             student.put(id, newStu);
19             System.out.println("修改成功！");
20             break;
21         }
22     }

使用Map中的containsKey()和containsValue()方法来判断Map中是否存在键或值

 1 /*
 2      * 测试Map中是否存在某个key值或value值
 3      */
 4     public void testContainsKey(){
 5         System.out.println("请输入学生ID：");
 6         Scanner sc = new Scanner(System.in);
 7         String stuID = sc.next();
 8         //用containsKey()方法来判断是否存在某个key值
 9         System.out.println("输入的ID为："+stuID+",在学生列表中是否存在："+student.containsKey(stuID));
10         if(student.containsKey(stuID)){
11             System.out.println("学生的姓名为："+student.get(stuID).name);
12         }
13
14         System.out.println("请输入学生姓名：");
15         String name = sc.next();
16         //用containsValue()方法来判断是否存在某个value值
17         if(student.containsValue(new Student(null,name))){
18             System.out.println("存在学生"+name);
19         }else{
20             System.out.println("学生不存在");
21         }
22     }

使用containsKey()和containsValue()方法判断是，先在学生类里重写equals()和hashCode()方法，如果只判断值的话，equals方法里只重写和值相关的内容。

10.collection 排序

package com.j1702.sort;

public class Student implements Comparable<Student> {

private Integer id;

private String name;

private Integer age;

public Student(Integer id, String name, Integer age) {

this.id = id;

this.name = name;

this.age = age;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

//根据id 排序

@Override

public int compareTo(Student o) {

if(this.id > o.id){

return 1;

} else if(this.id<o.id){

return -1;

}else{

return 0;

}

}

//根据汉子子hashmap中的顺序排序

//@Override

// public int compareTo(Student o) {

// if (this.name.compareTo(o.name)>0) {

// return 1;

// } else if (this.name.compareTo(o.name)<0) {

// return -1;

// } else {

// return 0;

//

// }

// }

}

package com.j1702.sort;

import java.util.*;

public class Student_sort {

public static void main(String[] args) {

Student stu1 = new Student(1001, "张三", 25);

Student stu2 = new Student(1004, "李四", 26);

Student stu3 = new Student(1007, "王五", 20);

Student stu4 = new Student(1002, "小红", 18);

Student stu5 = new Student(1005, "旺财", 17);

List<Student> li = new ArrayList<Student>();

li.add(stu1);

li.add(stu2);

li.add(stu3);

li.add(stu4);

li.add(stu5);

Collections.sort(li);

for(Student s:li){

System.out.println(s.getName() + "   " + s.getAge() + "     " + s.getId() );

}

}

}

注意；根据name字段排名时，中文 的顺序不是按照字母来排序的，他是通过汉字在hash码的大小来排序的。如果要实现中文根据拼音来排序，下载中文架包。

com.ibm.icu_3.8.jar

11.comparable  和comparator 的区别

11.1Comparable 简介

Comparable 是排序接口。

若一个类实现了Comparable接口，就意味着“该类支持排序”。  即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。

此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。

11.2Comparable 定义

Comparable 接口仅仅只包括一个函数，它的定义如下：

package java.lang;
import java.util.*;

public interface Comparable<T> {
    public int compareTo(T o);
}

说明：
假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

11.3Comparator 简介

Comparator 是比较器接口。

我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。

也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序。

11.4Comparator 定义

Comparator 接口仅仅只包括两个个函数，它的定义如下：

package java.util;

public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);
}

说明：
(01) 若一个类要实现Comparator接口：它一定要实现compareTo(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。

为什么可以不实现 equals(Object obj) 函数呢？ 因为任何类，默认都是已经实现了equals(Object obj)的。 Java中的一切类都是继承于java.lang.Object，在Object.java中实现了equals(Object obj)函数；所以，其它所有的类也相当于都实现了该函数。

(02) int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。

11.5 Comparator 与 Comparable 相同点

• Comparable & Comparator 都是用来实现集合中元素的比较、排序的；

• Comparable & Comparator 均为 Java 接口，Comparable 位于包 java.lang 下，而 Comparator 位于包 java.util 下；

• 自定义类实现二者中的一个，便可进行比较大小。

---

11.6.Comparator 与 Comparable 不同点

• Comparable 一般定义在类的内部，而Comparator 一般定义在类的外部；

• 实现 Comparable 接口需要重写其 compareTo 方法，而实现 Comparator 接口需要重写其 compare 方法

11.7  代码实例

（1）Comparable

package test;  

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;  

public class test {
    public static void main(String[] args) {
        List<UserInfo> list = new ArrayList<UserInfo>();
        list.add(new UserInfo(1,21,"name1"));
        list.add(new UserInfo(2,27,"name1"));
        list.add(new UserInfo(3,15,"name1"));
        list.add(new UserInfo(5,24,"name1"));
        list.add(new UserInfo(4,24,"name1"));
        //对该类排序
        Collections.sort(list);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}  

class UserInfo implements Comparable<UserInfo>{
    private int userid;
    private int age;
    private String name;
    public UserInfo(int userid, int age, String name) {
        this.userid = userid;
        this.age = age;
        this.name = name;
    }
    public int getUserid() {
        return userid;
    }
    public void setUserid(int userid) {
        this.userid = userid;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString(){
        return this.userid+","+this.age+","+this.name;
    }
    @Override
    public int compareTo(UserInfo o) {
        //如果年龄相同，则比较userid，也可以直接  return this.age-o.age;
        if(this.age-o.age==0){
            return this.userid-o.userid;
        }else{
            return this.age-o.age;
        }
    }  

}  

（2）comparator

package test;  

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;  

public class test1 {
    public static void main(String[] args) {
        List<UserInfo> list = new ArrayList<UserInfo>();
        list.add(new UserInfo(1,21,"name1"));
        list.add(new UserInfo(2,27,"name2"));
        list.add(new UserInfo(3,15,"name3"));
        list.add(new UserInfo(5,24,"name4"));
        list.add(new UserInfo(4,24,"name5"));
        //new一个比较器
        MyComparator comparator = new MyComparator();
        //对list排序
        Collections.sort(list,comparator);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}
class MyComparator implements Comparator<UserInfo>{
    @Override
    public int compare(UserInfo o1,UserInfo o2) {  

        if(o1.getAge()-o2.getAge()==0){
            return o1.getUserid()-o2.getUserid();
        }else{
            return o1.getAge()-o2.getAge();
        }
    }
}
class UserInfo{
    private int userid;
    private int age;
    private String name;
    public UserInfo(int userid, int age, String name) {
        this.userid = userid;
        this.age = age;
        this.name = name;
    }
    public int getUserid() {
        return userid;
    }
    public void setUserid(int userid) {
        this.userid = userid;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString(){
        return this.userid+","+this.age+","+this.name;
    }
}  

（3总结；

• 使用 Comparable 较为简单, 只要实现 Comparable 接口的对象就直接成为一个可以比较的对象，但是 需要修改源代码，而且由于这样做会导致代码耦合性比较高，会严重影响到代码的可扩展性；

• 用 Comparator 的好处是 不需要修改源代码，不会使代码发生强耦合 , 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时，把比较器和对象一起传递过去就可以比大小 ;

所以，就代码可扩展性角度而言，使用实现 Comparator 接口的方式去实现容器内元素的排序会更好一些。