Java基础day17 —— 调用 日期及数组的方法使用

1.日期方法

1.Date

获取当前的日期时间 和对应毫秒数

public class DateTest {
    /*
        Date
     */
    @Test
    public void test(){

        /*
            包是： java.util.Date
         */
        Date date = new Date();//获取当前的日期时间
        System.out.println(date);

        //获取当前时间所对应的毫秒数
        long time = date.getTime();//毫秒数 - 1712888846161   Fri Apr 12 10:27:26 CST 2024
        System.out.println(time);


        Date date2 = new Date(1712888846161L);//获取的是毫秒数所对应的日期时间
        System.out.println(date2);
    }

    /*
        SimpleDateFormat : 对日期时间进行格式化（格式化成我们想要的日期时间格式）
     */
    @Test
    public void test2() throws ParseException {
        //构造器传日期时间格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //将日期时间转成字符串（按照指定格式）
        String format = sdf.format(new Date());
        System.out.println(format);

        //2024-04-12 10:34:06
        //将字符串转成Date类型
        //注意：字符串的日期时间格式一定要和格造器中指定的格式匹配
        Date date = sdf.parse("2024-04-12 10:34:06");
        System.out.println(date);
    }
}

2.LocalDate 、LocalTime、 LocalDateTime

package com.atguigu.java;

import org.junit.Test;

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

/*
    LocalDate : 日期
    LocalTime ： 时间
    LocalDateTime ：日期时间
 */
public class LocalDateTimeTest {
    @Test
    public void test(){

        LocalDate dateNow = LocalDate.now(); //当前日期
        LocalTime timeNow = LocalTime.now(); //当前时间
        LocalDateTime dateTimeNow = LocalDateTime.now();//当前日期时间

        System.out.println(dateNow);
        System.out.println(timeNow);
        System.out.println(dateTimeNow);


        System.out.println("===============================================");

        //创建指定的日期对象
        LocalDate dateOf = LocalDate.of(2022, 10, 10);
        System.out.println(dateOf);

        //创建指定的时间对象
        LocalTime timeOf = LocalTime.of(12, 10, 10, 200);
        System.out.println(timeOf);

    }

    @Test
    public void test2(){

        LocalDateTime now = LocalDateTime.now();

        //当月的第几天
        int dayOfMonth = now.getDayOfMonth();
        //获取当前月份
        Month month = now.getMonth();

        System.out.println(dayOfMonth);
        System.out.println(month);

        System.out.println("------------------------------------");

        //在当前日期加1天 --- 不会修改原日期时间（获取一个新的日期时间）
        LocalDateTime localDateTime = now.plusDays(1);
        System.out.println(localDateTime);

        //在当前日期加2天 --- 不会修改原日期时间（获取一个新的日期时间）
        LocalDateTime localDateTime1 = now.plusDays(2);
        System.out.println(localDateTime1);

    }

    @Test
    public void test3(){
        /*
        | isBefore()/isAfter() | 比较两个 LocalDate |
        isLeapYear()       | 判断是否是闰年（在LocalDate类中声明） |
         */
        LocalDate now = LocalDate.now();
        System.out.println(now.getYear() + " : " + (now.isLeapYear()? "是闰年" : "是平年"));

        System.out.println("------------------------------------");

        LocalDate of1 = LocalDate.of(2022, 10, 3);
        LocalDate of2 = LocalDate.of(2021, 8, 9);

        System.out.println(of1.isAfter(of2));

    }
}

3.SimpleDateFormat和DateTimeFormatter

package com.atguigu.java;

import org.junit.Test;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

/*
 DateTimeFormatter : 对日期时间进行格式化 - 格式化可以得到我们想要的格式
 */
public class DateTimeFormatterTest {

    @Test
    public void test(){
        //获取当前的日期时间
        LocalDateTime now = LocalDateTime.now();

        //第一种转换方式
        DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE;
        String s = dtf.format(now);//对日期时间进行格式化
        System.out.println(s);


        System.out.println("==================================");
        //第二种转换方式
        DateTimeFormatter dtf2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        String s2 = dtf2.format(now);//对日期时间进行格式化
        System.out.println(s2);


        System.out.println("==================================");
        //第三种转换方式 ：自定义
        DateTimeFormatter dtf3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //将日期时间转成字符串
        String s3 = dtf3.format(now);
        //将字符串转成日期时间
        TemporalAccessor parse = dtf3.parse("2024-04-12 14:58:58");
        System.out.println(s3);
    }
}

2. 数组的工具代码

1.工具类

package com.atguigu.java2;

import org.junit.Test;

import java.util.Arrays;

/*
    数组的工具类 : Arrays
 */
public class ArraysTest {

