常用类(二)

一、比较器

比较器规范：（接口）

java.util.Comparator

package com.JavaSE.homework.Day15.comparatordemo;
​
import java.util.Arrays;
​
public class Practice {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 45, 5};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

sort(Object[] o,Comparator c);谁调用这个方法，传递一个数组，就会进行排序

两种方式：

第一种：写一个Compartor实现类

package com.JavaSE.homework.Day15.comparatordemo;
//说白了 就是套用了这个Compartor的壳,比较过程全是自己写的
import java.util.Comparator;
​
public class ComparatorImp1 implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof Student && o2 instanceof Student) {
            //这里重写没有指定参数类型,传入的参数还得强转,容易出错,还麻烦
            if (((Student) o1).getScore() > ((Student) o2).getScore()) {
                return 1;
            } else if (((Student) o1).getScore() < ((Student) o2).getScore()) {
                return -1;
            } else {
                return 0;
            }
        } else {
            System.out.println("请比较同一类型!!!");
            return 0;
        }
​
    }
}

package com.JavaSE.homework.Day15.comparatordemo;
​
import java.util.Arrays;
​
public class Student {
    private String stuID;
    private String name;
    private int score;
​
    public String getStuID() {
        return stuID;
    }
​
    public void setStuID(String stuID) {
        this.stuID = stuID;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getScore() {
        return score;
    }
​
    public void setScore(int score) {
        this.score = score;
    }
​
    public Student(String stuID, String name, int score) {
        this.stuID = stuID;
        this.name = name;
        this.score = score;
    }
​
    public Student() {
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "stuID='" + stuID + '\'' +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}
​

package com.JavaSE.homework.Day15.comparatordemo;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("001", "曹植", 100);
        Student s2 = new Student("002", "曹丕", 80);
        ComparatorImp1 ci1 = new ComparatorImp1();
        int a1 = ci1.compare(s1, s2);
        if (a1 > 0) {
            System.out.println(s1 + "大");
        } else if (a1 < 0) {
            System.out.println(s2 + "小");
        } else {
            System.out.println("相等");
        }
    }
​
}

弊端:这种重写没有指定参数类型,传入的参数还得强转,容易出错,还麻烦

下面我们指定参数类型

package com.JavaSE.homework.Day15.comparatordemo;
​
import java.util.Comparator;
​
public class ComparatorImp2 implements Comparator<Student> {
    @Override//因为限制了参数类型,所以不用在instanceof判断了
    public int compare(Student o1, Student o2) {
        return o1.getScore()-o2.getScore();
    }
}

​

package com.JavaSE.homework.Day15.comparatordemo;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("001", "曹植", 100);
        Student s2 = new Student("002", "曹丕", 80);
//        ComparatorImp1 ci1 = new ComparatorImp1();
        ComparatorImp2 ci2 = new ComparatorImp2();
        int a1 = ci2.compare(s1, s2);
        if (a1 > 0) {
            System.out.println(s1 + "大");
        } else if (a1 < 0) {
            System.out.println(s2 + "小");
        } else {
            System.out.println("相等");
        }
    }
​
}

最终版：

指定比较器参数类型+sort排序

package com.JavaSE.homework.Day15.comparatordemo;
​
import java.util.Arrays;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("001", "曹植", 100);
        Student s2 = new Student("002", "曹丕", 80);
        Student s3 = new Student("002", "曹爽", 70);
        Student s4 = new Student("002", "曹仁", 60);
        Student s5 = new Student("002", "曹冲", 90);
        Student s6 = new Student("002", "曹真", 88);
        ComparatorImp2 ci2 = new ComparatorImp2();
        Student[] stu = {s1, s2, s3, s4, s5, s6};
        Arrays.sort(stu,ci2);
        System.out.println(Arrays.toString(stu));
    }
​
}

匿名内部类最终写法

耦合度最低

package com.JavaSE.homework.Day15.comparatordemo;
​
import java.util.Arrays;
import java.util.Comparator;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("001", "曹植", 100);
        Student s2 = new Student("002", "曹丕", 80);
        Student s3 = new Student("003", "曹爽", 70);
        Student s4 = new Student("004", "曹仁", 60);
        Student s5 = new Student("005", "曹冲", 90);
        Student s6 = new Student("006", "曹真", 88);
