Java学习_Day23

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量92 收藏
点赞数
文章标签： java jdk1.8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shtxk/article/details/117267092
版权
本文详细介绍了Java 8中的Lambda表达式和函数式接口，包括它们的使用方式、特点以及如何实现SAM接口。示例涵盖了Runnable、Consumer、Supplier、Predicate、Function等接口，并演示了方法引用和构造器引用的使用。此外，还讨论了Stream API的基本操作，如filter、map、reduce等，并展示了在实际问题中的应用。
摘要由CSDN通过智能技术生成

函数式编程思想

​ 注重“函数” 函数实现的结果， 以及它必须有 接口

​ 以前： 接口 对象 = new 实现类() ;

​ 现在： 接口 对象 = new 接口() {

​ 实现接口的抽象方法

​ }

JDK1.8新特性
1.lambda表达式
属于jdk的语法塘
分为三部分
（参数列表 参数名） -> {抽象方法的实现体}
①参数列表 当参数列表只有一个参数的时候，（）可以省略，但是没有参数的时候，（）不能省略； 参数类型可以不写
②-> 中间不能有空格
③{方法 的实现体}：当方法只有一句话时候，{}可以省略，但是当有return时候，{}必须存在，但是只有一句表达式的时候，return可以省略，这时候{}可以省略
补充：参数类型可以省略，但是参数类型必须一致，可以运用泛型
List c = Arrays.asList(12, 15, 11, 2, 5, 3, 6, 8, 42, 8);

/**
 * Lambda语法
 * 接口中有且只有一种方法
 */
public class Test1 {
    public static void main(String[] args) {
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        //简写
        Runnable runnable1=()->{ System.out.println("hello");};

        //再次简写
        Runnable runnable2=()->{int a=8;
        System.out.println(a);};
        System.out.println();;
        new Thread(runnable1).start();
        new Thread(runnable2).start();




        List<Integer> c = Arrays.asList(12, 15, 11, 2, 5, 3, 6, 8, 42, 8);

//        c.sort((o1,o2)->o1.compareTo(o2));//==》c.sort(list);
//        for (Integer integer : c) {
//            System.out.println("-->"+integer);
//        }

        c.forEach((i) ->  System.out.println("-->"+i));

        c.stream().forEach(System.out::println);
    }
}

	**函数式接口**	
	lambda表达式就是实现SAM接口的语法糖（只有一个抽象接口需要实现，但是可以继承和包含其他的非抽象方法）
	@FunctionalInterface注解会强制该接口只有一个非抽象方法
				使用lambda有一些必要前提：
							①必须使接口
							②接口中有且只有一个抽象方法
		1.自定义函数接口
			eg：需求： 定义一个计算器接口，用于 计算两个数 ， 该接口既可以 计算两个数之和、 两个数之差、两个数之乘积 ，两个数之商  

@FunctionalInterface
public interface Calc {

    public int calc(int a,int b);
}

import org.junit.Test;

public class Test1 {
    @Test
    public void test1(){
        Calc calc=(a,b)->a+b;
        int calc1 = calc.calc(5, 6);
        System.out.println(calc1);
    }
    @Test
    public void test2(){
        Calc calc=(a,b)->a-b;
        int calc1 = calc.calc(5, 6);
        System.out.println(calc1);
    }

    @Test
    public void test3(){
        Calc calc=(a,b)->a*b;
        int calc1 = calc.calc(5, 6);
        System.out.println(calc1);
    }

    @Test
    public void test4(){
        Calc calc=(a,b)->a/b;
        int calc1 = calc.calc(5, 6);
        System.out.println(calc1);
    }
}



