黑马java学习笔记10(阶段二 第二章2-2~2-4)第二章完结

以下学习笔记记录于：2024.09.04-2024.09.10

阶段二 JavaSE进阶

第二章 常用API

2-2 时间日期类

53 传统时间：Date日期类

DateTest.java:

import java.util.Date;
// 目标：掌握Date日期类的使用
public class DateTest {
    public static void main(String[] args) {
        // 1、创建一个Date的对象，代表系统当前时间信息的
        Date d = new Date();
        System.out.println(d);

        // 2、拿到时间毫秒值
        long time = d.getTime();
        System.out.println(time);

        // 3、把时间毫秒值转换成日期对象：2s之后的时间是多少。（此处time为毫秒单位）
        time += 2 * 1000;
        Date d2 = new Date(time);
        System.out.println(d2);
        
        // 4、直接把日期对象的时间通过setTime方法进行修改
        Date d3 = new Date();
        d3.setTime(time);
        System.out.println(d3);
    }
}

运行结果：

54 传统时间：SimpleDateFormat日期格式化

SimpleDateFormatTest.java:

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

public class SimpleDateFormatTest {
    public static void main(String[] args) throws ParseException {
        // 1、准备一些时间
        Date d = new Date();
        System.out.println(d);

        long time = d.getTime();
        System.out.println(time);   // 毫秒值

        // 2、格式化日期对象，和时间（毫秒值）
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a");
        String rs = sdf.format(d);
        String rs2 = sdf.format(time);
        System.out.println(rs);
        System.out.println(rs2);
        
        System.out.println("---------------------------------");
        
        // 目标：掌握SimpleDateFormat解析字符串时间成为日期对象
        String dateStr = "2022-12-12 12:12:11";
        // 1、创建简单日期格式化对象，指定的时间格式必须与被解析的时间格式一模一样，否则程序会出bug
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2 = sdf2.parse(dateStr);
        System.out.println(d2);
    }
}

运行结果：

55 传统时间：秒杀案例

miaoshaTest.java:

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

public class miaoshaTest {
    public static void main(String[] args) throws ParseException {
        // 1、把开始时间、结束时间、小贾下单时间、小皮下单时间拿到程序中来
        String start = "2023年11月11日 0:0:0";
        String end = "2023年11月11日 0:10:0";
        String xj = "2023年11月11日 0:01:18";
        String xp = "2023年11月11日 0:10:57";

        // 2、把字符串的时间解析成日期对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startDt = sdf.parse(start);
        Date endDt = sdf.parse(end);
        Date xjDt = sdf.parse(xj);
        Date xpDt = sdf.parse(xp);

        // 3、开始判断小皮和小贾是否秒杀成功
        // 把日期对象转换成时间毫秒值来判断
        long startTime = startDt.getTime();
        long endTime = endDt.getTime();
        long xjTime = xjDt.getTime();
        long xpTime = xpDt.getTime();

        if (xjTime >= startTime && xjTime <= endTime){
            System.out.println("小贾您秒杀成功了！！！");
        }else {
            System.out.println("小贾您秒杀失败");
        }

        if (xpTime >= startTime && xpTime <= endTime){
            System.out.println("小皮您秒杀成功了！！！");
        }else {
            System.out.println("小皮您秒杀失败");
        }
    }
}

运行结果：

56 传统时间：Calendar

原本的解决方式：

CalendarTest.java:

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

public class CalendarTest {
    public static void main(String[] args) {
        // 1、得到系统此刻时间对应的日历对象
        Calendar now = Calendar.getInstance();
        System.out.println(now);

        // 2、获取日历中的某个信息
        int year = now.get(Calendar.YEAR);
        System.out.println(year);

        int days = now.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);

        // 3、拿到日历中记录的日期对象
        Date d = now.getTime();
        System.out.println(d);

        // 4、拿到当前时间毫秒值
        long time = now.getTimeInMillis();
        System.out.println(time);

        // 5、修改日历中的某个信息
        now.set(Calendar.MONTH, 9);     // 此处是从0开始算的，所以9表示10月份
        now.set(Calendar.DAY_OF_YEAR, 125);     // 修改成一年中的第125天
        System.out.println(now);

        // 6、为某个信息增加或者减少多少
        now.add(Calendar.DAY_OF_YEAR, 100);
        now.add(Calendar.DAY_OF_YEAR, -10);
        System.out.println(now);
    }
}

