华杉研发九学习日记21 Stream流 IO流

华杉研发九学习日记21

一，Stream流

主要操作：对集合的数据进行处理，简化其代码

Collection单列集合中包含了Stream，所以其子类都可以使用Stream流进行操作

Stream流的转化

//	List-->Stream流
List<String> list = Arrays.asList("11","李四","333","小孤鸡");
Stream<String> stream = list.stream();
//	Set-->Stream流
Set<String> set = new HashSet<>(list);
Stream<String> stream2 = set.stream();
//	数组-->Stream流
String str[] = {"11","李四","333","小孤鸡"};
Stream<String> stream3 = Arrays.stream(str);
//	Stream.of
Stream<String> stream4 = Stream.of("11", "李四", "333", "小孤鸡");

方法：

List<String> list = Arrays.asList("马云", "马化腾", "马云", "俞敏洪", "马超", "范小勤", "范小勇");
//  去除重复数据并遍历     distinct
list.stream().distinct().forEach(System.out::println);
//  过滤  filter
list.stream().filter(name->name.startsWith("马")).filter(name->name.length()==2).forEach(System.out::println);
//  跳过  skip
//  限制  limit
//  计数  count
long count = list.stream().skip(3).limit(3).count();
System.out.println(count);
list.stream().skip(3).limit(3).forEach(System.out::println);

二，IO流

2.1 File类

​ 首先，当我们创建一个File对象时，指的是在内存中分配了一块数据区域，也就是说，创建一个File对象并不会在系统中真的创建一个文件或者文件夹，而只是在JVM的内存中创建了一个对象。通过这个对象能够跟磁盘打交道，从而操作底层的文件。其次，既然 File对象是“代表"磁盘中的文件，因此并不要求File对象所代表的文件或者文件夹在磁盘中一定存在。也就是说，File对象所代表的文件或者文件夹可能不存在。

概念

(1)代表硬盘上的一个文件或者文件夹。

(2) Windows中路径表示方式c:Naa.txt

(3)Java中路径表示方式:①"E:/aa/bb.txt"; ②"E:\\aa\\bb.txt"

构造器：

//  File代表的是硬盘中的文件或文件夹对象，指明的是实体
File file = new File("E:\\aa\\bb.txt");
//  判断文件是否真实存在
System.out.println(file.exists());
//  上层文件和本身文件
File file2 = new File("E:\\aa","\\bb.txt");
System.out.println(file2.exists());
//  先创建对象指明父文件，再将其作为父对象指明子文件
File part = new File("E:\\aa");
System.out.println(part.exists());
File zi = new File(part,"bb.txt");
System.out.println(zi.exists());
zi.renameTo(new File(part,"bb.txt"));

方法：

//  文件
File file = new File("E:/aa/bb.txt");
System.out.println(file.exists());
System.out.println(file.getName());
System.out.println(file.length());
//  如果文件不存在或不是文件夹，返回false
System.out.println(file.isFile());
//  如果文件夹不存在或不是文件夹，返回false
System.out.println(file.isDirectory());
file.createNewFile();
//  文件夹
File f1 = new File("E:/aa/bb/cc/dd");
System.out.println(file.exists());
System.out.println(f1.isDirectory());
//  f1.mkdir();       只能创建一级文件夹
//  创建多级文件夹
f1.mkdirs();

方法+：

File file = new File("E:/aa/bb.txt");
//  获取最后一次修改时间 --距离1970年1-1已过的毫秒数
long l = file.lastModified();
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(l)));
//  获取父文件夹
System.out.println(file.getParent());
//  获取路径
System.out.println(file.getPath());
//  删除文件夹
//file.delete();

File file1 = new File("E:\\FileHistory");
//  获取子文件夹和文件的  --名称
String[] fname = file1.list();
System.out.println(Arrays.toString(fname));
//  获取子文件夹和文件的  --对象
File[] files = file1.listFiles();
Arrays.stream(files).forEach(System.out::println);