补充：lambda可以省略的原因使规定了接口有且只有一个抽象方法
	
		2.消费性接口
			接口 ： Consumer   void  accept（T t）
				解读：无返回值，但是要传递一或两个个泛型（任意类型但是不包括基本类型，基本类型的泛型为包装类）   Consumer ----》为接口名      accept---》为接口里面的抽象方法

 /**
     * 1、消费型接口
     *  Consumer      void accept(T t)
     */
    @Test
    public void Test1(){
        Consumer<Integer> consumer=(a)->{
            int num = 0;
            for (int i = 0; i <= a; i++) {
                num+=i;
            }
            System.out.println(num);
        };
        consumer.accept(100);
    }

    /**
     *
     *  Consumer      void accept(T t,U u)
     */
    @Test
    public void Test2(){
        BiConsumer<String,Integer> biConsumer =new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer score) {
                System.out.println("亲爱的"+s+"，分数："+score);
            }
        };

        BiConsumer<String,Integer> biConsumer1=(s,score)-> System.out.println("亲爱的"+s+"，分数："+score);

        biConsumer1.accept("baby",100);

    }


		3.供给型接口
			接口：Supplier T get()
				解读：有返回值，无参数

    /**
     * 2、供给型接口
     *   Supplier  T get()  : 有返回值 无参数
     */

    @Test
    public void Test3(){
        Supplier<Integer> supplier=()->{return (int)(Math.random()*101);};
        //省略
        Supplier<Integer> supplier1=()->(int)(Math.random()*101);

        Integer integer = supplier1.get();
        System.out.println(integer);
    }


		4.判断型接口
			接口：  Predicate   boolean  test（T t）
				解读：有一个或两个参数，有返回值但是返回值为boolean类型

**
 * 判断型接口
 *   Predicate   boolean test(T)  判断是否满足 ，返回true/false
 */

@Test
public void Test4(){
    // 判断一个字符串的长度是否大于5
    Predicate<String> predicate =new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.length()>5;
        }
    };

    //简写
    Predicate<String> predicate1 =s->s.length()>5;
    System.out.println(predicate1.test("sda"));

}

    /**
     *  BiPredicate  boolean test(T  t,  U u)
     */
    @Test
    public void Test5(){
        // 判断一个字符串是否包含另一个字符串
        BiPredicate<String,String> biPredicate=new BiPredicate<String, String>() {
            @Override
            public boolean test(String s, String s2) {
                return s.contains(s);
            }
        };

        //简写
        BiPredicate<String,String> biPredicate1=(s,s1)->s.contains(s1);

        System.out.println(biPredicate1.test("dada", "da"));

    }

    // 很多时候 是将 这个接口作为一个方法的参数来使用   ,
    @Test
    public void test8(){
        boolean flag  =   myTest("www.atguigu.com" ,"atguigu" , (s1,s2) -> s1.contains(s2));
        System.out.println(flag);
    }
    /**
     * 将接口的类型 作为方法的 形参
     * @param biPredicate
     * @return
     */
    public static boolean  myTest(String s1,String s2, BiPredicate<String , String > biPredicate){
        if(biPredicate.test(s1,s2)){
            System.out.println("条件满足");
            return  true;
        }else{
            System.out.println("条件不满足");
            return  false;
        }
    }
}

			5. 功能型接口（api--》接口）
				接口：Functio（T,R）  R  apply（T t）
								解读：第一个泛型T是方法的参数，第二个参数是返回值类型
				接口：BiFunction（T,U,R）  R apply（T t，U u）
								解读：第一个泛型T和第二个泛型U是方法的参数，第三个参数是返回值类型

   /**
     * 功能型接口
     *  Function(T,R)   R test(T)
     *  第一个泛型T是方法的参数，第二个参数是返回值类型
     */

    @Test
    public void Test6(){
        // 判断一个字符串的长度
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };

        //简写
        Function<String,Integer> function1=(s)->s.length();
        System.out.println(function1.apply("babt love you"));
    }


