java list.stream.filter 效率高吗

Posted 2023-04-28

参考技术A 不高 以前测试着玩过 lambda效率好像还不如foreache

Java4lambda，Stream流，File类，乱码，流，Properties，Tcp，文件上传/UUID/Junit，反射/注解，类加载器，代理/模板/单例/工厂，xml

文章目录

• 1.lambda表达式标准语法：()->
• 2.lambda表达式简略语法：可推导即可省略
• 3.lambda表达式原理：lambda效率比匿名内部类高
• 4.两个函数式接口：Consumer ，Predicate
• 5.Stream流引入： list.stream().filter
• 6.Stream流的获取：.stream()，Stream.of(array)
• 7.Stream流的终结方法：list.stream().count()
• 8.Stream流的拼接方法：Stream.concat
• 9.Stream源码分析：consumer.accept
• 10.File类三个构造方法和获取方法：\\
• 11.File的判断/创建/删除/列举方法：listFiles
• 12.案例：listFiles，isFile，.delete()
• 13.FileOutputStream两个构造：OIWR，IO流（内存为中心）
• 14.OutputStream的基本方法：int4，追加和换行
• 15.FileInputStream两个构造：一次读一个字节或字节数组
• 16.文件复制(重要)：System.currentTimeMillis()，fis.read，fos.write
• 17.编码表与字符流：编码/解码/乱码
• • 17.1 乱码：3个有编码，4个现象
  • 17.2 linux文件编码转换：iconv，enca
  • 17.3 Linux中文字符集：/etc/locale.conf
  • 17.4 Oracle的字符集：NLS_LANG
  • • 服务端的字符集：Oracle数据库实例创建后，如果没有开始业务运行，可修改字符集，如果已经业务化运行，不建议修改字符集，会造成数据中的汉字乱码
    • 客户端的字符集：Oracle客户端的字符集必须与服务端相同，否则中文会出现乱码，客户端的字符集由NLS_LANG环境变量控制
• 18.flush和close方法：.getBytes()
• 19.IO流异常处理：字符流用于读写文本文件，字节流outputStream（内存->硬盘：写，以内存为中心），BOP
• 20.字节/字符缓冲流：readLine
• 21.案例_出师表：\\ \\ . ，content = map.get(i)
• 22.转换流：字节字符的中间流
• 23.序列化流：oos.writeObject，Serializable
• 24.打印流：最后一个流
• 25.Properties集合：Hashtable 与HashMap 区别，p.load，toString
• 26.tcp通讯：ip相当于小区，port相当于门牌号
• • 26.1 单向：一个字节是2的8次方即256，所以0-255。ipv4组合方式共2的32（4*8=32）次方即43亿个
  • 26.2 双向：socket中介
• 27.案例_文件上传：ServerSocket
• 28.多线程优化服务端与UUID：is和fos
• 29.Junit测试框架：手动加jar包
• 30.Class对象三种获取方式：Class.forName(" ");
• 31.反射：clazz.newInstance()
• 32.注解与元注解：IO流（过河拆桥，用完后即时释放）, 泛型（泛型只在编译阶段，运行时也被擦除）
• 33.自定义junit测试框架并打jar包：method.isAnnotationPresent
• 34.类加载器：.class.getClassLoader()，引扩应，双亲委派
• 35.代理租房：静态代理，中介可代理实现FD接口的多个房东。装饰者设计模式（IO流，可层层增加功能），迭代器设计模式（集合）
• 36.动态代理：newProxyInstance（三参）.zufang（）调用h中invoke（三参）
• 37.模板：类里有抽象方法必须抽象类
• 38.单例：某个类只能有唯一的一个实例对象，多线程
• 39.工厂：工厂类（一个工厂），工厂接口（一车一工厂），clazz.newInstance()
• 40.DTD约束：配置文件
• 41.schema约束：命名空间
• 42.xml解析：dom4j

---

1.lambda表达式标准语法：()->

package com.itheima01.boot;
/*
*   函数式编程 语法 (JDK8): 函数(公式)  ->  java方法 。作用: 简化代码编写    
*       1. lambda表达式: 标准语法/简略语法
*       2. 运用: Stream流
*/
public class BootDemo 
    public static void main(String[] args) 
        //匿名内部类
        new Thread(new Runnable() 
            @Override
            public void run() 
                System.out.println(Thread.currentThread().getName());
            
        ).start();

        //lambda表达式
        new Thread(
                () -> 
                    System.out.println(Thread.currentThread().getName());
                
        ).start();
    

package com.itheima02.lambda;
/*
    lambda表达式 -> 函数式编程(不在乎什么对象, 在乎是什么方法)
    方法重要三部分： 参数列表、方法体、返回值

*   标准语法：  (参数列表)
*              -> : lambda符号，连接作用
*               方法体,返回值 
*/
public class StandardDemo 
    public static void main(String[] args) 
        Cooker cooker = new Cooker()  //匿名内部类 ，和下面的method()无关
            @Override
            public void cook() 
                System.out.println("猪肉炖粉条");
            
        ;
        method(cooker);