    /*
        toString ：将数组中的元素拼接成一个字符串
     */
    @Test
    public void test(){
        int[] ns = {1,2,3,4,5};
        //将数组中的元素拼接成一个字符串
        String s = Arrays.toString(ns);
        System.out.println(s);
    }
    /*
        sort : 对数组中的元素排序
     */
    @Test
    public void test2(){
        int[] ns = {5,2,1,3,9};
        // 对数组中的元素排序 : 因为是引用数类型所以不需要返回值
        Arrays.sort(ns);

        System.out.println(Arrays.toString(ns));
    }
    @Test
    public void test22(){
        int[] ns = {5,2,1,3,9,4,8,6};
        //static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
        //注意：不包括 toIndex
        Arrays.sort(ns,0,3);
        System.out.println(Arrays.toString(ns));
    }

    /*
    数组元素的二分查找
        static int binarySearch(int[] a, int key)
    注意：前提是必须有序
     */
    @Test
    public void test3(){
        int[] ns = {5,2,1,3,9,4,8,6,7};
        //排序
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
        //查找 - 查找的结果是排完序后的位置。如果找不到返回负数
        System.out.println(Arrays.binarySearch(ns,4));
    }

    /*
     * static int[] copyOf(int[] original, int newLength)  ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
     *
     * //下面的是一个泛型方法 --  后面讲(在这理解成T是任意类型--但不是基本数据类型)
     * static <T> T[] copyOf(T[] original,int newLength)：根据original原数组复制一个长度为newLength的新数组，并返回新数组
     *
     */
    @Test
    public void test4(){
        int[] ns = {1,2,3};
        //扩容 - ①创建新数组 ②将原数组中的内容copy到新数组中
        int[] newArray = Arrays.copyOf(ns, 6);

        System.out.println(Arrays.toString(newArray));

        System.out.println("==========================================");

        String[] d = {"aa","bbb"};
        Arrays.copyOf(d,20);
    }
    /*
     * static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
     *      注意：不包括to的位置
     * static <T> T[] copyOfRange(T[] original,int from,int to)：复制original原数组的[from,to)构成新数组，并返回新数组
     */
    @Test
    public void test5(){
        int[] ns = {5,2,1,3,9,4,8,6,7};
        int[] newNs = Arrays.copyOfRange(ns, 0, 3);
        System.out.println(Arrays.toString(newNs));
    }

    /*
     * static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
     *      比较的是内容（内容个数，内容本身）
     * static boolean equals(Object[] a,Object[] a2)：比较两个数组的长度、元素是否完全相同
     */
    @Test
    public void test6(){
        int[] ns = {5,2,1,3,9,4,8,6};
        int[] ns2 = {5,2,1,3,9,4,8,5};

        System.out.println(Arrays.equals(ns,ns2));
    }
    /*
     * static void fill(int[] a, int val) ：用val值填充整个a数组
     * static void fill(Object[] a,Object val)：用val对象填充整个a数组
     * static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val值
     * static void fill(Object[] a, int fromIndex, int toIndex, Object val) ：将a数组[fromIndex,toIndex)部分填充为val对象
     */
    @Test
    public void test7(){
        int[] ns = {5,2,1,3,9,4,8,6};
        Arrays.fill(ns,100);

        System.out.println(Arrays.toString(ns));
    }
}

2.数组的插入和删除

package com.atguigu.java2;

import org.junit.Test;

import java.util.Arrays;

/*
 static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：
    src: 源数组 （从源数组copy数组）
    srcPos: 源数组copy的位置
    dest: 目标数组（将源数组中的内容copy到目标数组中）
    destPos: 目标数组copy到的位置
    length: copy的内容的长度
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。常用于数组的插入和删除
 */
public class SystemArrayTest {
    @Test
    public void test(){
         int[] ns = {1,2,3,4,5,6};
         int[] newNs = new int[10];
        System.arraycopy(ns,2,newNs,2,3);

        System.out.println(Arrays.toString(newNs));
    }
}

3.练习

package com.atguigu.java2;

import java.util.Arrays;

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

        ShoppingCart sc = ShoppingCart.getInstance();
        sc.put("红米k70");
        sc.put("小米su7");
        sc.put("问界M9");
        sc.put("华为P70");
        sc.put("比亚迪汉");

        ShoppingCart sc2 = ShoppingCart.getInstance();
        sc2.delete(2);

        ShoppingCart sc3 = ShoppingCart.getInstance();
        sc3.update(1,"龙哥150");

        sc3.show();
    }
}

class ShoppingCart{

    //容器 ：装产品-String[]
    private String[] cart = new String[3];
    private int i = 0;


    private ShoppingCart(){}

    private final static ShoppingCart sc = new ShoppingCart();

    public static ShoppingCart getInstance(){
        return sc;
    }

    public void put(String sku){
        //判断数组是否放满了
        if (i >= cart.length){
            //数组满了 - 扩容
            /*
                做了三件事
                1.创建新数组长度为 ：数组原来的长度 * 2
                2.将原来数组中的内容copy到新数组
                3.将新数组赋值给原数组的引用
             */
            cart = Arrays.copyOf(cart,cart.length * 2);
        }
        //放数组 - 考虑数组满了的问题
        cart[i] = sku;
        i++;
    }

