本文链接：https://blog.csdn.net/Ningmengyouzhi/article/details/123258749

常用类

基本数据类型与包装类型
八种基本数据类型
整形 byte short int long
小数 float double
非数值 char boolean
八种基本数据类型对应的引用数据类型引用数据类型默认值 null
Byte(byte) Short(short) Integer(int) Long(long)
Float(float) Double(double)
Character(char) Boolean(boolean)
基本数据类型转换为包装类型：装箱
包装类型转换为基本数据类型：拆箱
java自动拆装箱【自动拆装箱机制】

本章用代码举例讲解

Integer以及Float等

Integer与int之间的关系
Integer类型的常用方法

这里有个范围易错点[-128,127]，代码有解释

package 常用类;

public class IntegerTest {
    public static void main(String[] args) {
        test01();
    }
    //Integer与int之间的关系
    public static void test01(){
        int a = 10;
        Integer b = 10;
        Integer c = 10;
        Integer d = new Integer(10);
        Integer e = new Integer(a);
        //测试比较的关系
        System.out.println(a==b);//true
        System.out.println(a==d);//true
        System.out.println(c==b);//true
        System.out.println(d==b);//false
        System.out.println(d==e);//false
        System.out.println(c.equals(d));//true
        System.out.println(c.equals(b));//true
        /*
        通过以上测试可以得到，int类型是可以和Integer类型==比较的
        两个没有new对象的Integer类型数据可以==比较
        两个Integer数据，当有一个以上new对象时，只能使用equals方法进行值比较
        注意：System.out.println(c==b);//true
            这个地方，两个没有new对象的是可以这样比较的，但一旦值得范围在[-128，127]之外，
            会自动给Integer数据new对象，这时，这个比较九是false
         */
        System.out.println(a+b);
        System.out.println(a+d);
        System.out.println(c+b);
        System.out.println(d+b);
        System.out.println(d+e);
        //以上算出来的结果都是20，所以计算上没啥区别
        //所以Integer数据也是可以当成Integer来进行计算的
    }
    //Integer类型的常用方法
    public static void test02(){
        Integer a = new Integer(10);
        //进制转换
        System.out.println(Integer.toHexString(10));
        System.out.println(Integer.toOctalString(10));
        System.out.println(Integer.toBinaryString(10));
        //数据类型转换
        int b = Integer.parseInt("123");
        String s = a.toString();
        s = String.valueOf(b);
    }
}

相对来说，用的比较多的就是Ingeter类，float、double、char、boolean就简单讲一下

package 常用类;

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) {

        test02();
    }
    public  static void  test01(){
        float f = 12.5F;//这里必须要加f或者F，否则就是double类型
        double d = 12.5;
        float f1 = new Float("12.5F");
    }

    public static  void test02(){
        Boolean b = new Boolean("true");
        Character c = new Character('a');//只能传字符
        Character c2 = 'a';
        String s = "a";
        Character c3 = s.charAt(0);//都可以
        String s1 = String.valueOf(c);
    }
}

String类

1、String类的内存分析
final修饰的类:不能被继承
2、常用方法
equals方法：equals方法是Object类中的方法，equals与==一样的，比较的俩对象的地址是否相等。但是String类重写了equals方法，除去比较地址，还比较俩字符串内容。如果地址一样直接返回true,如果地址不同，比较的是俩字符串类型，此时会比较俩字符串的内容是否一直，如果一次也会返回true。除去String类重写了equals方法，Integer，Double,等包装类型也重写了equals方法。

代码演示

package 常用类.demo02;