//11111111111111111111111111111111111111111111111111111111111111111	
        Cooker cooker2 =  () -> 
            System.out.println("小鸡炖蘑菇");
        ;
        method(cooker2);
            
    private static void method(Cooker cooker)  //参数类型是接口 -> 多态。调用此方法必须传入此接口的实现类对象。
        // System.out.println(1); //1 先于 猪肉炖粉条 打印
        cooker.cook(); //父类调用方法执行子类重写方法
    

interface Cooker  
    void cook(); //这方法无参无返回

package com.itheima02.lambda;
/*
*  lambda表达式：在乎的方法: 拿什么参数去做什么事情,返回什么结果。
*         (参数列表) ->  return xx; 
*/
public class StandardDemo02 
    public static void main(String[] args) 
        Calculator c1 = new Calculator() 
            @Override
            public int calc(int c, int d) 
                return c + d;
            
        ;
        method(c1);
        
//1111111111111111111111111111111111111111111111111111111111111111
        Calculator c2 = (int o1,int o2) -> 
            return o1 - o2;
        ;
        method(c2);
    

//1111111111111111111111111111111111111111111111111111111111111111
    private static void method(Calculator calculator) 
        int result = calculator.calc(1, 2); //父类调用方法执行子类重写方法
        System.out.println(result);
    

interface Calculator    
    int calc(int a, int b); //有参有返回

package com.itheima03.prefix;
/*
*   lambda表达式的使用前提： 1. 接口 : 有且仅有一个抽象方法 (需要被重写) 的接口
*       				     2. 上下文推导
*   lambda表达式可以看成 极为简化的 匿名内部类对象
*       接口的实现 (函数: 方法)
*/
public class PrefixDemo 
    public static void main(String[] args) 
        Cooker c1 = new Cooker() 
            @Override
            public void cooker() 
                System.out.println("翠花上酸菜");
            
        ;
        method(c1);

//11111111111111111111111111111111111111111111111111111111111111111	
        /*
        *   匿名内部类对比
        *   lambda表达式 : 1. 省略了new + 接口名 (因为上下文推导)
        *        2. 省略了方法名 (因为接口只有一个抽象方法,所以方法名不重要)
        */
        //上文 （Cooker c2 = 是上文 ，() ->...是下文） 推导
        Cooker c2 = () -> 
            System.out.println("蚂蚁上树");
        ;
        method(c2);
        
//111111111111111111111111111111111111111111111111111111111111111111		
        //下文推导。上下文有其一即可
        method( () -> 
            System.out.println("蚂蚁上树");
        );
    
    private static void method(Cooker cooker) 
        cooker.cooker();
    

interface Cooker
    void cooker(); //有且仅有一个抽象方法

package com.itheima03.prefix;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
*   lambda表达式的运用：1. Runnable接口
*       		        2. Comparator接口
*/
public class UseDemo 
    public static void main(String[] args) 
//        method01();
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,5,3,2,4,1);
        
        Collections.sort(list, new Comparator<Integer>() 
            @Override
            public int compare(Integer o1, Integer o2) 
                return o1 - o2;
            
        );
        System.out.println(list); //[1,2,3,4,5]

//11111111111111111111111111111111111111111111111111111111111111111111111111        
        Collections.sort(list,(Integer o1,Integer o2) -> 
            return o2 - o1;
        );
        System.out.println(list); //[5,4,3,2,1]
    

//11111111111111111111111111111111111111111111111111111111111111111111111111
    private static void method01()   
        new Thread(new Runnable() 
            @Override
            public void run()  
                System.out.println(Thread.currentThread().getName() + ": 嘻嘻"); //Thread-0：嘻嘻
            
        ).start();
        
//1111111111111111111111111111111111111111111111111111111111111111111111111
        Runnable runnable = () -> 
            System.out.println(Thread.currentThread().getName() + ":哈哈"); //Thread-1：哈哈
        ;
        new Thread(runnable).start();
        
//1111111111111111111111111111111111111111111111111111111111111111111111111
        new Thread(()->
            System.out.println(Thread.currentThread().getName() + ":呵呵"); //Thread-2：呵呵
        ).start();
    

2.lambda表达式简略语法：可推导即可省略

