526互联

Java第十三课_常用时间类和集合

发布时间 2023-12-22 23:23:12作者: 张心野

1.常用时间类

  • Calendar类

        public static void main(String[] args) {
        // JDK1.1开始
        // Calendar类是一个抽象类，
        // 它提供了在特定时刻和一组日历字段（如YEAR、MONTH、DAY_of_MONTH、HOUR等）之间进行转换的方法，以及操作日历字段（例如获取下一周的日期）的方法。时间的瞬间可以用毫秒值表示，毫秒值是从1970年1月1日00:00:00.000 GMT（格里高利）开始的偏移量。
        Calendar c1 = new GregorianCalendar();
        System.out.println("c1 = " + c1);
        Calendar c2 = Calendar.getInstance();
        System.out.println("c2 = " + c2);

        // 获取   int	get​(int field)
        int year = c1.get(Calendar.YEAR);
        System.out.println("year = " + year);
        int month = c1.get(Calendar.MONTH);
        System.out.println("month = " + month);
        // 查表法
        String[] months = {"一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"};
        System.out.println(months[c1.get(Calendar.MONTH)]);
        int day = c1.get(Calendar.DATE);
        System.out.println("day = " + day);

        int week = c1.get(Calendar.DAY_OF_WEEK);
        System.out.println("week = " + week);
        String[] weeks = {"", "日", "一", "二", "三", "四", "五", "六"};
        System.out.println(weeks[c1.get(Calendar.DAY_OF_WEEK)]);

        // 设置 :
        // void	set​(int field, int value)
        c1.set(Calendar.YEAR, 2024);
        year = c1.get(Calendar.YEAR);
        System.out.println("year = " + year);

        c1.set(Calendar.MONTH, 7);// 偏移量
        System.out.println(months[c1.get(Calendar.MONTH)]);

        // void	set​(int year, int month, int date)
        c1.set(2008, Calendar.AUGUST, 8);
        System.out.println(months[c1.get(Calendar.MONTH)]);

        // void	set​(int year, int month, int date, int hourOfDay, int minute)
        // void	set​(int year, int month, int date, int hourOfDay, int minute, int second)
        c2.set(2008, Calendar.AUGUST, 8);
        System.out.println(c1.equals(c2));

        // void	clear()	清除所有字段
        c1.clear();
        c2.clear();
        System.out.println("c1 = " + c1);
        c1.set(2008, Calendar.AUGUST, 8);
        c2.set(2008, Calendar.AUGUST, 8);
        System.out.println(c1.equals(c2));

        // void	clear​(int field) 清除指定字段
        System.out.println("c1 = " + c1);
        c1.clear(Calendar.YEAR);
        System.out.println("c1 = " + c1);

        // void	add​(int field, int amount) : 在现有时间的基础上向前向后延伸时间
        c2.add(Calendar.YEAR, -1000);
        System.out.println(c2.get(Calendar.YEAR));

        // boolean	after​(Object when)
        // boolean	before​(Object when)
        // 计算二月份有几天  2024年
        Calendar calendar = new GregorianCalendar();
        calendar.set(2023, Calendar.MARCH, 1);
        calendar.add(Calendar.DATE, -1);
        System.out.println(calendar.get(Calendar.DATE));

        // Date ---> Calendar
        c1.setTime(new Date());

        // Calendar --->  Date
        Date time = c1.getTime();
    }

  • java.time

        public static void main(String[] args) {
        /*
            1. JDK1.0 java.util.Date
                缺陷 : 偏移量
            2. JDK1.1 java.util.Calendar 线程不安全
                缺陷 :
                    a.偏移量
                    b.可变性,线程不安全的
                    c.格式化 : java.text.DateFormat 只适用于 Date , 不能用于 Calendar
            3. JDK8.0  java.time : 时间包
         */
        // LocalDate : 只有年月日
        // LocalTime : 只有时分秒毫秒
        // LocalDateTime : 年月日时分秒毫秒
        // now()
        LocalDate localDate = LocalDate.now();
        System.out.println("localDate = " + localDate);
        LocalTime localTime = LocalTime.now();
        System.out.println("localTime = " + localTime);
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("localDateTime = " + localDateTime);

        // of() 设置
        LocalDateTime localDateTime1 = LocalDateTime.of(2008, 8, 8, 8, 8);
        System.out.println("localDateTime1 = " + localDateTime1);
        System.out.println("localDateTime = " + localDateTime);
        LocalDate localDate1 = LocalDate.of(2008, 8, 8);
        System.out.println("localDate1 = " + localDate1);
        // 获取 get
        int year = localDateTime1.getYear();
        System.out.println("year = " + year);
        System.out.println(localDateTime1.getMonth());
        System.out.println("localDateTime1.getDayOfMonth() = " + localDateTime1.getDayOfMonth());
        System.out.println(localDateTime1.getMinute());

        // 设置  with
        System.out.println(LocalDateTime.now().withYear(2030).getYear());
        System.out.println(LocalDateTime.now().withMonth(9).getMonth());
    }

  • 时间的格式化

        public static void main(String[] args) {
        // 格式化 : DateTimeFormatter
        // DateTimeFormatter
        // 1.预定义标准 :
        // ISO_DATE_TIME : 2023-12-19T10:18:46.27
        // ISO_DATE : 2023-12-19
        // ISO_TIME : 10:19:49.405
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_TIME;
        // LocalDateTime ---> String
        String format = dateTimeFormatter.format(LocalDateTime.now());
        System.out.println("format = " + format);

        // String ---> LocalDateTime
        TemporalAccessor parse = dateTimeFormatter.parse("10:19:49.405");
        System.out.println("parse = " + parse);

        LocalTime parse1 = LocalTime.parse("10:19:49.405", dateTimeFormatter);
        System.out.println("parse1 = " + parse1);

        LocalDateTime localDateTime = LocalDateTime.parse("2023-12-19T10:18:46.27");
        System.out.println("localDateTime = " + localDateTime);
        localDateTime = LocalDateTime.parse("2023-12-19T10:18:46.27", DateTimeFormatter.ISO_DATE_TIME);
        System.out.println("localDateTime = " + localDateTime);

        // 2.本地相关 : FormatStyle
        // LONG :2023年12月19日 上午10时22分59秒
        // MEDIUM : 2023-12-19 10:23:17
        // SHORT : 23-12-19 上午10:23
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        String format1 = dateTimeFormatter1.format(LocalDateTime.now());
        System.out.println("format1 = " + format1);

        TemporalAccessor parse3 = dateTimeFormatter1.parse("23-12-19 上午10:23");
        System.out.println("parse3 = " + parse3);

        LocalDateTime parse2 = LocalDateTime.parse("23-12-19 上午10:28", DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT));
        System.out.println("parse2 = " + parse2);
        // 3.自定义 : 常用
        DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy/MM/dd kk:mm:ss SSS");
        String format2 = dateTimeFormatter2.format(LocalDateTime.now());
        System.out.println("format2 = " + format2);

        Instant now = Instant.now();
        System.out.println("now = " + now);

        Clock clock = Clock.systemDefaultZone();
        System.out.println("clock = " + clock);

        ZoneId zone = clock.getZone();
        System.out.println("zone = " + zone);
    }

