小知识点01

本文深入探讨了Java中的Lambda表达式及其使用前提,并详细讲解了Stream API的各种操作方法,包括生成方式、中间操作及终结操作等。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.Lambda

1.1函数式编程思想概述

参数,箭头(->)以及一个表达式{代码块}

Lambda表达式的使用前提

  1. 一个接口
  2. 接口中有且仅有一个抽象方法
//创建接口抽象方法没有参数
public interface Eatable {
     void eat();
}
    public static void main(String[] args) {
        //在主方法中调用 useEatable方法
        Eatable e = new EatableImpl();
       useEatable(e);
        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果医生远离我");
            }
        });
        //使用lambda表达式
        useEatable(() ->{
            System.out.println("天天吃苹果");
        });
    }
    private static void useEatable(Eatable e){
        e.eat();
    }
    
//创建接口抽象方法有参数
public interface Flyable {
    void  fly(String s);
}
    public static void main(String[] args) {

        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("我能开飞机");
            }
        });
        //使用lambda表达式
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("we can fly");
        });
    }
    private static void useFlyable(Flyable f){
        f.fly("我可以飞");
    }

面向对象的思想:必须通过对象的形式来做事情

函数式思想:强调做什么,而不是以什么形式去做

*  * Lambad表达式的标准格式
*  *  由三部分组成
*  *      1.一线参数
*  *      2.一个箭头
*  *      3.一段代码
*  *      格式:
*  *          (参数列表) -> {一些重写的方法的代码}
*  *       解释说明格式
*  *       ():接口中抽象方法的参数列表,没有参数,就空着,有参数就写出参数,多个参数就使用逗号分开
*  *       ->:传递的意思,把参数传递给方法体{}
*  *       {}:重写接口的抽象方法的方法体
 * lambda表达式 可推到可以省略
 * 凡是根据上下文推到出来的内容,都可以省略书写
 * 可以省略的内容
 *      1.(参数列表):括号中的参数列表的数据类型,可以省略不写
 *      2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
 *      3.(一些代码):如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
 *              注意:要省略({},return,分号),必须一起省略
 *
 *
 * 使用Lambda的使用前提
 *  必须有接口,接口中仅有一个抽象方法

即使是lambda表达式没有参数的时候,也需要提供括号,就像无参函数方法一样

() -> {for ( int i =100; i>=0;i–) System.out.println(i);}

无序知道lambda表达式的返回类型

Lambda表达式的注意事项

  1. 使用lambda必须要有接口,并且要求接口中有且仅有一个抽象方法
  2. 必须有上下文环境, 才能推导出lambda对应的接口
    1. 根据局部变量的赋值得知lambda对应的接口 : Runnable r = () ->System.out.printin(“Lambda表达式”);
    2. 根据调用方法的参数 得知lambda对应的接口 new Thread(() ->System.out.printin(“Lambda表达式”) ).start();

2.日期类

2.1 date

Date代表了一个特定的时间,精确到毫秒

// public Date()  分配了一个Date对象, 并将其初始化,表示从标准时间到now()的毫秒数

//public Date(long date) 分配了一个Date对象,并且将其初始化 从标准时间到指定时间的毫秒数

//常用方法
//getTime 获取日期对象从1970年1月1日 00:00:00 到现在毫秒数 

//setTime(long time) 设置 时间, 给的是毫秒值

2.2 SimpleDateFormat

用于设置敏感的方法格式化和解析日期

在这里插入图片描述

2.2.1格式化(从Date到String)

public void String format(Date date) 将日期格式化成为日期/时间字符串

在这里插入图片描述

2.2.2解析(从Sring到Date)

public Date parse(String source): 从定字符串的开始解析文本生成日期

在这里插入图片描述

2.2.3日期工具类

1.定义日期工具类(DateUtils)

2.定义一个方法dateToString , 用于把日期转换为 指定格式的字符串

1.  返回值类型 Stirng
	2.  参数 Date date , String format

3.定义一个方法stringToDate , 用于把字符串解析为 指定的日期格式

1. 返回值类型 Date
	2. 参数 String s ,String  format   

在这里插入图片描述

4.定义测试类DateDemo, 调用日期工具类中的方法

在这里插入图片描述

3.Calendar类

Calender为某一时刻和一组日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法

Calender 提供了 getInstance 用于获取Calender对象,其日期字段已使用当前日期和时间初始化

在这里插入图片描述

        //public int get(int field)
//        int year = instance.get(Calendar.YEAR);
//        int month = instance.get(Calendar.MONTH) + 1;
//        int day = instance.get(Calendar.DATE);
//        System.out.println(year+"年"+month+"月"+day+"日");


        // public abstract void add(int field,int amout); 根据日历的规则 将指定的时间量添加或减去给定的日历字段
        //需求 1.3年前的今天
//        instance.add(Calendar.YEAR,-3);
//        int year = instance.get(Calendar.YEAR);
//        int month = instance.get(Calendar.MONTH) + 1;
//        int day = instance.get(Calendar.DATE);
//        System.out.println(year+"年"+month+"月"+day+"日");

        //需求2. 10年后的5天前
//        instance.add(Calendar.YEAR,10);
//        instance.add(Calendar.DATE,-5);
//        int year = instance.get(Calendar.YEAR);
//        int month = instance.get(Calendar.MONTH) + 1;
//        int day = instance.get(Calendar.DATE);
//        System.out.println(year+"年"+month+"月"+day+"日");

        // public final void set (int year , int month , int date) 设置当前日历的年月日
        instance.set(2020,5,1);
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH) + 1;
        int day = instance.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+day+"日");