    public void delete(int index){
        //校验index位置是否有商品
        if (index >=0 && index < i) {
            //是否删除的是最后一个商品
            if (index == i - 1){
                //将最后一个位置变为null
                cart[i - 1] = null;
            }else {
                //从数组中删除商品
                System.arraycopy(cart, index + 1, cart, index, i - index - 1);
                //将最后一个位置变为null
                cart[i - 1] = null;
            }
            i--;//商品的数量要减1
        }else{//index不在合理范围
            throw new TheIndexIsOutsideOfReasonableLimitsException("没有该商品");
        }
    }

    public void update(int index,String sku){
        //校验index位置是否有商品
        if (index >=0 && index < i) {
            //更换商品
            cart[index] = sku;
        }else{
            throw new TheIndexIsOutsideOfReasonableLimitsException("没有该商品");
        }
    }

    public void show(){
        if (i == 0) {
            System.out.println("没有商品");
        }else {
            //输出所有商品
            for (int j = 0; j < i; j++) {
                System.out.println(cart[j]);
            }
        }
    }

}

4.数组元素的比较

package com.atguigu.java3;

import java.util.Arrays;

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

        Book[] books = new Book[4];
        books[0] = new Book("《如何让富婆爱上我》",100,20);
        books[1] = new Book("《我的霸道总裁》",80,13);
        books[2] = new Book("《消失的新娘》",90,23);
        books[3] = new Book("《我的100个女朋友》",135,21);


        compare(books);


        System.out.println(Arrays.toString(books));

    }

    public static void compare(Book[] books){
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j < books.length - i - 1; j++) {
                if (books[j].compareTo(books[j + 1]) > 0){
                    Book temp = books[j];
                    books[j] = books[j+1];
                    books[j+1] = temp;
                }
            }
        }
    }
}

/*
    自然排序 ： Comparable

    好处 ：  排序的算法不用修改。
            想要对某个对象进行排序只需要让那个对象所属的类实现Comparable接口并重写compareTo方法
            在compareTo方法去实现排序的方式（按照某个属性排序）即可
 */
class Book implements Comparable{
    String name;
    int price;

    //每本书都有人签名 - 可以签很多
    int number;


    public Book(String name, int price,int number) {
        this.name = name;
        this.price = price;
        this.number = number;
    }

    @Override
    public String toString() {
        return name + " " + price + " " + number;
    }

    /*
        比较内容

        返回值：
            正数： 当前对象的价格 大于 传进来的对象的价格
            负数：当前对象的价格 小于 传进来的对象的价格
            0 ：当前对象的价格 等于 传进来的对象的价格
     */
    @Override
    public int compareTo(Object o) {
        if (!(o instanceof Book) || o == null){
            throw new RuntimeException("类型不匹配");
        }

        //向下转型
        Book b = (Book) o;

        return this.price - b.price;
//        return this.number - b.number;
    }
}

5.自然排序

package com.atguigu.java4;

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

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

        Book[] books = new Book[4];
        books[0] = new Book("《如何让富婆爱上我》",100,20);
        books[1] = new Book("《我的霸道总裁》",80,13);
        books[2] = new Book("《消失的新娘》",90,23);
        books[3] = new Book("《我的100个女朋友》",135,21);


        /*
        compare(books, new Comparator() { //创建匿名内部类的对象
            @Override
            public int compare(Object o1, Object o2) {
                if (!(o1 instanceof Book) || !(o2 instanceof Book)){
                    throw new RuntimeException("类型不对");
                }
                //向下转型
                Book b1 = (Book) o1;
                Book b2 = (Book) o2;
                return b1.price - b2.price;//按照价格排序
            }
        });

         */

        compare(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //向下转型
                Book b1 = (Book) o1;
                Book b2 = (Book) o2;
                return b1.number - b2.number;//按照签名数量排序
            }
        });

        System.out.println(Arrays.toString(books));
    }

    /*
         public interface Comparator<T> {
            int compare(T o1, T o2);
         }
     */
    //将Comparator接口实现类的对象赋值给Comparator接口  多态
    public static void compare(Book[] books, Comparator c){
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j < books.length - i - 1; j++) {
                //compare方法调用的是接口的实现类中实现该接口的方法
                if (c.compare(books[j],books[j+1]) > 0){
                    Book temp = books[j];
                    books[j] = books[j+1];
                    books[j+1] = temp;
                }
            }
        }
    }
}

class Book{
    String name;
    int price;

    //每本书都有人签名 - 可以签很多
    int number;


    public Book(String name, int price,int number) {
        this.name = name;
        this.price = price;
        this.number = number;
    }

    @Override
    public String toString() {
        return name + " " + price + " " + number;
    }

}