57 为什么要学习JDK8新增的时间

JDK8新增的时间如下：

2-3 JDK8新时间

58 LocalDate、LocalTime、LocalDateTime

1) LocalDate

LocalDateTest.java:

import java.time.LocalDate;

public class LocalDateTest {
    public static void main(String[] args) {
        // 获取本地日期对象(不可变的)
        LocalDate ld = LocalDate.now();     // 年 月 日 星期 (不可变的)
        System.out.println(ld);

        // 1、获取日期对象中的信息
        int year = ld.getYear();                        // 年
        int month = ld.getMonthValue();                 // 月
        int day = ld.getDayOfMonth();                   // 日
        int dayOfyear = ld.getDayOfYear();              // 一年中的第几天
        int dayOfWeek = ld.getDayOfWeek().getValue();   // 星期几
        System.out.println(year);
        System.out.println(day);
        System.out.println(dayOfWeek);

        System.out.println("----------------------");
        // 2、直接修改某个信息（返回一个新对象，保持原对象）：withYear、withMonth、withDayOfMonth、withDayOfYear
        LocalDate ld2 = ld.withYear(2099);
        LocalDate ld3 = ld.withMonth(12);
        System.out.println(ld);
        System.out.println(ld2);
        System.out.println(ld3);

        // 3、把某个信息加多少（返回一个新对象，保持原对象）：plusYears、plusMonths、plusDays、plusWeeks
        LocalDate ld4 = ld.plusYears(2);
        LocalDate ld5 = ld.plusMonths(2);

        // 4、把某个信息减多少：minusYears、minusMonths、minusDays、minusWeeks
        LocalDate ld6 = ld.minusMonths(2);
        LocalDate ld7 = ld.minusYears(2);

        // 5、获取指定日期的LocalDate对象：public static LocalDate of( int year, int month, int dayOfMonth)
        LocalDate ld8 = LocalDate.of(2099, 12,12);
        LocalDate ld9 = LocalDate.of(2099, 12,12);

        System.out.println("----------------------");
        // 6、判断2个日期对象，是否相等、是前还是在后：equals、isBefore、isAfter
        System.out.println(ld8.equals(ld9));        // true
        System.out.println(ld8.isBefore(ld));       // false
        System.out.println(ld8.isAfter(ld));        // true
    }
}

运行结果：

2) LocalTime

LocalTimeTest.java:

import java.time.LocalTime;

public class LocalTimeTest {
    public static void main(String[] args) {
        // 获取本地时间对象(不可变的)
        LocalTime lt = LocalTime.now();   //时 分 秒 纳秒 (不可变的)
        System.out.println(lt);

        // 1、获取时间中的信息
        int hour = lt.getHour();         //时
        int minute = lt.getMinute();    //分
        int second = lt.getSecond();     //秒
        int nano = lt.getNano();        //纳秒
        System.out.println(hour);

        // 2、修改时间:withHour、withMinute、withSecond、withNano
        LocalTime lt3 = lt.withHour(10);
        LocalTime lt4 = lt.withMinute(10);
        LocalTime lt5 = lt.withSecond(10);
        LocalTime lt6 = lt.withNano(10);
        System.out.println(lt3);

        // 3、加多少:plusHours、plusMinutes、plusSeconds、plusNanos
        LocalTime lt7 = lt.plusHours(10);
        LocalTime lt8 = lt.plusMinutes(10);
        LocalTime lt9 = lt.plusSeconds(10);
        LocalTime lt10 = lt.plusNanos(10);
        System.out.println(lt7);

        // 4、减多少:minusHours、minusMinutes、minusSeconds、minusNanos
        LocalTime lt11 = lt.minusHours(10);
        LocalTime lt12 = lt.minusMinutes(10);
        LocalTime lt13 = lt.minusSeconds(10);
        LocalTime lt14 = lt.minusNanos(10);
        System.out.println(lt11);

        // 5、获取指定时间的LocalTime对象: public static LocalTime of(int hour, int minute, int second)
        LocalTime lt15 = LocalTime.of(12,12, 12);
        LocalTime lt16 = LocalTime.of(12,12,12);

        System.out.println("---------------------");
        // 6、判断2个时间对象，是否相等、在前还是在后:equals isBefore isAfter
        System.out.println(lt15.equals(lt16));
        System.out.println(lt15.isAfter(lt));
        System.out.println(lt15.isBefore(lt));
    }
}

