\ 经验分享
一、javase基础知识总结（自己看）
1、遇到空指针异常时或 JVM自动捕获的异常，可以不用try-catch，还有把异常抛给上一级来处理的话必须要使用throws来抛出异常。否则没有抛出也不会被捕获到。下面例子：
package com.leeue.
public class TestChain {
public static void main(String[] args){
TestChain tc = new TestChain();
tc.test1();
public void test1() throws NullPointerException{
//空指针异常时JVM自动捕获的异常，所以可以不用try-catch，还有把异常抛给上一级来处理的话必须要使用throws来抛出异常
throw new NullPointerException("test1 中空指针异常");
public void test2(){
2、自定义异常，继承Exception或其他子类例子
package com.leeue.
* 功能: 自定义异常
* @author:leeue
* @Version:
* @Date 日 下午3:49:46
public class DrunkException extends Exception {
public DrunkException(){
super();//调用父类的无参构造函数
public DrunkException(String message){
super(message);//调用父类带String参数的构造函数
public DrunkException(String message,Throwable cause){
super(message,cause);//调用父类含有cause参数的构造函数
//现在所有Throwable的子类子构造器中都可以接受一个cause对象作为参数，
//这个cause就异常原由，代表着原始异常，即使在当前位置创建并抛出行的异常，也可以通过这个cause追踪到异常最初发生的位置。
public DrunkException(Throwable cause){
super(cause);
3、异常链的具体分析
只有Error，Exception，RuntimeException提供了带cause参数的构造器，其他的所有异常类只能通过initCause()来设置cause。
所有Throwable的子类构造器中都可以接受一个cause对象作为参数。cause是异常原由，代表着原始异常。既可以在当前位置创建并抛出行的异常，也可以通过cause追踪到异常最初发生的位置。
异常链是一种面向对象编程技术，指将捕获的异常包装进一个新的异常中并重新抛出的异常处理方式。原异常被保存为新异常的一个属性（比如cause）。这个想法是指一个方法应该抛出定义在相同的抽象层次上的异常，但不会丢弃更低层次的信息。
把捕获的异常包装成新的异常，在新异常里添加原始的异常，并将新异常抛出，它们就像是链式反应一样，一个导致（cause）另一个
这个想法是指一个方法应该抛出定义在相同的抽象层次上的异常，（将所有捕获到的异常包装为新的异常类，即定义在相同的抽象层次上抛出）但不会丢弃更低层次的信息。
实现异常链功能的两种基本写法：
public class chainTest {
* @param args
* Test1抛出喝大了异常
* Test2调用test1捕获了喝大了异常，并且包装成运行时异常，继续抛出
* main方法中调用test2尝试捕获test2方法抛出的异常
public static void main(String[] args) {
// TODO Auto-generated method stub
chainTest ct=new chainTest();
ct.Test2();}
catch(Exception e){
e.printStackTrace();
}public void Test1()throws DrunkException{
throw new DrunkException("喝车别开酒");
public void Test2(){
}catch( DrunkException e){
RuntimeException rte=new RuntimeException(e);
//rte.initCause(e);//第一种实现就是调用initCause(e)在新异常添加原始的异常，第二种实现就是直接传递异常
e.printStackTrace();
4、Java中的equals()和==用法
equals是java.lang.Object类的方法。有两种用法说明
1、对于字符串来说，使用“==” 和equals()方法比较字符串的时候，其比较方法不同：
“==”比较两个字符串在内存中的首地址。
equals()比较字符串所包含的内容是否相同。
总结:equals()方法对于字符串来说是比较内容的，对于其基本类型来说是比较其对象指向的内存地址是否相同
== 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。
package com.leeue.
*总结== 和equals的用法
public class Test {
public static void main(String[] args){
String s1 = "123";
String s2 = "123";
String s0 = "12";
String s3 = s0 + "3";//因为s1是变量，s3在运行时才知道具体值，所以s3和s4是不同的对象
int a = -129;
int b = -129;//
-128&=Integer&= 127
这之间不会重新分配对象，有一个常量池。数值在这个之间都会a==b 为true
System.out.println("内存地址和内容都相等吗"+(s1 == s2));//true
System.out.println("内存地址和内容都相等吗"+(s1 == s3));// false
System.out.println("内容相等吗"+s1.equals(s2));//true
System.out.println(""+(a == b));//true
第二个示例代码
public class HelloWorld {
public static void main(String[] args) {
String s1 = "imooc";
String s2 = "imooc";
//定义字符串s3，保存“I love”和s1拼接后的内容
String s3 = "I love" + s1;
// 比较字符串s1和s2
// imooc为常量字符串，多次出现时会被编译器优化，只创建一个对象
System.out.println("s1和s2内存地址相同吗？" + (s1 == s2));//true
//比较字符串s1和s3
System.out.println("s1和s3内存地址相同吗？" + (s1==s3) );//false
String s4 = "I love " + s1;
//比较字符串s4和s3
// s1是变量，s4在运行时才知道具体值，所以s3和s4是不同的对象
System.out.println("s3和s4内存地址相同吗？" + (s4 == s3));//false
5、String类常用的方法
int length() 返回当前字符串的长度
int indexOf(int ch) 查找ch字符在该字符串中第一次出现的位置
int indexOf(String str) 查找str子字符串在该字符串中第一次出现的位置
int lastIndexOf(int ch) 查找ch字符在该字符串中最后一次出现的位置
int lastIndexOf(String str) 查找str子字符串在该字符串中最后一次出现的位置
String substring(int beginIndex) 获取从beginIndex位置开始到结束的子字符串
String substring(int beginIndex, int endIndex) 获取从beginIndex位置开始到endIndex位置的子字符串
String trim() 返回去除了前后空格的字符串
boolean equals(Object obj) 将该字符串与制定对象比较，返回true或false
String toLowerCase() 将字符串转换为小写
String toUpperCase() 将字符串转换为大写
char charAt(int index) 获取字符串中指定位置的字符
String[] split(String regex, int limit) 将字符串分割为子字符串，返回字符串数组
byte[] getBytes() 将该字符串转换为byte数组
使用 substring(beginIndex , endIndex) 进行字符串截取时，
包括 beginIndex 位置的字符，不包括 endIndex 位置的字符
6、java中的length length() 和size();
java中的length属性只是针对数组说的。
java中的length()是针对字符串说的。
java中的size()方法针对泛型集合说的。查看集合中有几个元素。
7、java中存储字符串的有String、StringBuffer、StringBuilder 的区别
String 类:具有是不可变性，多个字符串进行拼接以后产生一个新的临时变量并指向的新的对象或新的地址。
StringBuffer类:是线程安全的功能跟StringBuilder差不多。
StringBuilder类:是线程不安全，所以性能较好。如果创建一些内容可变的字符串，优先考虑StringBuilder类。
StringBuilder类常用方法:
str.append("abc");//追加字符串abc
str.toString();//转换为String对象
str.insert(num,"abc");//在第num个位置插入abc
str.length();//获取字符串长度
package com.leeue.string.
* 功能:StringBuilder的例子
* @author:leeue
* @Version:
* @Date 日 下午5:02:32
public class StringBuilderDemo {
public static void main(String[] args){
//创建一个空的字符串StringBuilder对象
StringBuilder sb = new StringBuilder("我是StringBuilder创建的");
//在StringBuilder中追加字符串
sb.append("HelloWorldzz");
sb.insert(0,"哈哈");
//从后往前每三隔三位插入逗号
for(int i = sb.length()-3; i&0; i = i-3){
//插入用insert();
sb.insert(i,",");
//输入对象
System.out.println(sb);
8、java中的包装类
Integer包装类常用方法
Integer包装类的构造函数
包装类主要提供了两大类方法
1、将本类型和其他类型进行互相转换的方法。
2、将字符串和本类型及包装类互相转换的方法。
package com.leeue.integer.
* 功能: 关于包装类方法的demo
* @author:李月
* @Version:
* @Date 日 下午5:37:59
public class IntegerDemo {
public static void main(String[] args){
//定义int基本类型
int score1 = 86;
//创建Integer包装类，表示变量score1的值
Integer score2 = new Integer(score1);//手动装箱
Integer score2 = score1;//自动装箱
//将Integer包装类转换成double类型
double score3 = score2.doubleValue();
//将Integer包装类转换成float类型
float score4 = score2.floatValue();
//将Integer包装类
int score5 = score2.intValue();//手动拆箱
System.out.println("Integer包装类：" + score2);
System.out.println("double类型：" + score3);
System.out.println("float类型：" + score4);
System.out.println("int类型：" + score5);
9、字符串和基本类型的相互转换
基本类型转字符串有三种方法
1、包装类的toString()方法；
2、String类中valueOf()方法
3、用一个空字符串加上基本类型，得到的就是基本数据类型对应的字符串
int c = 10;
String str1 = Integer.toString(c);
String str2 = String.valueOf(c);
String str3 = c + " ";
字符串转基本类型有两种方法
1、包装类的parseXxx静态方法
2、调用包装类的valueOf()方法
ps：转换为基本数据类型的时候包装类会自动拆箱
String str = "8";
int a = Integer.parseInt(str);
int b = Integer.valueOf(str);
10、java中的与时间有关的类 Date 、SimpleDateFormat（时间格式化的类）、Calendar类;
使用SimpleDateFormat 可以对日期时间进行格式化（由于Date默认输出的时间格式不友好需要转码），
可以使用SimpleDateFormat 将日期转为指定个是的日期文本，也可以将文本转化成日期。
1、使用SimpleDateFormat里面的format()方法将日期转换为指定的格式文本
package com.leeue.date.
import java.util.D
import java.text.SimpleDateF
* 功能: 日期的应用
* @author:leeue
* @Version:
* @Date 日 下午10:42:27
public class DateDemo {
public static void main(String[] args){
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日
HH时mm分ss秒");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date now = new Date();
String str1 = sdf1.format(now);
String str2 = sdf2.format(now);
String str3 = sdf3.format(now);
System.out.println("当前格式化的时间是:"+str1);
System.out.println("当前格式化的时间是:"+str2);
System.out.println("当前格式化日期是:"+str3);
当前格式化的时间是:日
18时46分24秒
当前格式化的时间是: 18-46-24
当前格式化日期是: 18:46:24
2、使用SimpleDateFormat里面的parse()方法将字符串转化成日期Date
//Date now = new Date();//这个是获取当前时间
String d = " 21:05:22"
SimpleDateFormat sdf
new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
Date date = sdf.parse(s);
使用java中的Date和SimpleDateFormat 需要注意：
1、调用SimpleDateFormat对象的parse()方法时可能会出现转换异常，所以要进行异常处理 ParseException
2、使用Date需要导入java.util.Date类，使用SimpleDateFormat需要导入java.text包。
11、使用Calendar类进行时间和日期的处理
## Calendar类基本使用方法
java.util.C类
1、通过调用getInstance()静态方法来获取一个Calendar对象
Calendar c = Calendar.getInstance();
2、通过调用get()方法来获取日期时间信息
int month = c.getMonth(Calendar.MONTH)+1
//0表示1月份，所以要+1
3、Calendar对象转化成Date对象调用getTime()方法
Date d = c.getTime(); //对象转化成Date对象
4、通过调用getTimeInMillis()方法获取Calendar的时间值。
long time = c.getTimeInMillis();
//获取当前的毫秒值
12、使用Math类操作数据
Math类在java.lang保重，Math类中包含用于执行基本数学运算的方法且所有方法都是[静态方法]，
所以使用该类的中的方法可以直接
类名.方法名 如：Math.round();
××常用方法：
· Math.abs()：取绝对值
· Math.random()：随机返回[0,1）之间的一个double值，可*100 再 四舍五入 得到[0,100）的随机整数
· Math.pow(a,b)：返回a的b次幂的值
· Math.rand()：对浮点数进行四舍五入
· Math.ceil()：返回大于参数的最小整数（double类型）
· Math.floor()：返回小于参数的最大整数（double类型）
· Math.max(a,b)：返回a,b中最大的数
· Math.min(a,b)：返回a,b最小值
13、java集合框架简介
java集合框架结构:是由Collection和Map两个根接口
Collection接口：内部存储的是一个独立的对象，包含有
1、list接口：序列，存储元素排列有序可重复，实现类有ArrayList，数组序列，LinkedList，链表
2、Queue接口：队列，存储元素排列有序可重复，实现类有LinkedList链表
3、Set接口：集，存储元素无序且不可重复，实现类：HashSet。哈希集
Map接口：内部以&key,value&两个对象为一个映射去存储数据，这个映射就是Entry类*（Map的内部类）
实现类有:HashMap: 哈希表，可以存空value
HashTable:
14、Collection接口中List接口简介
Collection接口是List、Set、Queue接口的父接口
Collection接口定义类可以用于操作List、Set 和Queue的方法- --- 增删查改
List接口及实现类ArrayList
List：是一个有序可以重复的集合，被称为序列，可以精确的控制每个元素的插入位置或删除某个位置的元素。
注意：List是接口不能直接new，而是通过ArrayList()来实例化
如：List coursesToSelect = new ArrayList&Course&();
List中常用方法：
1、添加元素到ArrayList中去调用add()方法，有两种方式
1、直接添加
如：coursesToSelect.add(cr1);
2、指定位置添加：如 coursesToSelect.add(0,cr1);
2、获取List中的元素调用get()方法，
如：Course temp = (Course)courseToselect.get(0);
注意：当一个对象被添加到集合中去的时候，它会被忽略掉类型，而都变成Object类型，取出时需要类型转换。
如果添加List中的长度大于他目前的长度courseToselect.size();则系统会出现异常，即下标越界异常。
List中添加元素第二种方式，调用 addAll();
Course[] course2 = {new Course("1",“高等数学”)，new Course("2","离散数学")};
coursesToSelect.addAll(Arrays.asList(course2));
//第二种，有位置
Course[] course3 = {new Course("1",“高等数学”)，new Course("2","离散数学")};
coursesToSelect.addAll(2，Arrays.asList(course3));
//注意Arrays.asList(数组)，是把一个数组转换成List类型
15、三种方式取出List中元素的方法
增强for循环使用的方式：
for(类型 变量名 ：需要遍历的 数组名）｛
sysout.(变量名);
第一种使用for each循环输出数组中的元素：
public void testForeachGet(){
System.out.println("使用增强for循环来遍历List");
for(Object c : coursesToSelect){//类型被忽略了，所以是Object前面有介绍
Course cr = (Course)
System.out.print("课程id："+cr.getId()+"
课程名："+cr.getName()+"
第二种使用for循环遍历
public void testForGet(){
System.out.println("使用For循环遍历List");
int size = coursesToSelect.size();
for(int i = 0; i & i++){
Course cr = (Course) coursesToSelect.get(i);
System.out.print("课程id："+cr.getId()+"
课程名："+cr.getName()+"
System.out.println();
第三种使用迭代器Iterator来遍历list
Iterator 是java.util包中
//集合通用的遍历方式
public void testIteratorGet(){
System.out.println("使用迭代器Iterator来遍历List");
Iterator it = coursesToSelect.iterator();
while(it.hasNext()){
Course cr = (Course) it.next();
System.out.print("课程id："+cr.getId()+"
课程名："+cr.getName()+"
System.out.println();
16、修改List中的元素
使用set(index,Object element) 修改元素，index：表示索引的位置 ，element表示新的对象。
* 修改List中的元素
public void testModify(){
coursesToSelect.set(4,new Course("7","毛概"));
17、删除List中的元素
(删除元素)List中有remove(index),remove(对象值)
和removeAll(Arrays.asList(对象数组名))方法来删除容器中元素的值(用法和add类似).
* 删除List中的元素
* @param args
public void testRemove(){
Course cr = (Course) coursesToSelect.get(4);
System.out.print("我是要删除的课程了--"+"课程id："+cr.getId()+"
课程名："+cr.getName()+"");
coursesToSelect.remove(cr);//第一种删除是直接找到这个对象，传递这个对象删除
coursesToSelect.remove(1);//第二种删除直接传递下标
//第三种删除多个对像 ，传入的是一个数组
Course[] courses= {(Course) coursesToSelect.get(0),(Course) coursesToSelect.get(1)};
coursesToSelect.removeAll(Arrays.asList(courses));
//Arrays.asList(数组名)。可以将数组转换成List
18、泛型的概念
泛型&&;规定List定义的容器只能存储某种类型的元素。
不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，
把它看成为Object类型，取出时需要强行转换对应的类型。
编写带有泛型的集合
List&Course& courseToS
//List&规定要放入的类型&
在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)
this.courseToSelect=new ArrayList&Course&();
//带有泛型-Course的List类型属性就创建了
泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。
运用了泛型的话，用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),
不必再用Object取 出再强转，因为已经规定容器里装的都是Course类型。
19、Set接口及其实现类 HashSet
Set:存放的元素无序，且不可以重复的集合，被称为集。，实现类是HashSet
HashSet:哈希集，是Set的一个重要的实现类
1、Set没有像List中set方法修改，因为List是有序的可以指定位置，而Set是无序的。
2、查询遍历时，Set不能用get方法来获取,因为List是有序的，而Set是无序的。
3、Set中的size()、add()、addAll()、remove()、removeAll()与List类似。
4、Set中还可以添加null
20、Map接口与其实现类HashMap
Map接口：实现类是HashMap
1、Map接口提供类一种映射关系，其中的元素是以键值对的形式来存储的，
能够实现根据key快速查找value。Key-value可以是任何对象，
2、Key是不可以重复的，Value是可以重复的。Key和Value都可以为null,不过只有一个key是null。
3、Map支持泛型，Map&K,V&；
4、每个键最多只能映射一个值
5、Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法。
6、通过调用put(key,value),remove(key),来增加或移除数据
7、HashMap中的Entry对象是无序排列的，HashMap是Map的一个重要的实现类，
也是最常用的。基于哈希表实现的。
21、遍历Map的2种方法
第一种调用keySet()方法
* 测试Map的KeySet方法
public void testKeySet(){
//通过keySet()方法返回Map中的所有集合的”键 就是key“的Set集合
Set&String& keySet = students.keySet();
System.out.println("调用keySet()方法来遍历Map");
//通过遍历keySet取得每个键，再调用get()方法取得每个键对应的value的值
for(String stuId : keySet){
Student stu = students.get(stuId);
if(stu!=null){
System.out.println("学生姓名:"+stu.getName());
第二种遍历Map调用里面的entrySet来遍历Map
* 调用entrySet来遍历Map集合
public void testEntrySet(){
System.out.println("调用entrySet()方法来遍历Map");
//通过entrySet方法返回Map中的所有的键值对
Entry也是一个泛型的
Set&Entry&String,Student&& entrySet = students.entrySet();
for(Entry&String,Student& entry: entrySet){
String id = (String) entry.getKey();
//此时的getValue()返回就是一个Student对象，因为上面已经定义了泛型了
System.out.println("学生姓名:"+entry.getValue().getName());
22、Map的增删查改
增: 调用map的put(key,value)方法添加
查：1、利用keySet()方法获得Map中的key集合，再遍历key的集合，
利用Map的get(key)方法得到key对应的value值。
2、利用entrySet()方法获取Map中的Entry对象集，然后用foreach遍历集，
再用Entry集的getKey()和getValue()方
法得到每个key值和value值。
注意：通过entrySet()可以返回Map中的所有键值对。
Set&Entry&String,Student&& entrySet = students.entrySet();
删:remove(Object key);
改:put(原有的key，新的value)；
23、List中的contains方法
List中的contains()方法的原理
List中contains()被调用时，会主动遍历List中的每个元素，并使用Object类中的equals()方法和传进来的引用
依次做比较，如果发现传进来的对象和某个元素指向一块相同的内存地址就返回
如果要实现比较传进来的对象和某个元素里面的内容是否相同，需要重写equals方法（这个重写是一个模版）
public void equals (Object obj)
if(this == obj)
// 指向同一个内存快 必然是相同的
//为什么contains(course2) 返回的是false
// 原因就在在这里 只是比较了一下 引用的值是否相同 没有进一步的比较 内存块中的值 下就是对这里进行了改写
if (obj == null)
// 如果obj为空 就直接没有戏了
if(! (obj instanceof Course))
//如果两者的不属于同一类型则 也直接没戏了
//经过以上的这么多的比较 终于可以判断二者的值是不是相同了
//首相要把objet型的obj转成 Course
Course course = (Course)
if( this.name == null )//比较内容是否想等
if(course.name == null )
if(this.name.equals(course.name))
//如果还有别的属性接着写
补充:List中的containAll();方法与上面介绍的removeAll()使用相似
24、Set中的contains()方法
在Object中定义了equals()方法还有个hashCode()方法，hashCode()方法是返回一个哈希码。
调用Set中的contains(obj)方法的时候，先是调用hasCode()返回哈希码，
如果哈希码想等的情况下再调用equals()方法,判断两个元素是否想等，
只有这两个方法返回的值都为true，才表明这个hashSet包含这个元素。
判断set中的课程是否存在(是否包含这个元素)？
使用set中的contains方法，set中调用contains（obj）方法，contains方法的实现机制：
先调用object中的hashcode方法，再调用object中的equals方法。
所以要对对象的hashcode（）方法和equals方法重写，
可以使用eclipse中的source&GENARATE hashcode（），在对象的类中，实现方法的重写。
25、Set中也有remove(),removeAll();方法等
26、获取List中中某个元素的索引位置使用。indexOf()方法与lastIndexOf()方法实现
indexOf()方法与lastIndexOf()方法实现原理：
1、遍历调用每个元素的equals()方法，如果返回true则将次元素的索引返回；
2、如果有多个相同元素，则只返回第一个元素的索引；
3、lastIndexOf()方法则从最后一个元素开始遍历；
26、Map中判断是否包含这个元素调用containsKey( key)，返回id，调用containsValue(value),返回的是value
* 测试Map中是否包含某个Key或者某个Value值
public void testContainsKeyOrValue(){
//提示输入学生ID
System.out.println("请输入查询学生ID:");
Scanner console = new Scanner(System.in);
String id = console.next();
//在Map中 用containsKey()方法来判断是否包含Key值
System.out.println("您输入的学生ID为"+id+",在学生映射表中是否存在"+students.containsKey(id));
if(students.containsKey(id)){
System.out.println("对应的学生为"+students.get(id).getName());
//提示输入姓名
System.out.println("请输入学生姓名");
String name = console.next();
//用containsValue()方法来判断是否包含Value值。
if(students.containsValue(name)){
System.out.println("对应的学生为"+students.get(id).getName());
System.out.println("没有此学生");
30、集合的排序
数组的排序使用java.util.Arrays里面的静态方法sort() 再提一遍:泛型不能用基本类型。
在集合中也有一个集合的工具类，java.util.Collections类，用来操作集合对象工具类。也是java集合框架成员
在Collections定义类一个sort()方法，用来排序
Collections.sort（）方法对元素进行排序，列表中的元素都必需实现 Comparable 接口，
否则不能使用 sort（）方法排序。如果不实现，原生的Collections.sort()只支持基本数据类型的包装类。
31、对其他对象的排序方法实现接口Compareable 是默认比较规则， 接口Comparator是临时比较规则
1、Compareable接口------默认比较规则 可比较的
1、实现该接口的类表示：这个类的实例可以比较大小，可以进行自然排序，定义了默认的比较规则
2、其实现Compareable接口需要实现compareTo()方法，返回正数1表示大，负数-1表示小，0表示想等
2、Comparator接口-----更像是比较的工具类，用于定义临时比较规则
1、实现Comparator的接口表示:这个类也是可比较的，定义的是一个临时的比较规则而不是默认的比较规则
2、实现Comparator的接口，需要实现compare()方法。
3、compareable 是默认比较规则， comparator是临时比较规则
32、基本使用规则
让没有默认比较规则的类进行比较的方法
一、让该类实现Comparable接口：
1、在该类中加上implements Comparable&类名&。
2、实现.compareTo(类名 对象名)方法，若this较大则返回正值，
若相等则返回0，若this较小则返回负值。（各种类都包含.compareTo()方法）
3、调用Collections.sort（对象名）进行排序。
public class student implements Comparable{
public int compareTo(Student o) {
//当o这个对象大于当前这个对象就会返回1，等于返回0，小于返回负数
return this.id.compareTo(o.id);
二、让该类实现Comparator接口：
1、新建一个类加上implements Comparator&类名&
2、实现.compare(类名 对象名1，类名，对象名2)方法，若this较大则返回正值，
若相等则返回0，若this较小则返回负值。
3、调用Collections.sort（对象名，实现Comparator&类名&接口的对象名）方法。
（因此要重建一个类来实现Comparator接口！！）
字符串大小比较方式：分别将每一个字符串的每一位进行比较，0-9&A-Z&a-z。
都是使用Collections.sort();来调用
package com.leeue.collection.
import java.util.C
public class StudentComparator implements Comparator&Student&｛//重新定义个比较类
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return o1.getName().compareTo(o2.getName());
Collections.sort(studentList,new StudentComparator());
若觉得本文不错，就分享一下吧！
请登录后，发表评论
评论加载中...
Copyright (C) 2018 imooc.com All Rights Reserved | 京ICP备 号-2}