17Java基础之常用API

常用API使用

StringBuilder

StringBuilder代表可变字符串对象，相当于一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。
好处：StringBuilder比String更适合做字符串的修改操作，效率会更高，代码也会更简洁。

案例：

// 目标：学会用StringBuilder，理解其好处。
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //1.创建StringBuilder对象
        StringBuilder s1 = new StringBuilder(); // 相当于s1 = ""
        StringBuilder s2 = new StringBuilder("abc"); // 相当于s2 = "abc"
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("-------------------------------------");
        //2.拼接内容
        s1.append("abc").append("我是好人").append(666).append(true);
        System.out.println(s1);
        System.out.println("-------------------------------------");
        //3.反转内容
        s1.reverse();
        System.out.println(s1);
        System.out.println("-------------------------------------");
        //4.拿长度
        System.out.println(s1.length());
        System.out.println("-------------------------------------");
        //5.把StringBuilder对象转换成String对象。
        // StringBuilder是拼接字符串的手段，String才是开发的目的。
        String rs = s1.toString();
        System.out.println(rs);
    }
}

为什么操作字符串建议使用StringBuilder，而不用原来学过的String？

因为String拼接字符串的性能较差，而StringBuilder较好。

案例：

//目标：进行StringBuilder拼接字符串的性能测试
public class StringBuilder02 {
    public static void main(String[] args) {
        //1. 使用String拼接，看看效率如何
        String s = "";
       /* for (int i = 0; i < 1000000; i++) {
            s += "abc";
        }
        System.out.println(s);*/

        //2. 使用StringBuilder拼接，看看效率
        StringBuilder s1 = new StringBuilder();
        for (int i = 0; i < 1000000; i++) {
            s1.append("abc");
        }
        System.out.println(s1);
    }
}

对于字符串相关的操作，如果频繁的拼接、修改等，建议用StringBuilder，效率更高。
注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议用String。

StringBuffer与StringBuilder
注意：

StringBuffer的用法与StringBuilder是一模一样的。
但StringBuilder是线程不安全的，StringBuffer是线程安全的。

案例：

需求：设计一个方法，用于返回任意整型数组的内容，要求返回的数组内容格式如：“[11, 22, 33]”

//目标：使用StringBuilder完成对字符串的拼接操作
public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        String s = getArrayData(arr);
        System.out.println(s);
    }

    public static String getArrayData(int[] arr){
        if(arr == null || arr.length == 0) return null;

        //1.创建StringBuilder对象
        StringBuilder s1 = new StringBuilder();

        s1.append("[");
        //2.遍历数组的内容
        for (int i = 0; i < arr.length; i++) {
                int temp = arr[i];
                s1.append(temp);
                s1.append(i == arr.length - 1 ? "" : ", ");
        }
        s1.append("]");
        return s1.toString();
    }
}

StringJoiner
为什么学StringJoiner？

JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。
好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁。

案例：

// 目标：使用StringJoiner完成对字符串的拼接
public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        String s = getArrayData(arr);
        System.out.println(s);
    }
    public static String getArrayData(int[] arr){
        if(arr == null || arr.length == 0) return null;

        //1.创建StringJoiner对象
        // StringJoiner(间隔符，开始符号，结束符号)
        StringJoiner s1 = new StringJoiner(", ", "[", "]");
        //2.遍历数组的内容
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            s1.add(Integer.toString(temp));
        }

        return s1.toString();
    }
}

Math、System、Runtime

Math

Math代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法。
Math类提供的常见方法

Runtime

代表程序所在的运行环境。
Runtime是一个单例类。
Runtime类提供的常见方法

System

System代表程序所在的系统，也是一个工具类。
System类提供的常见方法

currentTimeMillis()方法，返回的时间是毫秒值。
时间毫秒值

指的是从1970年1月1日，00:00:00走到此刻的总毫秒数，应该是很大的.1s = 1000ms。

为什么选择“1970年1月1日，00:00:00”作为时间起点？

1969年8月，贝尔实验室的程序员汤普逊利用妻儿离开一个月的机会，开始着手创造一个全新的革命性的操作系统，他使用B编译语言在老旧的PDP-7机器上开发出了Unix的一个版本。随后汤普逊和同事丹尼斯里奇改进了B语言，开发出了C语言，重写了UNIX。1970年1月1日，算是C语言的生日。

BigDecimal

用于解决浮点型运算时，出现结果失真的问题。

BigDecimal的常见构造器、常用方法

案例：

// 目标：学会处理浮点型运算失真的问题
public class Test {
    public static void main(String[] args) {
        double a = 0.1;
        double b = 0.3;
        double c = a + b;
        System.out.println(c);//0.30000000000000004

        //1. 把两个数据包装成Bigdecimal对象
        // a. public BigDecimal(String val):这个接收字符串的构造器才可以解决失真的问题。
        BigDecimal a1 = new BigDecimal(Double.toString(0.1));
        BigDecimal a2 = new BigDecimal(Double.toString(0.3));
        a1 = a1.add(a2);
        System.out.println(a1);

        // b. 阿里巴巴公司更推荐我们使用valueOf方法，包装浮点型数据称为BigDecimal对象。
        // 和上面的做法本质是一样的。
        BigDecimal b1 = BigDecimal.valueOf(a);
        BigDecimal b2 = BigDecimal.valueOf(b);

        //2. 调用方法进行精度运算
        BigDecimal c11 = b1.add(b2);
        BigDecimal c1 =b1.subtract(b2);
        //3. BigDecimal是处理精度问题的手段，结果必须是基本类型。
        double res = c11.doubleValue();
        System.out.println(res);
        res = c1.doubleValue();
        System.out.println(res);
        System.out.println("======================");

        /*
        * divaide(除数, 保留小数位数, 取舍方式)
        * */
        BigDecimal k = a1.divide(a2, 3, BigDecimal.ROUND_HALF_UP);
    }
}