//    运用 把接口作为形参列表
    public static int getlen(String s,Function<String,Integer> fun){
        //调用接口的方法
        int n =fun.apply(s);
        return n;
    }

    @Test
    public void test7(){
        //genlen的参数决定了方法  实现（该繁峙县可以使用lambda表达式）
        int len=getlen("baby i love you", new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        });

        //简写
        int len1 = getlen("baby i love you", s -> s.length());
        System.out.println(len);
        System.out.println(len1);
    }

    /**
     * bifunction(U,T,R)   R  apply(U u,T t)
     */
    @Test
    public void test9(){
        //eg:求两个字符串的总长度
        BiFunction<String,String,Integer> biFunction = new BiFunction<String, String, Integer>() {
            @Override
            public Integer apply(String s, String s2) {
                return s.length()+s2.length();
            }
        };
        Integer apply = biFunction.apply("hello", "world");
        System.out.println(apply);

        //简写
        BiFunction<String,String,Integer> biFunction1=(s,s1)->s.length()+s1.length();
        Integer apply1 = biFunction1.apply("hello", "world");
        System.out.println(apply1);

    }

		**方法引用和构造器的引用**
				1.方法的引用
					①类的实例名（对象名）：实例方法名（没有加static修饰的方法）

 /**
     * 类的实例名（对象名）：实例方法名（没有加static修饰的方法）
     * 1.有且只有一个抽象方法
     * 2.抽象方法只有一句话
     * 3.这句话就是方法的调用
     * 4.调用的方法的参数与抽象方法保持一致
     * eg：
     *            public void accept(String s) {
     *                 System.out.println(s+"hekkk"); //此时就不一致
     *             }
     */
    @Test
    public void test1(){
        //eg：通过consumer接口输出helloword

        Consumer<String> consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s); //方法的调用
            }
        };

        //lambda方法
        Consumer<String> consumer1=s -> System.out.println(s);
        consumer1.accept("helloword");

        //方法调用
        //System.out  类的实例名
        //println    引用的方法
        Consumer<String> consumer2=System.out::println;
        consumer2.accept("baby");

    }


					②类名：：静态方法名 （加了static修饰的方法）

   /**
     * 类名：静态方法
     * 1.有且只有一个抽象方法
     * 2.抽象方法只有一句话
     * 3.这句话就是方法的调用
     * 4.调用的方法的参数与抽象方法保持一致
     */
    @Test
    public void test2(){
        //eg：比较2个double类型大小 返回int
        BiFunction<Double,Double,Integer> biFunction=new BiFunction<Double, Double, Integer>() {
            @Override
            public Integer apply(Double aDouble, Double aDouble2) {
                return Double.compare(aDouble,aDouble2);//1 0 -1
            }
        };
        biFunction.apply(5.8,7.3);

        //lambda方法
        BiFunction<Double,Double,Integer> biFunction1=(d1,d2)->Double.compare(d1,d2);
        //方法调用
        BiFunction<Double,Double,Integer> biFunction2=Double::compareTo;

    }


					③类名：：实例方法名

 /**
     * 类名：实例方法名
     * 1.有且只有一个抽象方法
     * 2.抽象方法只有一句话
     * 3.这句话就是方法的调用
     * 4.抽象方法的第一个参数是方法的调用者，后面的参数与该方法的参数列表一致
     */
    @Test
    public void test3(){
        //eg：判断一个字符串是否存在另一个字符串  contains是string类的方法
        BiFunction<String,String,Boolean> booleanBiFunction=new BiFunction<String, String, Boolean>() {
            @Override
            public Boolean apply(String s, String s2) {
                return s.contains(s2);
            }
        };

        //lambda方法
        BiFunction<String,String,Boolean> booleanBiFunction1=(s,s1)->s.contains(s1);
        //方法调用
        BiFunction<String,String,Boolean> booleanBiFunction2=String::contains;
        System.out.println(booleanBiFunction2.apply("hello", "he"));
    }

    @Test
    public void test4(){
        //eg：比较2个double类型大小 返回int


        //lambda方法

        //方法调用


    }


		**构造方法的引用**
				① 类名：：new

    /**
     * 构造器的引用
     *  类名：：new
     *  1.有接口（没有自定义）
     *  2.抽象方法中只有一句代码的实现
     *  3.该代码就是构造器的调用
     *  4.构造器的参数与抽象方法的参数保持一致
     */
    @Test
    public void test1(){
        Student baby = new Student(5, "baby");
        //函数式接口
        BiFunction<Integer,String,Student> function=new BiFunction<Integer, String, Student>() {
            @Override
            public Student apply(Integer id , String s) {
                return new Student(id,s);//构造器的引用
            }
        };
//lambda简写
        BiFunction<Integer,String,Student> function1=(id,s)->new Student(id,s);
//        构造器的引用
        BiFunction<Integer,String,Student> function2=Student::new;
        System.out.println(function2.apply(1, "ly"));
    }

			②数组类型：new

 /**
     * 构造器的引用
     *  数组类型：：new
     *  1.有接口（没有自定义）
     *  2.抽象方法中只有一句代码的实现
     *  3.数组的的长度与抽象方法的参数保持一致
     */
    @Test
    public void test2(){
        //eg：创建一个指定长度的int类型数组
        int[] ints = new int[5];//类型为包装类  integer
        //函数式接口
        Function<Integer,int[]> function= new Function<Integer, int[]>() {
            @Override
            public int[] apply(Integer i) {
                return new int[i];
            }
        };
//lambda简写
        Function<Integer,int[]> function1=i->new int[i];
//        构造器的引用
        Function<Integer,int[]> function2=int[]::new;

        //调用方法的时候才赋值参数
        int[] apply = function2.apply(5);
        for (int i = 0; i <apply.length ; i++) {
            System.out.println(apply[i]);
        }
    }