2.集合

  • 集合Collection

        public static void main(String[] args) {
        /*
            算法 ：解题的流程
                1.可以解决具体的问题
                    1 + 2 +3 +4 + ... + 100

                2.设计解决问题的流程
                    a.
                        1+2 = 3
                        3 +3 =6
                        6+4=10

                    b.
                        1+100
                        2+99
                        3+98
                        4+97
                        ...
                3.评价指标
                    时间复杂度
                    空间复杂度

            数据结构 ：
                1.逻辑结构 ：
                    认知结构、思想上的结构
                    厨房 ， 客厅 ...
                    线性表 ， 图 ， 栈 ，队列
                2.物理结构 ：
                    真实结构
                    钢筋水泥 + 力学
                    紧密结构（顺序结构）
                    跳转结构 （链式结构）

                线性表 ：相同类型数据的有序序列  a1 a2  a3 ... an  an+1
                    1.相同的数据类型
                    2.序列、顺序性
                    3.有限

            紧密结构 ：
                优点 ： 查询块
                缺点 ： 增删慢

            链式结构、跳转结构 ： 1.单项链表  2. 双向链表  3.环式链表
                优点 ：增删快
                缺点 ：查询效率低
         */

        /*
            数组 ：
                1.增删元素麻烦 ： 需要字节编写函数
                2.长度是固定的 ：
                3.结构单一

            集合 ：内存存储
                1.有增删改查的功能
                2.长度会自增
                3.数据结构较多 ， 可以满足多种需求

            数据库 ： 持久存储
         */
        // Collection 表示一组对象，这些对象也称为 collection 的元素。
        //  | List :
        //      | ArrayList :
        //      | Vector :
        //      | LinkedList :
        //  | Set :
        //      | HashSet :
        //      | TreeSet :
        // 注意 : 集合中的 contains 函数  , remove 函数 以及 indexOf , lastIndexOf 函数会根据集合中的元素的equals函数进行判断

        Collection<Object> collection = new ArrayList<>();
        // 增
        // boolean add(E e)
        //           确保此 collection 包含指定的元素（可选操作）。
        collection.add(123);// Integer
        collection.add("aaa");
        collection.add(3.14);// Double
        collection.add(true);// Boolean
        collection.add('Y');// Character
        Object o = new Object();
        collection.add(o);
        System.out.println(collection);//等同于.toString()

        // 删
        //  boolean remove(Object o)
        //           从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
        collection.remove(true);
        collection.remove("aaa");
        collection.remove(o);
        System.out.println("collection = " + collection);
        // void clear()
        //           移除此 collection 中的所有元素（可选操作）。
        collection.clear();
        System.out.println("collection = " + collection);

        // 查
        //  int size()
        //           返回此 collection 中的元素数。
        collection.clear();
        System.out.println("collection.size() = " + collection.size());

        // 判断
        //  boolean contains(Object o)
        //           如果此 collection 包含指定的元素，则返回 true。
        System.out.println("collection.contains(123) = " + collection.contains(123));
        //  boolean isEmpty()
        //           如果此 collection 不包含元素，则返回 true。
        System.out.println("collection.isEmpty() = " + collection.isEmpty());

        // 集合  ---> 数组
        //  Object[] toArray()
        //           返回包含此 collection 中所有元素的数组。
        //  <T> T[] toArray(T[] a)
        //           返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
    }

  • 迭代器Iterator

        public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(123);// Integer
        collection.add("aaa");
        collection.add(3.14);// Double
        collection.add(true);// Boolean
        collection.add('Y');// Character

        //  Iterator<E> iterator()
        //           返回在此 collection 的元素上进行迭代的迭代器。

        // 开发不会使用 while 循环
        Iterator iterator = collection.iterator();

        while (iterator.hasNext()) {// iterator.hasNext() 判断当前指针是否有数据. 判断后不会主动向后找, 需要配合.next()移动指针
            Object o = iterator.next();// 每调用一次 next() 函数就会得到一个新的元素,如果没有元素,就会 NoSuchElementException
            System.out.println("o = " + o);
        }
        System.out.println("----------------------------------------");
        // 开发常用方式一 : for 循环
        for (Iterator iterator1 = collection.iterator(); iterator1.hasNext(); ) {
            Object o = iterator1.next();
            System.out.println("o = " + o);
        }

        // 方式二 : 增强for循环
        for (Object object : collection) {
            System.out.println("object = " + object);
        }

        // 方式三 : JDK8.0开始 : Stream
        collection.forEach(System.out::println);

        // 方式四 : JDK8.0
        collection.stream().forEach(System.out::println);

        // 方式四 : JDK8.0
        collection.stream().forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println("o = " + o);
            }
        });
    }

  • 泛型

        public static void main(String[] args) {
        // JDK5.0 泛型 : <数据类型>
        // 将集合的类型限定为某个类型, 编译时期有效
        // 优势:
        //      1.将运行时异常转换为编译时错误
        //      2.可以避免类型转换
        Collection<String> collection1 = new ArrayList<>();
        Collection<String> collection2 = new ArrayList<>();

        collection1.add("aaa");
        collection1.add("bbb");
        collection1.add("ccc");
        collection1.add("ddd");
        for (Iterator<String> iterator = collection1.iterator(); iterator.hasNext(); ) {
            // Object o = iterator.next();
            // String s = (String) o;
            String s = iterator.next();// 泛型后可以直接使用对应类, 来接收集合的数据, 无需强制类型转换
            System.out.println("s.length() = " + s.length());
        }

        collection2.add("ccc");
        collection2.add("ddd");
        collection2.add("eee");
        collection2.add("fff");

        //  boolean addAll(Collection<? extends E> c)  并集
        //           将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
        // collection1.addAll(collection2);

        //  boolean containsAll(Collection<?> c)
        //           如果此 collection 包含指定 collection 中的所有元素，则返回 true。
        System.out.println(collection1.containsAll(collection2));
        //  boolean removeAll(Collection<?> c) 差集
        //           移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
        // collection1.removeAll(collection2);

        System.out.println("collection1 = " + collection1);
        System.out.println("collection2 = " + collection2);

        //  boolean retainAll(Collection<?> c) 交集
        //           仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
        collection1.retainAll(collection2);

        System.out.println("collection1 = " + collection1);
        System.out.println("collection2 = " + collection2);
    }