运行结果：

3) LocalDateTime

LocalDateTimeTest.java:

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalDateTimeTest {
    // 获取本地日期和时间对象。
    LocalDateTime ldt = LocalDateTime.now();        // 年 月 日 时 分 秒 纳秒

    // 可以把LocalDateTime转换成LocalDate和LocalTime 
    // public LocalDate toLocalDate()
    // public LocalTime toLocalTime()
    // public static LocalDateTime of(LocalDate date, LocalTime time)
    LocalDate ld = ldt.toLocalDate();
    LocalTime lt = ldt.toLocalTime();
    LocalDateTime ldt10 = LocalDateTime.of(ld, lt);
}

59 ZoneId、ZonedDateTime

ZoneId_ZonedDateTime_Test.java:

import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;

// 目标：了解时区和带时区的时间
public class ZoneId_ZonedDateTime_Test {
    public static void main(String[] args) {
        // 1、ZoneId的常见方法：
        // public static ZoneId systemDefault(): 获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId.getId());
//        System.out.println(zoneId.toString());
        System.out.println(zoneId);

        // public static Set<String> getAvailableZoneIds():获取Java支持的全部时区Id
        System.out.println(ZoneId.getAvailableZoneIds());
        
        // public static Zoneld of(String zoneId):把某个时区id封装成ZoneId对象。
        ZoneId zoneId1 = ZoneId.of("America/New_York");
        
        // 2、ZonedDateTime:带时区的时间。
        // public static ZonedDateTime now(ZoneId zone):获取某个时区的ZonedDateTime对象。
        ZonedDateTime now = ZonedDateTime.now(zoneId1);
        System.out.println(now);
        
        // 世界标准时间
        ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);

        // public static ZonedDateTime now():获取系统默认时区的ZonedDateTime对象
        ZonedDateTime now2 = ZonedDateTime.now();System.out.println(now2);
    }
}

运行结果：

60 Instant

InstantTest.java:

import java.time.Duration;
import java.time.Instant;

public class InstantTest {
    public static void main(String[] args) {
        // 1、创建Instant对象，获取此刻时间信息（总秒数 不到1秒的纳秒数）
        Instant now = Instant.now();        // 不可变对象

        // 2、获取总秒数
        long second = now.getEpochSecond();
        System.out.println(second);

        // 3、获取不够1秒的纳秒数
        int nano = now.getNano();
        System.out.println(nano);

        // 判断系列、减少时间系列、增加时间系列的方法使用方式均与之前所学过的LocalDate等一致
        Instant instant = now.plusNanos(10);
        System.out.println(instant);

        // Instant对象的作用：做代码的性能分析、或者记录用户的操作时间点
        Instant start = Instant.now();
        // 其他代码执行。。。。。。
        for (int i = 0; i < 100000; i++) {}         // 代码1
        Instant end = Instant.now();
        Duration timeElapsed = Duration.between(start, end);
        System.out.println("运行时间: " + timeElapsed.toNanos() + " 纳秒");       // 输出代码1的运行时间
    }
}

运行结果：

61 DateTimeFormatter

DateTimeFormatterTest.java:

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

public class DateTimeFormatterTest {
    public static void main(String[] args) {
        // 1、创建一个日期时间格式化器对象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 2、对所给时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        String rs = formatter.format(now);      // 正向格式化
        System.out.println(rs);

        // 3、格式化时间的另一种方案
        String rs2 = now.format(formatter);     // 反向格式化
        System.out.println(rs2);

        // 4、解析时间：解析时间一般使用LocalDateTime提供的解析方法来进行解析。
        String dateStr = "2029-12-12 12:12:12";
        LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
        System.out.println(ldt);
    }
}

运行结果：

62 Period、Duration

1) Period

PeriodTest.java:

import java.time.LocalDate;
import java.time.Period;

/*
* 目标：掌握Period的作用，计算机每个日期相差的年数、月数、天数。
* */
public class PeriodTest {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2029, 8, 15);
        LocalDate end = LocalDate.of(2029, 9, 10);

        // 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());
    }
}

运行结果：

2) Duration

DurationTest.java:

import java.time.Duration;
import java.time.LocalDateTime;