​
        Student[] stu = {s1, s2, s3, s4, s5, s6};
        //正常这里是放一个对象,现在我们new父类 把子类重写的方法直接写到这里,等于省略了中间的变量名(对象名)
        //即使用匿名函数
        Arrays.sort(stu,new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getScore()-o2.getScore();
            }
        });
        System.out.println(Arrays.toString(stu));
​
    }
}

java.lang.Comparable 接口

String implements Comparable

耦合度高，一般不这么写

package com.JavaSE.homework.Day15.comparabledemo;
​
​
public class Student implements Comparable<Student> {
    private String stuID;
    private String name;
    private int score;
​
    public String getStuID() {
        return stuID;
    }
​
    public void setStuID(String stuID) {
        this.stuID = stuID;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getScore() {
        return score;
    }
​
    public void setScore(int score) {
        this.score = score;
    }
​
    public Student(String stuID, String name, int score) {
        this.stuID = stuID;
        this.name = name;
        this.score = score;
    }
​
    public Student() {
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "stuID='" + stuID + '\'' +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
​
    @Override
    public int compareTo(Student o) {
        return this.getScore()-o.getScore();
    }
}

 

package com.JavaSE.homework.Day15.comparabledemo;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("001", "曹植", 100);
        Student s2 = new Student("002", "曹丕", 80);
        int a1 = s1.compareTo(s2);
                if (a1 > 0) {
            System.out.println(s1 + "大");
        } else if (a1 < 0) {
            System.out.println(s2 + "小");
        } else {
            System.out.println("相等");
        }
    }
}

总结：比较器是比较的两个接口，两个规范

自定义的类是没有比较规则的，那么这个时候实现需要比较器来设定比较规则的

二、StringBuilder

StringBuffer是可变字符串，引用的内存地址不变，内存中数组是可扩容改变的

StringBuilder跟StringBuffer是一样的

insert()

delete()

append()

reverse()

 

StringBuffer的方法上全部都有关键字 synchronized，表示线程安全

StringBuilder的方法没有synchronized，线程不安全

 

StringBuffer，线程安全， 效率低

StringBuilder, 线程不安全，效率高

 

package com.JavaSE.homework.Day15.stringbuilder;
​
public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        sb1.append(1);
        sb1.append("哈哈1");
        System.out.println(sb1);//1哈哈1
        sb1.delete(0, 1);
        System.out.println(sb1);//哈哈1
        sb1.reverse();
        System.out.println(sb1);//1哈哈
        sb1.replace(0, 3, "嘻嘻1");//嘻嘻1
        System.out.println(sb1);
        sb1.deleteCharAt(2);
        System.out.println(sb1);//嘻嘻
    }
​
}

三、Date类

package com.szpowernode.day15.datedemo;

import java.util.Calendar;
import java.util.Date;

public class DateTest {

    public static void main(String[] args) {
        //本机时间
        Date date=new Date();
        System.out.println(date);
        int year1 = date.getYear();
        System.out.println(year1+1900);
         //输出 的类型是date类型，国内不是很好
        // 输出单个的年月日，不好用，已过时
       // 推荐使用的新的去替换Date的一个类
        System.out.println("===================");
        Calendar instance = Calendar.getInstance();
        //得到了年份
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH)+1;
        int day = instance.get(Calendar.DAY_OF_MONTH);
        int week = instance.get(Calendar.DAY_OF_WEEK)-1;
        int hour = instance.get(Calendar.HOUR);
        int minute = instance.get(Calendar.MINUTE);
        int second = instance.get(Calendar.SECOND);
        System.out.println(year+"年"+month+"月"+day+"日"+" 星期"+week);
                    System.out.println(hour+":"+minute+" "+second);

    }

}

日期格式化类java.text.SimpleDateFormat

package com.JavaSE.homework.Day15.DemoDate;


import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDate {
    public static void main(String[] args) {
        Date d1 = new Date();
        System.out.println(d1);//自带的不习惯
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss");
        String s1 = df.format(d1);
        System.out.println(s1);
    }
}

结果：
Sun Oct 18 12:11:43 CST 2020
2020-10-18 星期日 12:11:43

四、LocalDateTime类

1.8新特性的类，线程安全的

package com.JavaSE.homework.Day15.DemoDate;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;