streamAPI
streamAPI：java.util.stream类中
功能：可以将集合数组的元素进行查找，过滤，筛选等若干处理
好处：简化程序，写更精简的，高效的代码
注意：
1.不能存数组
2.不会改变源数据，每次操作后会返回一个新的stream流
3.stream流是延迟操作，只有出现结果的时候，才会执行过程
stream流分为三步：
1.创建流
2.中间处理
3.最终操作
在这里插入图片描述


public class Test1 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("hsd", "addsa", "fasda", "dasdua", "hello");
        //创建流
        Stream<String> stream = list.stream();
        //中间操作 (会得到新的流,流操作后会自动关闭)
        Stream<String> stringStream = stream.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 4;
            }
        });
        //最终操作  //消费型接口
        stringStream.forEach(s -> System.out.println(s));


        //jdk8可以采取链式操作（中间操作不断，流不会终止和产生新的）
        long count = list.stream()//开始操作 只能一个
                .filter(s -> s.length() > 4) //中间操作  可以很多个
                .count();//最终操作  只能有一个

    }
}


练习：
/**
  • 需求：通过streamAPI 查询年龄在35岁以上的
  • 需求：查询35随以上的，工资8000
  • 需求：查询工资20000 35岁以上 火箭1
    */

/**
 * 需求：通过streamAPI 查询年龄在35岁以上的
 * 需求：查询35随以上的，工资8000
 * 需求：查询工资20000 35岁以上  火箭1
 */
public class Test1 {

    @Test
    public void Test1(){
        List<Emyee> list = Arrays.asList(
                new Emyee(1,"s",10000,18,"火箭1"),
                new Emyee(2,"s1",100000,25,"火箭2"),
                new Emyee(3,"s2",1000000,35,"火箭3"),
                new Emyee(4,"s3",10000,45,"火箭2"),
                new Emyee(5,"s4",10000,55,"火箭1"),
                new Emyee(6,"s5",100000,33,"火箭2"),
                new Emyee(7,"s6",10000,22,"火箭3")
        );
        // 1、 创建流
        Stream<Emyee> stream =list.stream();
//中间操作
        Stream<Emyee> stream1 =stream.filter(new Predicate<Emyee>() {
            @Override
            public boolean test(Emyee e) {
                return e.getAge()>35;
            }
        });
        stream1.forEach(System.out::println);

        list.stream()
                .filter(emyee -> emyee.getAge()>35 &&emyee.getSalary()>8000)
//                .forEach(System.out::println);
                    .forEach(emyee-> System.out.println(emyee.getName()));

        list.stream()
                .filter(emyee -> emyee.getAge()>35 &&emyee.getSalary()>8000 &&emyee.getSection().equals("火箭1"))
                .forEach(System.out::println);

    }
}



public class Emyee {
    private  int id;
    private  String name;
    private double salary;
    private int age;
    private String section;

    public Emyee() {
    }

    public Emyee(int id, String name, double salary, int age, String section) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.age = age;
        this.section = section;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

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

    public String getSection() {
        return section;
    }

    public void setSection(String section) {
        this.section = section;
    }

    @Override
    public String toString() {
        return "Emyee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                ", section='" + section + '\'' +
                '}';
    }
}

stream流三步的主要方法
①创建流的方法：
1.顺序流
2.并列流
3.数组创建流
4.stream of创建流
创建无限流（2种方法）