package com.itheima04.simple;
/*
*       1. 参数类型可以省略 (接口抽象方法只有一个,参数列表只有一个,什么类型不需要特地声明)
*       2. 如果方法体中只有一行代码,那么 和return和; 都可以省略
*       3. 如果参数列表 有且只有一个参数,那么()可以省略
*/
public class SimpleDemo 
    public static void main(String[] args) 
        //lambda编写: 拿什么东西去做什么事,结果?
        method((int a,int b)->  return a + b;);

        method((a,b) -> return a+b;); //可以

        method((a,b) -> a+b); //可以，如上的省略

        method((a,b) ->  
            int sum = a+b;
            return sum; //两句不能去掉..return..
        );		
        
//1111111111111111111111111111111111111111111111111111111111111111111111111111
        method02((String cai) -> 
            System.out.println("开水煮" + cai); //子类重写的方法 //开水煮大白菜
        );

        method02((cai) -> System.out.println("醋溜" + cai));

        method02(cai -> System.out.println("韩式泡" + cai)); //空参必须写（）
    

//1111111111111111111111111111111111111111111111111111111111111111111111111111
    private static void method02(Cooker cooker) 
        cooker.cook("大白菜"); //无返回值，父类调用方法执行子类重写的方法，此时cai="大白菜"。这行是主体。
    
    private static void method(Calculator calculator) 
        int result = calculator.calc(1, 2);
        System.out.println(result);
    

interface Calculator
    int calc(int a,int b);

interface Cooker
    void cook(String cai);

package com.itheima04.simple;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
*   lambda表达式简略语法运用
*       1. Runnbale接口
*       2. Comparator
*/
public class UseDemo 
    public static void main(String[] args) 
        new Thread(new Runnable() 
            @Override
            public void run() 
                System.out.println("嘻嘻");
            
        ).start();
        
        new Thread(() -> System.out.println("呵呵")).start();	
        	
//11111111111111111111111111111111111111111111111111111111111111111
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,5,3,4,2,1);
        
        Collections.sort(list, new Comparator<Integer>() 
            @Override
            public int compare(Integer o1, Integer o2) 
                return o1 - o2;
            
        );
        System.out.println(list);

//11111111111111111111111111111111111111111111111111111111111111111        
        Collections.sort(list,(o1,o2) -> o2 -o1);
        System.out.println(list);
    

3.lambda表达式原理：lambda效率比匿名内部类高

package com.itheima05.theory;
import java.util.ArrayList;
import java.util.List;
/*
* lambda表达式和匿名内部类： 0.lambda表达式 可以算是 一种 匿名内部类的 简化语法
*       1.lambda表达式能不能完全替代匿名内部类？不能
*           1.lambda表达式只能用在(有且仅有一个抽象方法需要被重写的)接口
*           2.匿名内部类(接口比较多,类实际上也可以)
*       2.lambda表达式是不是匿名内部类的语法糖(原理完全相同,语法更为简练称为语法糖)？  不是         
*           1.匿名内部类 是 类
*           2.lambda表达式不是 类，是可以替代对象 的函数
*/
public class LambdaDemo      // LambdaDemo.class
    public static void main(String[] args)         
        Runnable runnable = new Runnable()  // LambdaDemo$1.class（编译生成） ，所以匿名内部类是类。idea中run集成了编译和运行
            @Override
            public void run() 
                System.out.println("嘻嘻");
            
        ;
  
//111111111111111111111111111111111111111111111111111111111111111111111111
        Runnable runnable2 = new Runnable()  // LambdaDemo$2.class 
            @Override
            public void run() 
                System.out.println("嘻嘻2");
            
        ;
    //接口类型 引用 = 接口实现类对象(看成,但实际上不是) //没有.class文件生成
        Runnable runnable3 = () -> System.out.println("呼呼");
    

4.两个函数式接口：Consumer ，Predicate

package com.itheima06.function;
import java.util.Comparator;
/*
* 函数式接口:  1. 定义 : 有且仅有一个抽象方法(需要被重写)的接口
*          2. 作用 : 支持函数式编程(A.lambda表达式 B.方法引用)
*         3. 已学习 : Runnbale , Comparator两个函数式接口
*       4. 注解: @FunctionalInterface
*               写在接口声明上, 检查此接口是否是函数式接口,如果不是编译报错
*/
public class FunctionDemo 
    public static void main(String[] args) 
//        Runnable
    

@FunctionalInterface
interface A
    void eat(); //需要重写的抽象方法，只一个
    String toString(); // 不需要重写的抽象方法
    static void method01() //不影响@FunctionalInterface，静态方法一定不能被重写
    
    default void method02()
    


//1111111111111111111111111111111111111111111111111111111111111
interface B
    String toString();  

//Object和接口B中拥有相同方法,C先继承Object的方法,当成接口B的重写
java 8 streamlambda表达式对list操作分组过滤求和最值排序去重

 java 8 streamlambda表达式对list操作分组过滤求和最值排序去重
 java8 方法引用与lambda
 元素为零时如何避免列表迭代
 返回stream.map中定义的函数的模拟对象
 Stream流的小技巧