public class DurationTest {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
        LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);

        // 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.toMillis());    // 间隔多少毫秒
        System.out.println(duration.toNanos());     // 间隔多少纳秒
    }
}

运行结果：

2-4 Arrays类

63 基本使用

ArraysTest1.java:

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.function.IntToDoubleFunction;

public class ArraysTest1 {
    public static void main(String[] args) {
        // 1、public static string tostring(类型[] arr):返回数组的内容
        int[]arr = {10, 20, 30, 40, 50, 60};
        System.out.println(Arrays.toString(arr));

        // 2、public static 类型[] copyOfRange(类型[] arr，起始索引，结束索引):拷贝数组(指定范围，[…,…)包前不包后)
        int[] arr2 = Arrays.copyOfRange(arr,1,4);
        System.out.println(Arrays.toString(arr2));

        // 3、public static copyOf(类型[] arr，int newLength):拷贝数组，可以指定新数组的长度。
        int[] arr3 =Arrays.copyOf(arr,10);
        System.out.println(Arrays.toString(arr3));

        // 4、public static setAll(double[] array,IntToDoubleFunction generator):把数组中的原教数据改为新数据义存进去
        double[] prices ={99.8, 128, 100};
        // 把所有的价格都打八折，然后又存进去
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                BigDecimal p = BigDecimal.valueOf(prices[value]);
                double a = 0.8;
                BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
                return p1.doubleValue();
//                return prices[value] * 0.8;       // 可以选择用BigDecimal计算（此处不会失真可直接return）
            }
        });
        System.out.println(Arrays.toString(prices));

        // 5、public static void sort(类型[] arr):对数组进行排序(默认是升序排序)。若数组中存储的是对象则需要自定义排序规则。
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));
    }
}

运行结果：

64 自定义排序规则的方式一

Student.java:

public class Student implements Comparable<Student>{
    private String name;
    private double height;
    private int age;

    // 指定比较规则
    @Override
    public int compareTo(Student o) {
        // 约定1:认为左边对象 大于 右边对象，请您返回正整数
        // 约定2:认为左边对象 小于 右边对象，请您返回负整数
        // 约定3:认为左边对象 等于 右边对象，请您一定返回0
        // 按照年龄升序排序（此处要求返回int，而年龄数据类型刚好为int，则可以直接用加减法进行return）。
//        if (this.age > o.age){
//            return 1;
//        }else if (this.age < o.age){
//            return -1;
//        }
//        return 0;
        return this.age - o.age;    // 升序
//        return o.age - this.age;    // 降序
    }

    public Student() {
    }

    public Student(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }
}

ArraysTest2.java:

import java.util.Arrays;

// 目标：掌握如何对数组中的对象进行排序
public class ArraysTest2 {
    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精",169.6, 890);
        students[1] = new Student("紫霞",165.5, 18);
        students[2] = new Student("至尊宝",183.0, 1000);
        students[3] = new Student("兔精",158.9, 248);

        // 1、public static void sort(类型[] arr): 对数组进行排序
        Arrays.sort(students);
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
//        for (Student student : students) {
//            System.out.println(student);
//        }
    }
}

运行结果：

65 自定义排序规则的方式二

Student.java无改动，ArraysTest2.java改动如下：

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

// 目标：掌握如何对数组中的对象进行排序
public class ArraysTest2 {
    public static void main(String[] args) {
        ……
        // 1、public static void sort(类型[] arr): 对数组进行排序
        ……

        // 2、public static <T> void sort(T[] arr,Comparator<? super T> c)
        // 参数一: 需要排序的数组
        // 参数二: Comparator比较器对象(用来制定对象的比较规则)
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 约定1:认为左边对象 大于 右边对象，请您返回正整数
                // 约定2:认为左边对象 小于 右边对象，请您返回负整数
                // 约定3:认为左边对象 等于 右边对象，请您一定返回0
                // 按照身高升序排序（此处要求返回int，而身高数据类型为double，则不可以直接用加减法进行return，只能老老实实用if语句判断大小）。
//                if (o1.getHeight() > o2.getHeight()){
//                    return 1;
//                }else if (o1.getHeight() < o2.getHeight()){
//                    return -1;
//                }
//                return 0;   // 升序
                return Double.compare(o1.getHeight(), o2.getHeight());  // 升序
//                return Double.compare(o2.getHeight(), o1.getHeight());  // 降序
            }
        });
    }
}

运行结果：