/**
     * 创建流stream
     */
    public class Test1 {

    /**
         * 创建顺序流 和并行流
         */
        @Test
        public void test1(){
            List<String> list = Arrays.asList("jaa", "sada", "jafafa");
            //创建顺序流
            Stream<String> stream = list.stream();

            //创建并行流 （由多个线程创建一个stream对象）
            //数据量大可以用并行流 该流的输出顺序不一定
            Stream<String> stream1 = list.parallelStream();

            stream.forEach(System.out::println);
            System.out.println();
            stream1.forEach(System.out::println);
        }


        /**
         * 创建数组 流
         */
        @Test
        public void test2(){
            String[] list = {"jaa", "sada", "jafafa"};
            //数组创建流
            Stream<String> stream = Arrays.stream(list);

            stream.forEach(System.out::println);
        }

    /**
     * stream of（T。。。）   创建流
     */
    @Test
    public void test3(){
        
        //数组创建流
        Stream<String> stream = Stream.of("jaa", "sada", "jafafa");

        long count = stream.filter(s -> s.length() > 1).count();
        System.out.println("元素个数："+count);

    }

    /**
     * 创建一个无限流
     */
    @Test
    public void test4(){

        //数组创建流
      Stream.generate(new Supplier<Double>() {
//          返回一个double类型的随机数
          @Override
          public Double get() {
              return Math.random();
          }
      });
//?  源源不断的产生数据
        Stream<Double> generate = Stream.generate(() -> Math.random());

        generate.forEach(System.out::println);
    }


    /**
     * 创建一个无限流
     */
    @Test
    public void test5(){

        //数组创建流
        Stream<Integer> iterate = Stream.iterate(0, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer i) {
                return i += 1;
            }
        });


//?  源源不断的产生数据


        iterate.forEach(System.out::println);
    }


}

②中间操作


/**
 * stream流的中间操作
 */
public class Test1 {

    @Test
    public void teat1(){
        List<String> list = Arrays.asList("sdadaada","java", "jdbc", "mysql", "servlet", "maven","java","java");

        list.stream()
                .filter(s-> s.length()>2)//判断字符个数
//                .sorted()//判断数组的排列
                .sorted(new Comparator<String>() {
                    @Override
                    public int compare(String o1, String o2) {
                        return o1.length()-o2.length();
                    }
                })
                .skip(1)//跳过一个
                .limit(2)//取前两个
                .peek(s -> System.out.println("study="+s))  //这里的s与20行的s相对应  表示修饰哪些  不会改变元素本身
//                .forEach(s->System.out::println);
                .forEach(s->System.out.println());

//        .distinct()  自动过滤重复的元素
        list.stream().distinct().forEach(System.out::println);
//   map  对元素进行处理，并返回处理结果
        list.stream().map(new Function<String, Integer>() {//会改变元素本身
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        }).forEach(System.out::println);


        list.stream().map(s-> "元素："+s).forEach(System.out::println);
    //map和peek的区别：
    //map（Function）将处理的结果放入流中
    //peek（Consumer）知识处理过程，没有返回值，不会将结果放入stream流中


    }

        @Test
    public void test2(){
            List<String> list = Arrays.asList("sdadaada","java", "jdbc", "mysql", "servlet", "maven","java","java");
//          根据flatMap的实现，将元素先拆分成指定的一段流，最后每一个元素的流数据合并一个流
            list.stream().flatMap(new Function<String, Stream<String>>() {
                @Override
                public Stream<String> apply(String s) {
                    return Arrays.stream(s.split("a"));//由于split拆分的返回的是数组 ---》转化为流
                }
            }).forEach(System.out::println);
        }

}

③最终操作


/**
 * 最终操作
 */