绝对路径和相对路径
绝对路径:就是从盘符开始算起的路径I例如: D:/File/javaFile.txt

相对路径:相对于项目文件夹根目录的路径,例如: src/com/lanou/main/Test.java

创建File对象的时候,不但可以使用绝对路径,还可以使用相对路径.

//  绝对路径    从盘符出发
File file = new File("C:\\Users\\86155\\Desktop\\javasedemo\\file\\aa.txt");
System.out.println(file.exists());
//  相对路径    相对于当前项目名的下面
File file1 = new File("file\\aa.txt");
System.out.println(file1.exists());
//  获取绝对路径
System.out.println(file1.getAbsolutePath());

2.2 递归算法

递归算法就是方法自己本身调用自己本身。

注意点:

1.递归算法一定要有 终止条件
2.递归算法容易出现内存溢出异常

public static void main(String[] args) {
    print(100);   //    100--1输出
    printup(1);//   1--100输出
    System.out.println(sum(100));   //  100--1求和
    System.out.println(jie(10));        //  10的阶乘
}
public static void print(int n) {
    System.out.println(n);
    //  终止条件
    if(n==1){
        return ;
    }
    print(n-1);
}
public static void printup(int n) {
    System.out.println(n);
    //  终止条件
    if(n==100){
        return ;
    }
    printup(n+1);
}

public static int sum(int n) {
    if (n == 1) {
        return 1;
    }
    return n+sum(n-1);
}
public static int jie(int n) {
    if (n == 1) {
        return 1;
    }
    return n*jie(n-1);
}

//  传入一个文件夹对象，动态的获取文件夹下的所有的子文件对象
//  如果是文件，打印其文件名，如果是文件夹则调用自己
public static void print (File file) {
    File[] files = file.listFiles();
    for(File f : files) {
        if(f.isFile()){
            System.out.println(f.getName());
        }
        else{
            print(f);
        }
    }
}


public static void main(String[] args) {
    File f1 = new File("C:\\.......");
    print(f1);
}

2.3 IO流

IO流就是数据的输入输出流，只能操作文件对象。

什么是I0流

IO: input(输入),output(输出)。

无论输入还是输出都有源头和目的地。
对于Java来说，输入指的是从哪到哪呢?输出指的是从哪到哪呢?

Java里的输入：把数据从文件(或者网络)读取到程序里,【读取文件】
Java里的输出：把程序里的数据写入到文件（或者网络)中。【写入文件】

IO流分类

三种方式：

• 方向不同:输入流（读取文件把数据传输到程序中）输出流(写入文件把数据从程序中写入文件)

• 数据单位:字节流 字符流

• 功能不同:节点流 缓存流(过滤流)

组合:

• 字节输入输出流︰以字节的形式来操作文件内容，可以操作所有的文件

• 字符输入输出流:以字符的形式来操作文件内容，只可以操作文字类型的文件

2.4 字节流

字节流就是在操作数据流时，是以字节的形式来操作（以byte数组为媒介）。

因为计算机中所有的文件都是以字节的形式来保存，所有字节流可以用来操作所有的文件(文本 word文件exe文件图片文件视频文件音频文件…)

2.4.1 FileInputStream

FileInputStream是文件字节输入流，继承于抽象类InputStream类.用于以字节为单位读取文件.逆用于读取任意格式的文件可以读取:文本文件, word, pdf, ppt,压缩包, exe文件,等等任意类型的文件.

在系统里,任何文件都是以字节为单位存储的,所有FileInputStream可以读取任意文件

构造方法：

//  1.与文件建立连接通道   --字节输入流
//        try {
//            FileInputStream fis = new FileInputStream("file/aa.txt");
//        } catch (FileNotFoundException e) {
//            throw new RuntimeException("File not found", e);
//        }
        File file = new File("file/aa.txt");
        FileInputStream f1 = new FileInputStream(file);

