Lambda&IO

Lambda
1.Lambda作用
Lambda 表达式是一个匿名函数，可以把lambda表达式理解为一段可传递的代码（将代码像数据一样传递）。 Lambda表达式本质上只是一个“语法糖”，由编译器推断并帮你转换包装为常规的代码，因此可以使用更少的代码来实现同样的功能。
2.Lambda格式
通常用（argument)->{body}语法书写 （左侧是参数，右侧是方法体） 常见格式： 无参数，无返回值 () -> System.out.println("Hello World")； 无参数，有返回值： () -> { return 3.1415}; 有一个参数，无返回值： (String s) -> { System.out.println(s); } 由多个参数，由返回值： (int a,int b) -> { return a + b ;} 有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 (a, b) -> { return a - b; }

案例测试：

import java.util.ArrayList;
import java.util.Comparator;

public class Demo01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        list.add("s");
        list.add("d");
        list.add("w");
        list.add("f");

        /*
        使用sort方法对集合进行排序，创建一个匿名内部类对象
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
         */

//Lambda  将一个匿名函数当作参数传递
        list.sort( (o1,o2) -> {return o1.compareTo(o2); } );
        System.out.println(list);
    }
}

运行结果：

[d, f, s, w]

测试：

package Lambda;

public interface LambdaInterface {

    //void test();
    //void test(int a);
    int test(int a,int b);
}

package Lambda;
//自写语法进行测试
//自写接口
public class Demo03 {
    public static void main(String[] args) {

//创建匿名内部类对象重写方法
        /*
        new LambdaInterface(){
            @Override
            public void test() {

            }
        }*/

        /*LambdaInterface lambda = ()->{ System.out.println("test"); };
                        lambda.test();*/

        /*LambdaInterface lambda = (a)->{ System.out.println("test"+a); };
                        lambda.test(10);*/

        LambdaInterface lambda = (a,b)->{ return a+b; };
        System.out.println(lambda.test(10,20));

    }

    public static void Demo01(LambdaInterface lambdaInterface) {


    }

}

运行结果：30

IO

一、File类

1. File类是java.io包中很重要的一个类；
2. File类的对象可以表示文件，目录，在程序在一个File类的对象可以表示一个文件或目录；
3. File类对象可以对文件的属性进行操作，如：文件名，文件大小，最后修改日期等；
4. File类对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。

package IO;
//File类中的几个构造方法
import java.io.File;
import java.util.Date;

public class FileDemo01 {

    /*
    一个File的对象，可以表示计算机硬盘上的一个文件或目录（文件夹）;
    可以获取文件信息，创建文件，删除文件
    但是不能对文件中的数据进行读写操作
     */

    public static void main(String[] args) {
        /*File f = new File("E:/demo.txt");
        System.out.println(new Date(f.lastModified()));
        //E盘在demo文档最后修改时间
         */

        //把父集跟子集拆分，可写多个子集
       /* String p = "E:/";
        File f1 = new File(p,"demo.txt");
        File f2 = new File(p,"demo.txt");
        System.out.println(f1.lastModified());*/

        /*File pf = new File("E:");
        File f2 = new File(pf,"demo.txt");
        System.out.println(f2.lastModified());*/

        File f = new File("E:/demo.txt");
        System.out.println(f.canExecute());
        System.out.println(f.canRead());

        System.out.println("===============");
        System.out.println(f.exists());
        System.out.println(f.getAbsolutePath());//获得文件绝对地址
        System.out.println(f.getName());
        System.out.println(f.getPath());

        System.out.println(f.isAbsolute());//是不是绝对路径

        System.out.println(f.isDirectory());//是否为目录
        System.out.println(f.isFile());
        System.out.println(f.isHidden());//是不是隐藏文件

        System.out.println(new Date(f.lastModified()));//文件最后一次修改时间
        System.out.println(f.length());//文件字节长度
    }
}

package IO;

import java.io.File;
import java.io.IOException;

public class FileDemo02 {
    public static void main(String[] args) {

        //File f = new File("E:/a.txt");

        /*
        if(!f.exists()){
            try {
                f.createNewFile();//创建一个文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(f.delete());//删除文件，存在返回true，不存在返回false；
        */

       /*
        File d = new File("E:/a/b/c");//无后缀就是文件夹
             d.mkdir();//创建单级文件夹
             d.mkdirs();//创建多级文件夹
             d.delete();//删除文件夹，文件夹必须是空的
        */


        //过滤文件
        /*
        File f = new File("E:/api");
        String[] fs = f.list();
        for (String s : fs){
            System.out.println(s);
        }
         */

        //获取指定目录下的所以子集文件和目录，过滤筛选指定文件
        File f = new File("E:/api");
        File[] fs = f.listFiles((e)->{return e.getName().endsWith("chm");});
        for (File s : fs){
            System.out.println(s);
        }
    }
}

• 输入输出的概念

1. 把电脑硬盘上的数据读到程序中，称为输入，input，进行数据的read操作；
2. 从程序往外部设备写数据，称为输出，output，进行数据的write操作；

按照流（java提供的读写文件的类）的读写单位划分:

字节流：每次读写是以字节为单位（steam结尾）

（计算机中的所有数据存储都是以字节为单位）

  可以读取任意文件（视频、音频···）

 输入字节流       输出字节流

 InputStream      OutputStream

FileInputStream   FileOutputStream

字符流：每次读写是以字符为单位，只能读取纯文本文件（txt、java、html）

        （Read、Write结尾）

       输入字符流    输出字符流

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamDemo01 {

    public static void main(String[] args) throws IOException {
        //创建一个输入流字节对象，并为其指定要读入的对象
        FileInputStream in = new FileInputStream("E:/demo.txt");
        //输入的源文件不存在，会报错
        FileOutputStream out = new FileOutputStream("E:/demo.txt");
        //输出时文件不存在是可以自动创建的

        //in.read() 每次读到一个字节的数据，并返回，直到读完后返回-1；
        /*
        System.out.println(in.read());
        System.out.println(in.read());
        System.out.println(in.read());
        System.out.println(in.read());
        System.out.println(in.read());
         */

        /*
        int b = 0;
        while((b=in.read())!=-1){
            System.out.println(b);
        }
         */

        int b = 0;
        while((b=in.read())!=-1){
            out.write(b);
        }
        in.close();
        out.close();//关闭流的通道，释放文件

    }
}

对应在E盘中的demo.txt文件；

package Stream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;

public class StreamDemo02 {
    public static void main(String[] args) throws IOException {

        FileInputStream in = new FileInputStream("E:\\非凡英才\\1Java\\2021-12-25IO\\练习\\练习.txt");
        FileOutputStream out = new FileOutputStream("E:/demo.txt");
        //read()  write(int b) 每次只能读入写出一个字节，效率低，读写次数多

        //in.read(b); 每次读一个byte数组个字节内容，返回实际向数组装入的字节数量，读完也是返回-1；
                   byte[] b = new byte[1024];
                   int size = 0;//实际字节长度
                   in.read(b);
                   int num = 0;
                   while((size=in.read())!=-1){
                       num++;
                       System.out.println(size);
                       out.write(b,0,size);
                       //out.write(b,0,size); 每次向外写出一个byte数组个字节，从第0个开始，写size个
                   }
        System.out.println(num);//循环次数
                   in.close();
                   out.close();
    }
}