public class Test1 {
    /**
     * allMatch  检查元素是否都匹配
     */
    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
//返回该元素是否全都小于5
        boolean b = list.stream().allMatch(n -> n <= 6);
        System.out.println(b);
    }

    /**
     * antMatch  检查元素是否由一个满足
     */
    @Test
    public void test2(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
//返回该元素是否全都小于5
        boolean b = list.stream().anyMatch(n -> n <= 6);
        System.out.println(b);
    }

    /**
     * onneMatch  检查元素是否没有匹配
     */
    @Test
    public void test3(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
//返回该元素是否全存在偶数 (存在一个为false)
        boolean b = list.stream().noneMatch(n -> n%2==0);
        System.out.println(b);
    }

    /**
     *findFirst()  返回第一个元素
     */
    @Test
    public void test4(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
//返回值Optional  ：用于封装返回值的一个工具  可避免空指针异常
        Optional<Integer> first = list.stream().findFirst();
        System.out.println(first);//Optional.empty为空
//        System.out.println(first.get());//返回第一个元素
        System.out.println(first.isPresent());//判断元素是否存在
    }


    /**
     *findAny()  返回任意一个元素
     */
    @Test
    public void test5(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
//返回值Optional  ：用于封装返回值的一个工具  可避免空指针异常
        Optional<Integer> first = list.stream().findAny();
        System.out.println(first);//Optional.empty为空
        System.out.println(first.get());//返回first中的一个元素
        System.out.println(first.isPresent());//判断元素是否存在
    }

    /**
     *max（）  最大的元素
     * min（） 最小的元素
     */
    @Test
    public void test6(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
        Optional<Integer> max = list.stream().max((o1, o2) -> o1.compareTo(o2));
        Optional<Integer> min = list.stream().min((o1, o2) -> o1.compareTo(o2));
        System.out.println(max);
        System.out.println(min);

    }

    /**
     *reduce()  求和
     */
    @Test
    public void test7(){
        List<Integer> list = Arrays.asList(1, 8, 6, 3, 2, 4, 5);
        Optional<Integer> reduce = list.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer a, Integer b) {
                return a + b;
            }
        });

        //可以设置初始值
        Integer reduce1 = list.stream().reduce(10, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer a, Integer b) {
                return a + b;
            }
        });

        System.out.println(reduce);
        System.out.println(reduce1);

    }


    /**
     * 遍历 计算总数 如果需要将中间操作的结果进行接收 可以用collect（）
     * 可将处理的流收集成  集合类型
     */
    @Test
    public void test8(){
        List<String> list = Arrays.asList("sdadaada","java", "jdbc", "mysql", "servlet", "maven","java","java");
        List<String> a = list.stream().flatMap(new Function<String, Stream<String>>() {
            @Override
            public Stream<String> apply(String s) {
                return Arrays.stream(s.split("a"));//由于split拆分的返回的是数组 ---》转化为流
            }
        }).collect(Collectors.toList());//收集成新的集合
        System.out.println("新的集合：" + a);

    }







}

知识补充：
optiona类型