方法：read

//  2.读取文件内容    --  字节  ASCLL码
        //  read一次只读一个字节
        int in1 = f1.read();
        while(in1 != -1) {
            System.out.print((char)in1);
            in1 = f1.read();
        }
        //  默认的读取方式，一个一个读取
//        int i1 = f1.read();
//        System.out.println(i1);
//        int i2 = f1.read();
//        System.out.println(i2);
//        int i3 = f1.read();
//        System.out.println(i3);
//        int i4 = f1.read();
//        System.out.println(i4);
//        int i5 = f1.read();       //  如果读取的结果为-1，则文件内容读取到末尾了
//        System.out.println(i5);

读取多个字节

//  1.建立连接
        FileInputStream fis = new FileInputStream("file/bb.txt");
        //  2.读取数据
        byte[] b = new byte[9];    //  一次读取九个字节 一个中文三个字节
        int n = fis.read(b);
        //  n ：代表的是当前从文件中真正读取的个数，也就是放入到数组中的真实的数据个数
//        System.out.println(n);
        while(n!=-1){
            //  一次将n个字节转化成字符串并输出
            String s =new String(b,0,n);
            System.out.println(s);
            n = fis.read(b);
        }
//        System.out.println(new String(b, 0, n));

//        int n;
//        while((n=fis.read())!=-1){
//            System.out.print((char)n);
//        }
//  3.释放资源
        fis.close();

2.4.2 FileOutputStream

写入文件 程序–>文件

//  如果文件不存在，则会先创建文件，然后写入数据              //  append追加（不覆盖）默认为false
FileOutputStream fos = new FileOutputStream("file/cc.txt",true);
//  写入数据
String mess = "hello world";
byte[] bytes = mess.getBytes();
fos.write(bytes);
//  释放资源
fos.close();

2.4.3 拷贝 输入输出一起用

//  拷贝的本质就是一读一写 可以拷贝任意的文件
//  1.创建字节的输入输出流
FileInputStream fis = new FileInputStream("C:\\Users\\...\\jiji.mp4");
FileOutputStream fos = new FileOutputStream("C:\\Users\\...\\jjj.mp4");
//  2.读取和写入
byte[] b = new byte[1024];
int n = 0;
while((n=fis.read(b))!=-1){
    fos.write(b,0,n);
}
//  3.释放资源  --> 先开后关
fos.close();
fis.close();

2.5 字符流

2.5.1 FileReader

FileReader是文件字符输入流。继承于抽象类Reader类.用于"*以字符为单位读取文件适用于读取纯文本文件

//  1.创建字符输入流
try {
    FileReader reader = new FileReader("file/aa.txt");
    //  2.读取
    int n = 0;
    while((n=reader.read())!=-1){
        System.out.print((char)n);
    }
    //  3.释放资源
    reader.close();
} catch (FileNotFoundException e) {
    throw new RuntimeException(e);
} catch (IOException e) {
    throw new RuntimeException(e);
}

2.5.2 FileWriter

FileWriter fw = new FileWriter("C:\\Users\\86155\\Desktop\\张晓岚\\你真的太美\\ctrl.txt",true);
//  写入数据
fw.write(48);
fw.write("你好".toCharArray());
fw.write("世界，你来了");
//  释放资源
fw.close();

拷贝：读取和写入

public static void main(String[] args) {
    //  文本
    copy("file/aa.txt", "file/dd.txt");
    //  图片      会出错
    copy("C:\\...\\jijiiji.jpg", "file/ee.jpg");

}


public static void copy(String from, String to){
    //  创建字符输入输出流
    try {
        FileReader fr = new FileReader(from);
        FileWriter fw = new FileWriter(to);
        //  读取和写入
        char ch[] = new char[1024];
        int n=0;
        while((n=fr.read(ch))!=-1){
            fw.write(ch,0,n);
        }
        //  释放资源
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }

}