日期、时间API

JDK8新增的时间

所在的包：java.time包

LocalDate：年、月、日
LocalTime：时、分、秒
LocalDateTime:年、月、日、时、分、秒
ZoneId: 时区
ZoneDateTime：带时区的时间
Instant：时间戳/时间线
DateTimeFormatter：用于时间的格式化和解析
Duration：时间间隔（时、分、秒、纳秒）
Period：时间间隔（年、月、日）

他们获取对象的方案

案例：

public class LocalDateDemo01 {
    public static void main(String[] args) {
        //1. 得到LocalDate的对象:代表的是此刻的日期
        LocalDate ld = LocalDate.now();
        System.out.println(ld);

        //2. 单独获取年、月、日
        System.out.println(ld.getYear());
        System.out.println(ld.getMonthValue());
        System.out.println(ld.getDayOfMonth());
        // 3.获取星期几
        System.out.println(ld.getDayOfWeek().getValue());
    }
}

什么是时区？

由于世界各个国家与地区的经纬度不同，各地区的时间也有所不同，因此会划分为不同的时区。
Zoneld:代表时区id，中国标准时间为UTC8.

Zoneld时区的常见方法

案例：

 //目标：了解时区和带时区的时间
public class ZoneldDemo01 {
    public static void main(String[] args) {
        //1. Zoneld(用于获取时区):的常见方法
        ZoneId zld = ZoneId.systemDefault();
        System.out.println(zld.getId());
        System.out.println(zld);

        // 获取所有时区的id
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds);
        ZoneId an = ZoneId.of("America/New_York");

        //2. 通过美国时区，获取带时区的时间
        // ZonedDateTime的功能和LocalDateTime的一样。
        ZonedDateTime zdt = ZonedDateTime.now(an);
        System.out.println(zdt);

        //3. 获取世界标准时间
        ZonedDateTime zdt1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(zdt1);
    }
}

Instant 时间线上的某个时刻/时间戳

通过获取Instant的对象可以拿到此刻的时间，该时间由两部分组成：从1970-01-01 00:00:00开始走到此刻的总秒数+不够1秒的纳秒数。
案例：

//目标：掌握Instant的使用
public class InstantDemo01 {
    public static void main(String[] args) {
        //1. 创建Instant对象，获取此刻时间信息
        Instant ins = Instant.now();
        System.out.println(ins);

        //2. 获取总秒数
        System.out.println(ins.getEpochSecond());
        //3. 获取纳秒数
        System.out.println(ins.getNano());
    }
}

DateTimeFormatter 格式化器，用于时间的格式化，解析

案例：

//目标：掌握DateTimeFormatter的使用
public class DateTimeFormatterDemo01 {
    public static void main(String[] args) {
        //1. 创建一个日期时间格式化器对象
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss EEE a");
        //2. 格式化日期时间
        LocalDateTime ldt = LocalDateTime.now();
        String date = dtf.format(ldt);
        System.out.println(date);
        //3. 第二种方案格式化时间
        String date2 = ldt.format(dtf);
        System.out.println(date2);

        //4. 解析时间：解析时间一般使用localDateTime提供的解析方法来解析。
        String datestr = "2023-11-13 14:45:28";
        // 第一步：必须写一个日期时间格式化器对象
        DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //第二步：解析时间
        LocalDateTime ldt2 = LocalDateTime.parse(datestr,dtf2);
        System.out.println(ldt2);
    }
}

Period(一段时间)

可以计算两个LocalDate对象相差的年数、月数、天数。

案例：

//目标：掌握Period的使用：计算两个日期相差的年数，月数，天数
public class PeriodDemo01 {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2025,7,31);
        LocalDate end = LocalDate.of(2025,9,3);
        //1. 创建Period对象，封装两个日期
        Period period = Period.between(start,end);
        //2. 通过period对象获取两个日期对象相差的信息。
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

Duration(持续时间)

可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime、LocalDateTime、Instant等时间差。

案例：

//目标：掌握Duration的使用
public class DurationDemo01 {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025,7,31,16,41,32);
        LocalDateTime end = LocalDateTime.of(2025,9,3,18,41,32);
        //1. 创建Duration对象,计算两个日期的相差的时间
        Duration duration = Duration.between(start, end);
        //2. 获取两个时间间隔的信息
        System.out.println(duration.toDays());
        System.out.println(duration.toHours());
        System.out.println(duration.toMinutes());
        System.out.println(duration.toSeconds());
        System.out.println(duration.toNanos());
    }
}

**案例：高考倒计时 **

//目标：高考倒计时
public class Test {
    public static void main(String[] args) {
        //1. 高考时间
        String StartTime ="2026-06-07 09:30:00";
        //2. 知道此刻距离高考时间差多少天，多少时，多少分，多少秒
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime start = LocalDateTime.parse(StartTime,dtf);
        LocalDateTime end = LocalDateTime.now();

        // 3. 计算两个日期差
        Duration between = Duration.between(start, end);
        System.out.println(between.toDays() + "天" +
                            between.toHoursPart() + "时" +
                            between.toMinutesPart() + "分" +
                            between.toSecondsPart() + "秒");
    }
}

posted @ 2025-08-01 16:11 狂风将军阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

gyg9006

17Java基础之常用API

常用API使用

公告