import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        test01();
        test02();
    }
    //常用创建方法
    public static void test01(){
        String s="中国";
        try {
            byte[] bs =  s.getBytes("GBK");
            String s1 = new String(bs,"GBK");
            System.out.println(s1);
            char[] cs = {'a','b','c'};
            String s2 = new String(cs);
            String s3 = "hello";
            String s4 = new String("hello");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
    //String类型对象创建的地址情况
    public static void test02(){
        String s1 = "hello";//池
        String s2 = new String("hello");//堆
        String s3 = "hello";//池
        System.out.println(s1.equals(s2));//true，值相等
        System.out.println(s1==s2);//false，值相等但地址不等
        System.out.println(s1==s3);//true，值和地址都相等
        /*
        s1得声明会在String常量池中寻找是否有hello这个字符串，如果没有的话就在常量池中创建一个hello字符串，并指向这个内存
        s2的声明会在堆中开辟空间，然后这块内存指向常量池中hello字符串
        s3的声明会在String常量池中寻找hello字符串，找到直接指向它
        所以
        s1和s3的地址相同，但s2的地址却和他们不一样==地址相同时才true
         */
        /*String s = new String("hello");创建了几个对象？
        这里主要还是上一个知识点，new的时候会创建几个对象呢？一个或者两个
        上面我们说到，new时，会在堆中开辟一块内存，然后这块内存会在String常量池中找需要的字符串
        如果前面用到过这个字符串，那么直接指向常量池中的字符就行了，这是就创建堆中一个对象
        如果前面没有用到这个字符串，就要在String常量池中创建该字符串，所以加上堆中开辟的，一共是创建两个对象
        。
        只要前面使用过该字符串，该字符串就会在String常量池中出现，即使这个字符串不使用了，也依然存在String常量池
         */
    }
    public static void test03(){
        String s="hello";//池中创建hello
        String s1="world";//池中创建world
        String s2="hello"+"world";//池中创建helloworld
        String s3="helloworld";//指向池中helloworld
        System.out.println(s2==s3);//true
        String s4=s+"world";//堆中开辟再指向
        System.out.println(s3==s4);//false
        //一旦出现变量，比如s4，就会自动在堆中开辟空间，然后再在String常量池中找
        String s5 = s1.intern();//返回s1池子中的内容，即直接指向池中的字符串，不用在堆中开辟空间
        System.out.println(s5=="world");//true
    }
    //常用方法
    public  static void test04(){
        //表示长度
        String s="Helloworld,ems,jerry";
        System.out.println(s.length());//方法 字符串的长度
        //大小写转换
        System.out.println(s.toLowerCase());//转换为小写得到新的字符串是更改好的内容，源字符串没变。String是不可变的
        System.out.println(s.toUpperCase());//转换为大写
        System.out.println(s);
        //检索某个字符
        int index = s.indexOf('e');//检索字符或字符串出现的位置,如果找到就返回索引位置，如果找不到就返回-1
        System.out.println(index);//检索字符串出现的位置
        index = s.indexOf('e',11);//从11索引开始找e出现的位置
        System.out.println(index);//检索字符串出现的位置
        index=s.indexOf("e");
        System.out.println(index);
        index=s.indexOf("E",10);
        System.out.println(index);
        index=s.lastIndexOf("e");//最后一次出现的索引位置
        System.out.println(index);
        String s1="heLLo";
        //忽略大小写比较
        boolean f = "hello".equalsIgnoreCase(s1);//忽略大小写比较
        System.out.println(f);
        //Helloworld,ems,jerry
        //截取字符串
        String news =   s.substring(0,10);//截取从start索引位置开始，到end结束位置，包含前面的索引，不包含后面的索引
        System.out.println(news+"-----"+s);
        news =   s.substring(11,14);//截取从start索引位置开始，到end结束位置，包含开始11的索引，不包含结束14的索引
        System.out.println(news+"-----"+s);
        //字符串拼接
        String news1 =  news.concat("  very good");//字符串的拼接，相当于+
        System.out.println(news1+"----"+news);
        System.out.println("=============/======"+s+"=============");
        //判断子字符串是否在某个位置
        System.out.println(s.contains("ems"));//是否包含某些字符串
        System.out.println(s.startsWith("Hello"));//以某些字符串开头
        System.out.println(s.endsWith("jerry"));//以某些字符串结尾s
        //判断是否为空
        s="";//s=null;不可以
        System.out.println(s.isEmpty());
        s="   hello  world  ";
        //去除空格
        news =  s.trim();//去除前后空格
        System.out.println("**"+news+"**");
        System.out.println("**"+s+"**");
        s="hello world ,hello java,hello linux";
        //替换某个字符
        news = s.replace("hello","你好");//替换
        System.out.println(news);
        System.out.println(s);
        // \s 空格    *正则规则 任意个数。 规则后面详细的去讲。
        news = s.replaceAll("\\s","**");//满足正则规则的替换
        System.out.println(news);
        //拆分字符串
        s="hello-world-java-html-jsp-servlet";
        String[] arr =  s.split("-");//拆分字符串得到一个数组
        System.out.println(Arrays.toString(arr));
        //数字组合成字符串
        String newss =  String.join(";",arr);//hello  将数组中的每个元素按照符号拼接成一个字符串
        System.out.println(newss);
        //比较
        System.out.println("abc".compareTo("aba"));
    }
}

StringBuffer与StringBuilder

StringBuffer

java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象。很多方法与String相同。作为参数传递时，方法内部可以改变值。 StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

常见方法

构造方法
StringBuffer()：初始容量为16的字符串缓冲区
StringBuffer(int size)：构造指定容量的字符串缓冲区
StringBuffer(String str)：将内容初始化为指定字符串内容
常用方法
StringBuffer append(xxx)：//提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：//删除指定位置的内容
StringBuffer replace(int start, int end, String str)：//把[start,end)位置替换为 str
StringBuffer insert(int offset, xxx)：//在指定位置插入xxx
StringBuffer reverse() ：//把当前字符序列逆转

StringBuilder

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样

String、StringBuffer、StringBuilder三者的异同？

String(JDK1.0)：不可变字符序列
StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全
StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全
注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值。
String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储。

代码演示

package 常用类.StringTest.demo02;
//以StringBuffer为例，StringBuilder同理
public class Demo08 {
    public static void main(String[] args) {
        test04();
    }
    public static void test01(){
        StringBuffer sb = new StringBuffer();//底层是一个char类型的数组保存数据的。String也是一个char类型的数组保存数据，final 修饰的
        //直接new StringBuffer(), 此时底层数组的长度是16
        StringBuffer sb2 = new StringBuffer(20);//折定数组的长度20
        sb.append("a");//a
        sb.append("b");//ab
        String s = null;
        sb.append(s);//abnull
        sb.append("");//abnull
        System . out. println(sb);
    }
    public static void test02(){
        StringBuffer sb = new StringBuffer(null);//NullPointerException
        System. out. println(sb);//报错

    }
    public static void test03(){
        StringBuffer sb = new StringBuffer("hello");
        sb.append(" world");
        sb.append("java");
        //获取char类型的数组
        char[] cs = sb. toString().toCharArray() ;

    }
    public static void test04(){
        StringBuffer sb = new StringBuffer("helloworld");
        StringBuffer sb2 = sb.insert(5, ",");//再装个位置插入一个符号
        System.out.println(sb);
        System.out.println(sb==sb2);
        //hello, world
        sb.delete(5,6);//[5,6)
        System.out.println(sb2);
        //helloworld
        sb. delete(5, sb.length());//[5,10)
        System.out.println(sb);
        sb.reverse();
        System.out.println(sb);

    }
}

总结

StringBuffer[1.0] StringBuilder[1.5]方法一样的, 构造等都一样, char类型数组的处理方式都是一样的。因为StringBuffer是线程安全的，效率低。StringBuilder，是线程不安全的，效率高。他们都是可变字符串。String是不可变字符串，底层是final修饰的char类型的数组。构造方法常用的是三个，默认char类型数组的长度是16。数组的增量是原来长度的二倍+2。如果创建StringBuffer的时候，直接传递字符串,此时数组的长度是字符串的长度+16。

append(方法:追加。如果追加的是null,此时，直接将null字符串追加到末尾[appendNull方法] 。如果char类型的数组满了,如何进行扩容?是原来长度的二倍+2。 [newCapacity方法] 。如果创建StringBuider或StringBuilder的时候，直接传递null, 将会抛空指针异常，因为带参构造方法(String)先获取String的长度,抛出空指针。

正则表达式

先给出相关表达，看不到的话，可以想看代码演示，再来理解这个意思

\d：0-9任意数字
\w：a-zA-Z0-9_
\D：非0-9
\W：非a-zA-Z0-9_
.：任意字符如果此时想值匹配。这个字符，需要对。进行转义
[a-d|0-5|X-Z]：区问[] ，| 或者
(a|z)：某个字符1从中选取一个
{m ,n}：匹心m到n次。如果省略n，代表最少m次，最多不限制
+：最少一次
*：0到多次
?：最多一次

package 常用类.StringTest.demo02;
//正则表达式
public class Pattern {
    public static void main(String[] args) {
        test03();
    }
    //基本了解用法
    public static void test01(){
        String s = "X";
        boolean f = s.matches("[a-d|0-5|X-Z]");
        System.out.println(f);
    }
    //匹配手机号，或者座机号(0527-8888777，前面是3-4位，后面是7-8位)
    public static void test02(){
        String phone = "052-8888777";
        boolean f = phone.matches("\\d{11}|\\d{3,4}-\\d{7,8}");
        System.out.println(f);
    }
    //匹配邮箱 英文字符开头+数字、字符、下划线(5-17位)+@+数字或者字母(2-6位)+.com/.cn
    public static void test03(){
        String email = "a123456789@qq.com";
        boolean f = email.matches("[a-zA-Z]\\w{5,17}@[0-9a-zA-Z]{2,6}\\.(com|cn)");
        System.out.println(f);
    }
}

Date类

知识清单

System. currentTimeMillis()系统当前时间，毫秒表示

表示日期一般有两种

java.util.Date
java. sql.Date
util下的Date是sql.Date的一个父类。开发的时候，自己声明bean对象的时候，一般使用utilDate
需要掌握两者之间的转换
java.util.Date中的方法
Date()
Date(long time)
getTime();

字符串转换为sqlDate java. sql.Date. value0f();
sql. Date与util.Date()转换

借助SimpLeDateFormat类转换字符串和日期

借助simpleDateFormat类转换日期与字符串
String s = “时间”;
SimpleDateFormat sdf = new SimpleDateFormat(“格式”);//yyyy-MM-dd HH:mm:ss
Date date = sdf .parse(s);//java. utilDate

也可以借助SimpleDateFormat获取我们想要的时间格式
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat(“yyy年MM月dd日HH:mm:ss”);
String s = dateFormat . format (date);

思考：自己定义一个工具类，可以实现日期与字符串之间的一个转换。
1.实现将日期类型转换为字符串类型
2、实现将字符串类型转换为日期类型

Calendar类，获取日期信息
Calendar calendar = Calendar . getInstance();//实例
int year = calendar.get(CaLendar.YEAR);//得到年
int month = calendar.get(Calendar.MONTH)+1;//得到月
int day =calendar.get (Calendar.DAY_OF_MONTH);//得到天
int weekday = calendar.get (Calendar.DAY_0F_WEEK);//得到星期
打印日历

JDK8的新特性

LocalDate
LocalTime
LocalDateTime

LocalDate date = LocalDate.now();//获取当前日期
LocalDate date2 = LocalDate.of(2019, 3, 14);//修改日期
DayOfWeek weekDay = date.getDayOfWeek();//得到这个日期是星期几
int monthVal = date.getMonthValue();//得到这个日期是几月
String s = date.format(DateTimeFormatter.ofPattern(“yy/MM/dd”));//对日期进行格式处理
LocalDate date3 = LocalDate.parse(“2019-03-25”, DateTimeFormatter.ofPattern(“yy-MM-dd”));//对日期进行格式处理

代码讲解

package 常用类.StringTest.demo02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class DateTest {
    public static void main(String[] args) {
        test08();
    }

    //初始date
    public static void test01() {
        //java中日期类型
        /*三种表达日期方式
        long time = System.currentTimeMillis();毫秒显示
        Date date2 = new Date(time);直接输出是英文显示
        Date date = new Date();直接输出是英文显示
        data.getTime();获取日期的毫秒表示
         */

        Date date = new Date();//系统当前的时间.
        System.out.println(date);
        try {
            Thread.sleep(2000);//睡眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long time = System.currentTimeMillis();
        System.out.println(time);
        Date date2 = new Date(time);
        System.out.println(date2);
    }

    //sql.Date与util.Date()转换
    public static void test02() {
        //将一个字符串转换为sql.Date().value0f();
        java.sql.Date date = java.sql.Date.valueOf("2020-01-12");
        System.out.println(date);
        Date date2 = new Date(date.getTime());
        System.out.println(date2);
        //Java. util. Date
    }

    //如果将给定的字符串转化成日期类型
    public static void test03() {
        String s = "2020/01/28 08:30:23";//转换 为11期类型
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy/MM/dd HH:mm:ss");//格式要一样
        try {
            Date date = simpleDateFormat.parse(s);
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    //将日期转化成我们想要的格式
    public static void test04() {
        Date date = new Date();
        System.out.println(date);
        //转换为然悉的方符中形式
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月ddH HH:mm:ss");
        String s = dateFormat.format(date);
        System.out.println(s);
    }

    //接口Calendar用法
    public static void test05() {
        Calendar calendar = Calendar.getInstance();//实例
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "--" + month + "---" + day);
        calendar.set(Calendar.DAY_OF_MONTH, 27);
        Date date = calendar.getTime();
        System.out.println(date);
    }

    //JDK8新特性LocalDate用法
    public static void test06() {
        LocalDate date = LocalDate.now();//获取当前日期
        System.out.println(date);
        LocalDate date2 = LocalDate.of(2019, 3, 14);//修改日期
        System.out.println(date2);
        DayOfWeek weekDay = date.getDayOfWeek();//得到这个日期是星期几
        System.out.println(weekDay);//英文的星期
        System.out.println(weekDay.getValue());//数字的星期
        int monthVal = date.getMonthValue();//得到这个日期是几月
        System.out.println(monthVal);
        String s = date.format(DateTimeFormatter.ofPattern("yy/MM/dd"));//对日期进行格式处理
        System.out.println(s);
        LocalDate date3 = LocalDate.parse("2019-03-25", DateTimeFormatter.ofPattern("yy-MM-dd"));//对日期进行格式处理
        System.out.println(date3);
    }

    //Instant用法
    public static void test07() {
        Instant instant = Instant.now();//零时区的时间
        System.out.println(instant);
        OffsetDateTime dateTime = instant.atOffset(ZoneOffset.ofHours(8));//设置位东8区时间
        System.out.println(dateTime);
    }

    //打印日历
    public static void test08() {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入年与月");
        int year = input.nextInt();
        int month = input.nextInt();
        LocalDate localDate = LocalDate.of(year, month, 1);
        int week = localDate.getDayOfWeek().getValue();//
        System.out.println(localDate.isLeapYear());
        int days = 31;
        if (month >= 1 & month <= 12) {
            switch (month) {
                case 2:
                    if (localDate.isLeapYear()) {
                        days = 29;
                    } else {
                        days = 28;
                    }
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    days = 30;
                    break;
            }
            System.out.println("星期一\t星期二\t星期三\t星期四\t星期五\t星期六\t星期日");
            int count = 0;
            for (int i = 1; i < week; i++) {
                System.out.print("\t\t");
                count++;
                for (int i1 = 1; i1 <= days; i1++) {
                    System.out.print(i1 + "\t\t");
                    count++;
                    if (count % 7 == 0) {
                        System.out.println();


                    }
                }
            }
//            for(int i=1;i<week;i++){
//                System. out.print("\t\t");
//                count++;
//                while(localDate.getMonthValue()==month) {
//                    System. out . print (localDate.getDayOfMonth()+"\t\t");
//                    localDate = localDate.plusDays(1);
//                    count++;
//                    if (count%7==0){
//                        System. out . println();
//                    }
//                }
//
            }
    }
}

Math类

主要就是进行数学中的一些运算，常见的运算可以考虑该类型

package 常用类.MathTest;

import java.math.BigDecimal;
import java.math.BigInteger;

public class Demo01 {
    public static void main(String[] args) {
        test01();
    }

    public static void test01() {
        double num = 12.5;
        double num2 = -12.5;
        System.out.println(Math.ceil(num));//向上取整
        System.out.println(Math.ceil(num2));
        System.out.println(Math.floor(num));//向下取整
        System.out.println(Math.floor(num2));
        System.out.println(Math.round(num));//四舍五入
        System.out.println(Math.round(num2));
    }

    //和Math有点一样，这个的数字可以很大，如果用Math时数值太大，超了范围，就可以考虑
    public static void test02(){
        BigInteger bigInteger1 = new BigInteger("100");
        BigInteger bigInteger2 = new BigInteger("100");
        BigInteger bigInteger3 = bigInteger1. add(bigInteger2);
        System.out.println(bigInteger1);
        System.out.println(bigInteger3);
        System.out.println(bigInteger1. divide(bigInteger3));
        System.out.println(bigInteger1.max(bigInteger3));//返回大的数字.
        BigInteger bigInteger = BigInteger.valueOf(125236);
        System.out.println(bigInteger);
    }
    public static void test03(){
        BigDecimal bigDecimal = new BigDecimal(1000);//
        int val = bigDecimal.intValue();
        System.out.println(val);
    }


}

Arrays类

这个类中我们经常使用的是数组的输出，我们这里主要讲一下里面的sort方法，对于基本数据类型可以直接使用，对于引用数据类型需要我们自己重写CompareTo方法

Comparable接口

public class Person implements Comparable<Person>{//继承Comparable接口，比较的类型就是Person
	private int pid;
	private String pname;
	private Integer page;
	public Person() {
	}
	public Person(Integer pid， string pname, Integer page) {
        this.pid = pid;
        this.pname = pname ;
        this .page = page;
	}
    ....
    @override//需要重写该方法，需要使用的时候就可以直接使用sort方法
    public int compareTo(Person p) {
    	return this.page.compareTo(p.page);//按照page这个属性比较，
    }
}

上面我们用的是继承了这个Comparable这个接口，并且进行了重写，那如果类中没有继承比较器，该怎么比较呢？我们前面也讲过内部类。所以我们在sort时给它传进去一个接口即可如下

Comparator接口

import Day09.Demo3;

import java.util.Arrays;
import java.util.Comparator;

class Person{
    Integer age;
    String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "姓名："+ name + "年龄："+ age;
    }
}

public class Demo02 {
    public static void main(String[] args) {
        Person[] arr = new Person[5];
        arr[0] = new Person(12,"a");
        arr[1] = new Person(2,"f");
        arr[2] = new Person(14,"s");
        arr[3] = new Person(20,"h");
        arr[4] = new Person(7,"fs");
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.age.compareTo(o2.age);
            }
        });
        System.out.println(Arrays.toString(arr));

    }
}