public class TestDemo2 {
    public static void main(String[] args) {
        //LocalDateTime的构造函数私有化,不能创建对象
        //必须借助now()方法才能获取当前系统时间
        LocalDateTime d1 = LocalDateTime.now();
        System.out.println(d1);
        //DateTimeFormatter的构造函数是default
        //只能在java.text包中使用
        DateTimeFormatter f1 = DateTimeFormatter.ofPattern("yyyy-MM-dd E HH:mm:ss");
        //参数类型TemporalAccessor ---- 爷爷类 这个和DateTimeFormatter什么关系
        // Temporal ------父类
        // 实际传递的类型LocalDateTime----子类
        //父子关系
        String s = d1.format(f1);
        //传入DateTimeFormatter类对象 调用了formatter.format(this),这个this就是Temporal类
        //而这个Temporal又是LocalDateTime的父类,所以此方法用DateTimeFormatter格式化等于绕个弯
        //用的还是LocalDateTime类的方法
        System.out.println(s);
    }
}

结果：
2020-10-18T15:00:48.176
2020-10-18 星期日 15:00:48

Date 和LocalDateTime的区别？-----------线程安全的区别

五、数学类和其他类

package com.JavaSE.homework.Day15.DemoMath;

public class TestMath {
    public static void main(String[] args) {
        //绝对值
        short s1 = (short) 2;
        System.out.println(Math.abs(s1));//byte和short被强转成int了
        //四舍五入变成整数
        System.out.println(Math.round(3.49));
        //无穷大方向上最接近的整数
        System.out.println(Math.ceil(-2.9));
        System.out.println(Math.ceil(2.9));
        //无穷小方向上最接近的整数
        System.out.println(Math.floor(-3.6));
        System.out.println(Math.floor(3.6));
        //随机数,产生一个[0,1)的随机数
        System.out.println(Math.random());
        //产生一个1到10的随机数
        int i = (int) ((Math.random()) * 10 + 1);
        System.out.println(i);
        System.out.println(Math.max(3.1,5.6));
        System.out.println(Math.min(3.1,5.6));
        System.out.println(Math.sqrt(64));
        System.out.println(Math.cbrt(64));
        System.out.println(Math.pow(64,0.5));
        System.out.println(Math.pow(8,2));
    }
}

java.util.Random类

package com.szpowernode.day15.mathdemo;

import java.util.Random;

public class TestRandom {
    public static void main(String[] args) {
        Random rd=new Random();
        //nextInt() 0到参数的随机数，（不包括参数）
        int i = rd.nextInt(10)+1;
        System.out.println(i);
    }
}

java.text.DecimalFormat数字格式化类

package com.JavaSE.homework.Day15.DemoMath;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;

//小数格式化
public class NumFormat {
    public static void main(String[] args) throws ParseException {
        DecimalFormat df = new DecimalFormat("#,##0.00");
        String s = df.format(323.2332);
        System.out.println(s);
        //字符串转数字
        Number n1 = df.parse("23.543");
        System.out.println(n1);
        //包装类 向下转型
        Double d1 = (Double) n1;
        System.out.println(d1);
//        BigDecimal d2 = (BigDecimal) n1;//这里不能强制转
//        System.out.println(d2);

    }
} 

• BigInteger,BigDecimal类

如果进行科学计算,财务计算时,使用double可能不准确, 可以使用BigInteger,BigDecimal类. 可以调用add(),subtract(),multiply(),divide()进行加减乘除操作. 

package com.JavaSE.homework.Day15.DemoMath;

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

public class TestBig {
    public static void main(String[] args) {
        //大整数,有小数点会报错
        BigInteger bi1 = new BigInteger("21124134213214123213");
        System.out.println(bi1);
        BigInteger bi2=new BigInteger("123456789123456789125634564654654654564634565456465465");
        BigInteger add = bi1.add(bi2);
        System.out.println(add);
        System.out.println(bi1.subtract(bi2));
        System.out.println(bi1.multiply(bi2));
        System.out.println(bi1.divide(bi2));
        //大小数
        BigDecimal bd1 = new BigDecimal("2.00");
        System.out.println(bd1);
        BigDecimal bd2 = new BigDecimal("1.1");
        BigDecimal add2 = bd1.add(bd2);
        System.out.println(add2);
        System.out.println(bd1.subtract(bd2));
        System.out.println(2.0-1.1);
        System.out.println(bd1.multiply(bd2));
//        System.out.println(bd1.divide(bd2));//除不尽会报错

    }
}