public class TestOptional {
    public static void main(String[] args) {
          // Optional避免空指针异常
        Employee emp = null;
     //   System.out.println(emp.getName());  // 空指针

        // of ： 将一个对象封装成 option
        Optional<Employee> optional = Optional.of(null);
        // 判断对象是否存在
        if(optional.isPresent()){
            System.out.println(optional.get());
        }else{
            System.out.println("不存在");
        }

        //  orElse(obj) : 如果对象为空则使用obj初始化
    }
}
心中爱恋宝宝的猪猪
关注
专栏目录
Day8_8 Java学习之List集合类
weixin_43717536的博客
08-08 2575
解析：1.List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。2.List 集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。3.List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。4.List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类。5.List集合的长度可变，且其中的数据类型只能为引用类型。............
Java_day23上课资料.zip
04-01
今天我们将深入探讨“Java_day23上课资料”中的关键知识点，这可能是针对初学者或有一定基础的学习者的一堂进阶课程。 首先，Java的核心特性之一是它的跨平台能力，这得益于Java的“一次编写，到处运行”（Write ...
java基础学习first day
weixin_45798731的博客
10-26 1481
一、什么是软件开发？ 首先我们必须先明白三个概念： 1、什么是软件 软件就是按照特定的顺序把数据和指令组合在一起，能够完成相应功能的程序。 软件分为两种： 系统软件：专门用于运行其他程序的平台。比如：Linux、Windows、MAC等 应用软件：完成相应功能的程序。比如：MS-Office，QQ，微信等 2、什么是开发 开发其实就是制作软件的过程。开发既然是个过程，这个过程可以分...
Java学习_Day 02(学习内容：狂神说JAVA零基础P12-P17)
好一个区块链
04-01 4067
P12 1 JAVA发展 1.1 构建工具 Ant, Maven, Jekins 1.2 应用服务器 Tomcat, Jetty, Jboss, Websphere, Weblogic 1.3 Web开发 Struts, Spring, Hibernate, myBatis 1.4 开发工具 Eclipse, Netbean, intellij idea, Jbuilder P15 1 JAVA三大版本 JavaSE：标准版（桌面程序，控制台开发等） JavaME：嵌入式开发（手机，小家电等） JavaEE
Java 学习笔记day_03
weixin_43754657的博客
03-03 4042
顺序结构 if结构_ if(关系表达式){ 语句体; } 首先计算关系表达式的结果（True 或 False） 如果为True 则执行语句体中的内容 如果为False 则不执行语句体的内容程序继续向下执行 执行完整个if结构,程序会继续往下执行 if…else结构_ if(关系表达式){ 语句体1; }else{ 语句体2; } 首先计算关系表达式的结果（True 或 False） 为True 则执行语句体1 为False 则执行语句体2 if…el
JAVA_SE_Day08
Anoraker的小屋
01-23 7028
学习面向对象的三条主线 Java类以及类的成员 : 属性 方法 构造器 代码块 内部类 面向对象的三大特征 : 封装 继承 多态 其他关键字 : this super static final abstract interface package import等 面向对象(OOP) : 强调具备了功能的对象，以类/对象为最小的单位 面向过程(POP) : 强调的是功能行为，以函数为最小单位，考虑怎么做 Java 语言的基本元素 类 : 是对一类事物的描述，是抽象的，概念上的 对象 : 是对实际存在的
Day22_7 Java学习之对象数组
热门推荐
weixin_43717536的博客
07-22 1万+
一、先定义，再开辟数组空间类名称对象数组名[]=null;对象数组名=new类名称[长度];二、定义并开辟数组空间类名称对象数组名[]=new类名称[长度];特别注意在声明对象数组后，必须对每个数组成员进行实例化之后才能直接使用，否则报空指针异常！Studentstudent[]={newStudent("小王",20),newStudent("小明",20),newStudent("小红",20)}；...
JAVA学习day6
qq_54395021的博客
04-30 2331
多线程：在身边的应用 可以边 看电影边 听音乐边 打游戏 JDK：java development kit （java开发者工具） JRE：java runtime environment （java运行环境） JVM：java virtual machine （java虚拟机）
学习Java笔记记录Day3
m0_69052198的博客
07-26 2583
Day3
韩顺平java学习day1
m0_60005887的博客
03-10 8258
程序举例 新建后缀名Test.java 的文件，用记事本打开，编辑程序，选中目录路径，输入CMD，打开 命令提示符，运行javac -encoding UTF-8 Test.java 编译，生成可执行文件Test.class，再使用java Test命令执行程序 Java的重要特性 面向对象（OOP） 夸平台性。一个编译好的class文件可以在多个系统运行 解释性语言（编译后的代码，不能直接被机器执行，需要解析器来执行） 编译性语言，编译后的代码可以直接被机器执行 Java的开
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7742
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
Spring_day_01_SourceCode.zip_Java编程_Java__Java编程_Java_
08-09
标题中的"Spring_day_01_SourceCode.zip"表明这是一个关于Spring框架学习的资源包，其中包含了第一天学习的源代码。"Java编程_Java__Java编程_Java_"在描述和标签中重复出现，强调了这个主题与Java编程语言的密切...
java_in_one_day
03-22
本教程“java_in_one_day”将带你快速入门，理解Java的核心概念，并教你如何编写简单的程序。 首先，你需要安装Java Development Kit（JDK），它是开发和运行Java程序的必备工具集。访问Oracle官网，根据你的操作...
Java基础_第二阶段-day18每日作业卷答案1
08-08
【Java基础】BeanUtils工具类详解 在Java开发中，BeanUtils工具类是Apache Commons库中的一个组件，它提供了一种方便的方式来操作...在学习和实践中，不断熟悉和运用这些工具类，能够提升编程的熟练度和代码质量。
Java_day17上课资料.zip
04-01
在这个压缩包“Java_day17上课资料.zip”中，我们可以期待找到与Java相关的各种学习材料，如课件、示例代码和练习题，帮助我们巩固和提升Java技能。 首先，Java的核心特性之一是它的平台独立性，这得益于Java虚拟机...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 548
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 417
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 702
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 851
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
Java MBeanInstantiator 0day 漏洞分析
"Java 0day Analysis - MBeanInstantiator.findClass 漏洞解析" 在2013年1月，Java社区面临了一个新的重大安全威胁：Java MBeanInstantiator.findClass 0day漏洞。这个漏洞的影响广泛，因为Java在当时已经广泛应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值