时间Api使用

时间SimpleDateFormat的两个作用

1.格式化

2.解析

例如：

public class formatDate {
    public static void main(String[] args) throws ParseException {
        //格式化时间格式
        Date d1 = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
        String format = sdf1.format(d1);
        System.out.println(format);
 //解析时间
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String str = "2023年07月04日 17:15:35";
        Date parse = sdf2.parse(str);
        System.out.println(parse);
        long time = parse.getTime();
        System.out.println(time);
    }
    
    
# 日期转换

String dateStr = "2023/06/21 15:58:10";

把这个字符串转为Date

再转为字符串，要求新的字符串日期格式为：yyyy-MM-dd

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

public class Test {
    public static void main(String[] args) throws ParseException {
        /*
            String dateStr = "2023/06/21 15:58:10";
              把这个字符串转为Date

        再转为字符串，要求新的字符串日期格式为：yyyy-MM-dd
    * */

    String dateStr = "2023/06/21 15:58:10";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    Date date = sdf.parse(dateStr);

    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
    String formatDateStr = sdf1.format(date);
    System.out.println(formatDateStr);
   }
}

# 日期转为时间戳

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

public class Test02 {
    public static void main(String[] args) throws ParseException {
        String dateStr = "2012-12-21 12:34:11";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(dateStr);
        long time = d.getTime();
        System.out.println(time);
    }
}

Lambda表达式

1.参数类型可以省略不写

2.如果只有一个参数，参数类型可以省略，同时（）也可以省略

3.如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写需要同时省略

例如：

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

public class lambdaDemo {
    public static void main(String[] args) {
        String[] arr = {"a","aa","aaa","aaaa"};
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        System.out.println(Arrays.toString(arr));
        System.out.println("==========================");
        Arrays.sort(arr,(o1,o2) -> o2.length()-o1.length());
        System.out.println(Arrays.toString(arr));
    }
}

stream流

1.stream创建

public static void main(String[] args) {
    //单列集合 Collection中的默认fangf
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"a","b","c","d","e");
    list.stream().forEach(System.out::println);
    //数组  Arrays工具类中的静态方法
    int[] arr = {1,2,3,4,5};
    Arrays.stream(arr).forEach(System.out::println);
    String[] str = {"a","b","c","d","e"};
    Arrays.stream(str).forEach(System.out::println);
    //双列集合  无法直接使用需转换Set
    HashMap<String, Integer> map = new HashMap<>();
    map.put("aaa",111);
    map.put("bbb",222);
    map.put("ccc",333);
    map.put("ddd",444);
    Set<String> strings = map.keySet();
    strings.stream().forEach(System.out::println);
    Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
    entrySet.stream().forEach(System.out::println);
    //零散数据 Stream接口中的静态方法
    //注意：方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组
    //但是数组必须是引用数据的，如果传递基本数据类型是会把整个数组当成一个元素放入到Stream当中
    Stream.of(1,3,4,5,2).forEach(System.out::println);
}

2.stream中间方法

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();

    Collections.addAll(list,"张三","李四","王五","赵四","张三","李四");
    //distianct去重
     list.stream().distinct().forEach(System.out::println);
    //startWith找姓张
    list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
    //跳过几个元素
    list.stream().skip(3).forEach(System.out::println);
    //获得前几个元素
    list.stream().limit(3).forEach(System.out::println);
    //只获取数值map
    ArrayList<String> list1 = new ArrayList<>();
    Collections.addAll(list1,"张三-1","李四-2","王五-3","赵四-4","张三-5","李四-6");
    for (String s : list1) {
        String[] split = s.split("-");
        String s1 = split[1];
        System.out.println(s1);
    }
      list.stream().map(new Function<String, Integer>() {
                @Override
                public Integer apply(String s) {
                    String[] split1 = s.split("-");
                    String s2 = split1[1];
                    int age = Integer.parseInt(s2);
                    return age;
                }
            }).forEach(s2 -> System.out.println(s2));
            list.stream().map(s3 -> Integer.parseInt(s.split("-")[1])).forEach(s3 -> System.out.println(s3));
    //合并通过Stream的静态方法concat
    Stream.concat(list.stream(),list1.stream()).forEach(System.out::println);
}

3.stream的终结方法

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张三","李四","王五","赵四","张三","李四");
    //count统计集合中的个数
    long count = list.stream().count();
    System.out.println(count);
    //forEach打印
    list.stream().forEach(System.out::println);
    //toArray
    String[] arr = list.stream().toArray(new IntFunction<String[]>() {
        @Override
        public String[] apply(int value) {
            return list.toArray(new String[value]);
        }
    });
    System.out.println(Arrays.toString(arr));
    String[] arr2 = list.stream().toArray(value -> list.toArray(new String[value]));
    System.out.println(Arrays.toString(arr2));
}