二月天

  1. 键盘录入任意的年份
  2. 设置日历对象的年,月,日
    1. 年 键盘录入
    2. 月 设置为3月 月份是从0开始的 所以设置的值是2
    3. 日 设置的为1日
  3. 3月1日往前推一天就是2月的最后一天
  4. 取出这一天
    在这里插入图片描述

4.Stream流

Stream流的生成方式

1.Collection体系的集合可以使用默认的方法Stream()生成流

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();

Set<String> set = new HashSet<>();
Stream<String> stream1 = set.stream();

2.Map体系的集合间接生成流

Map<String,Integer> map = new HashMap<>();
Stream<String> stream2 = map.keySet().stream();

Stream<Integer> stream3 = map.values().stream();
Stream<Map.Entry<String, Integer>> stream4 = map.entrySet().stream();

3.数组可以通过Stream接口的静态方法of(T…values) 生成流

String[] strarray = {"hello","world"};
Stream<String> strarray1 = Stream.of(strarray);
Stream<String> hello = Stream.of("hello", "world");
Stream<Integer> integerStream = Stream.of(10, 20, 30);

filter :用于对流中的数据进行过滤

//创建一个集合
ArrayList<String> List = new ArrayList<>();
List.add("林青霞");
List.add("张曼玉");
List.add("王祖贤");
List.add("柳岩");
List.add("张敏");
List.add("张无忌");
//需求1: 把list集合以开头的在控制台中输出
List.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
//需求2:把集合中长度为3的元素在控制台中输出
List.stream().filter(s -> s.length() == 3).forEach(System.out::println);
//需求3: 把集合中以张开头的而且长度为3的元素在控制台中输出
List.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3 ).forEach(System.out::println);

limit: 返回此流中的元素组成的流,截取前指定参数个数的元素

//需求1: 取前三个数据在控制台中输出
List.stream().limit(3).forEach(System.out::println);

skip跳过 指定参数个数的数据,返回由该流的剩余元素组成的流

//需求2:跳过上元素,把剩下的元素在控制台中输出
List.stream().skip(3).forEach(System.out::println);

concat(Stream a , Stream b): 合并a和b两个流为同一个流

//取前四个数据组成一个流
Stream<String> s1 = List.stream().limit(4);

//跳过两个元素组成一个流
Stream<String> s2 = List.stream().skip(2);

//合并两个流
//Stream.concat(s1,s2).forEach(System.out::println);

distinct() 去重

//合并两个流,在控制台中输出,去重
Stream.concat(s1,s2).distinct().forEach(System.out::println);

sorted() 返回由此流的元素组成的流,根据自然顺序排序

//        //需求1 :  按照字母顺序把数据在控制台中输出
//        list.stream().sorted().forEach(System.out::println);

sorted(Comparator comparator) 返回由此流的元素组成的流,根据提供的Comparator进行排序

//需求2: 按照字符串长度把数据在控制台中输出
        list.stream().sorted((s1,s2) ->{
            int num = s1.length() -s2.length();
            int num2 = num==0? s1.compareTo(s2) :num;
            return num2;
        }).forEach(System.out::println);

map 返回由给定函数应用与此流元素的结果组成的流

mapToInt 返回一个IntStream其中包含将给定函数应用与此流的元素的结果

    ArrayList<String> list = new ArrayList<>();
    list.add("10");
    list.add("20");
    list.add("30");
    list.add("40");
    list.add("50");

    // 需求1: 将 集合中的字符串数据转换为整数后在控制台中输出
    list.stream().map(Integer::parseInt).forEach(System.out::println);

    //计算 流中的总和
    int result = list.stream().mapToInt(Integer::parseInt).sum();
    System.out.println(result);
}

Stream流终结操作方法

forEach() 对此流的每个元素执行操作

//遍历流中的所有元素
List.stream().forEach(System.out::println);

long count() 返回此流中的元素数

//计算流中元素的个数
long count = List.stream().filter(s -> s.startsWith("张")).count();
System.out.println(count);

Stream流的收集

​ Collecoter toList() 把元素收集到list集合中

// 创建list 集合对象
ArrayList<String> list = new ArrayList<>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");

//需求1: 得到名字为3个字的流
Stream<String> s1 = list.stream().filter(s -> s.length() == 3);
//将数据收集到list集合中,遍历
List<String> names = s1.collect(Collectors.toList());
for (String s: names
     ) {
    System.out.println(s);
}

​ Collecoter toSet() 把元素收集到Set集合中

// 创建set集合对象
Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(40);
set.add(50);
//大于25的数
Stream<Integer> s2 = set.stream().filter(s -> s > 25);
//将数据收集到set集合中,遍历
Set<Integer> ages = s2.collect(Collectors.toSet());
for (Integer age: ages
     ) {
    System.out.println(age);
}

​ Collecoter toMap(Function key , Function value) 把元素收集到Map集合中

//定义一个字符串数组
String[] strArray = {"张三,23","李四,24","王五,25"};
//得到年龄大于18的流
Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 18);

Map<String, Integer> map = stringStream.collect(Collectors.toMap(
        s -> s.split(",")[0],
        s -> Integer.parseInt(s.split(",")[1]))
);
Set<String> keySet = map.keySet();
for (String key: keySet
     ) {
    Integer value = map.get(key);
    System.out.println(key +"," + value);
}
"};
//得到年龄大于18的流
Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 18);

Map<String, Integer> map = stringStream.collect(Collectors.toMap(
        s -> s.split(",")[0],
        s -> Integer.parseInt(s.split(",")[1]))
);
Set<String> keySet = map.keySet();
for (String key: keySet
     ) {
    Integer value = map.get(key);
    System.out.println(key +"," + value);
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

卡卡卡丶西都

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值