或者我们自己写一个方法继承Comparator也行，这个方法是比较常用的，因为可以写很多方法，每个方法都是按照不同的比较依据。但如果是上面的Comparable接口，是写在类里面的，按照什么比较就固定死了。

package 常用类.MathTest;

import Day09.Demo3;

import java.util.Arrays;
import java.util.Comparator;

class Person{
    Integer age;
    String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "姓名："+ name + "年龄："+ age;
    }
}

public class Demo02 {
    public static void main(String[] args) {
        Person[] arr = new Person[5];
        arr[0] = new Person(12,"a");
        arr[1] = new Person(2,"f");
        arr[2] = new Person(14,"s");
        arr[3] = new Person(20,"h");
        arr[4] = new Person(7,"fs");
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr, new personComparator());
        System.out.println(Arrays.toString(arr));

    }
    public static class personComparator implements Comparator<Person>{//自己写的方法继承Comparator
        @Override
        public int compare(Person o1, Person o2) {
            return o1.age.compareTo(o2.age);
        }
    }

}

这几种比较讲完了可以想一下，什么时候用Comparable接口，什么时候用Comparator接口？，如果这个类确定只按照某一种排序，那么直接封装在类中用Comparator接口，如果这个类的比较依据不确定，可能按照年龄，可能按照姓名…像这样就用Comparator接口比较灵活。当然，如果类中封装了Comparable接口，然后进行排序时，又用了Comparator接口，那么就是按照就近的比较规则排序。