javaSE学习笔记（七）IO流

因为字节输入流可以操作任意类型的文件，比如图片音频等，文件都是以二进制形式存储，如果每次读取都返回byte，有可能在读到中间的时候遇到111111111，那么这11111111是byte类型的-1，流遇到-1就认为到达文件末尾，不会再继续读取后续内容，读取的时候用int类型接收，如果11111111会在其前面补上24个0凑足4个字节，那么byte类型的-1就变成int类型的255，这样可以保证整个数据读完，而结束标记的-1就是int类型

FileOutputStream

获取文件输出流

FileOutputStream fos = new FileOutputStream(file);

FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshi.txt"); //文件如果不存在，会自动创建，文件存在会清空该文件

FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshiOut.txt", true); //追加写入，不清空文件

方法

public void write(int b) throws IOException //通过流向文件末尾写入一个字节，虽然入参是int，但实际写入时会默认去掉前面的0

public void write(byte b[]) throws IOException

public void write(byte b[], int off, int len) throws IOException

java 复制代码

//桌面上创建一个txt文件，保存 123ceshi测试，然后操作这个文件看看效果
FileInputStream fis = new FileInputStream("C:\\Users\\Coolway26\\Desktop\\ceshi.txt");
int n=0;
StringBuffer sb = new StringBuffer();
while (n != -1)     //当n不等于-1,则代表未到末尾
{
    n = fis.read(); //读取文件的一个字节(8个二进制位),并将其由二进制转成十进制的整数返回
    char by = (char) n;    //转成字符，中文会乱码，因为中文不是单个字节存储
    sb.append(by);
}
System.out.println(sb.toString());

int m=0;
byte[] b = new byte[1024];
int i = 0;
while (m != -1)             //当n不等于-1,则代表未到末尾
{
    m = fis.read(b);        //返回实际读取到字节数组中的字节数
    System.out.println(m);
    System.out.println(Arrays.toString(b)); //每次读取后的字节数组内容，数组大小是初始化时侯定好的，没有读到数据的元素是默认值0
    System.out.println(new String(b));      //字节数组转为String，这一次不会乱码，因为字节数组完整接收了整个中文汉字
    i++;
}
fis.close();	//关流

FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshiOut.txt", true);
fos.write(99);

byte[] bytes = "这是一个测试".getBytes();
fos.write(bytes);

fos.close();


//举例：文件通过流进行复制
//方式一：一次性读取和写入，弊端:有可能会内存溢出----所以应该定义较小的数组进行流的操作
FileInputStream fis = new FileInputStream("C:\\Users\\Coolway26\\Desktop\\ceshi.txt");
FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshiOut.txt");
byte[] arr = new byte[fis.available()];	//根据文件大小做一个字节数组
fis.read(arr);	   //将文件上的所有字节读取到数组中，返回值是读入的有效字节个数
fos.write(arr);    //将数组中的所有字节一次写到了文件上，返回值是读出的有效字节个数
fis.close();
fos.close();
//方式二：通过小数组操作，这种方式很重要，通常开发中需要生成缓存文件，或者向云服务器上传文件，会使用这种方式
FileInputStream fis = new FileInputStream("C:\\Users\\Coolway26\\Desktop\\ceshi.txt");
FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshiOut.txt");
int len;
byte[] arr = new byte[1024 * 8];	//自定义字节数组，1024的整数倍，这是标准形式
while((len = fis.read(arr)) != -1) {
    //fos.write(arr);
    fos.write(arr, 0, len);	        //写出字节数组，只写出有效个字节个数，如果不限制，即使用fos.write(arr)，那么最后一次写的时候，可能会写入无效字节0，即若干个空字符
}
fis.close();
fos.close();

4.BufferedInputStream&BufferedOutputStream

通过操作小数组来读写流数据，显然比一次性读取全部，或者单个字节读写，都要可靠，因为既能保证内存不溢出，又能减少磁盘IO次数提高效率

java提供了自带的缓冲流操作BufferedInputStream&BufferedOutputStream，使用缓冲流，我们将不再需要手动定义小数组

关流时，只需要关闭缓冲流

小数组的读写和带Buffered的读取哪个更好

定义小数组如果是8192个字节大小和Buffered比较的话（1024*8）（这是缓冲区的默认大小），定义小数组会略胜一筹，因为读和写操作的是同一个数组，而Buffered操作的是两个数组

BufferedInputStream

BufferedInputStream内置了一个缓冲区(数组)，当使用BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个，程序再次读取时, 就不用找文件了, 直接从缓冲区中获取，直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个

获取缓冲输入流

FileInputStream fis = new FileInputStream("C:\\Users\\Coolway26\\Desktop\\ceshi.txt");

BufferedInputStream bis = new BufferedInputStream(fis);

BufferedOutputStream

BufferedOutputStream也内置了一个缓冲区(数组)，程序向流中写出字节时，不会直接写到文件，先写到缓冲区中，直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里

获取缓冲输出流

FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshiOut.txt");

BufferedOutputStream bos = new BufferedOutputStream(fos);

方法

public void flush(); //刷新此缓冲的输出流，这会使所有缓冲的输出字节被写出到底层输出流中，清空了缓冲区，可以继续写入

public void close() throws IOException //关闭缓冲流，关闭前会执行flush()操作

java 复制代码

//拷贝文件
FileInputStream fis = new FileInputStream("C:\\Users\\Coolway26\\Desktop\\ceshi.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("C:\\Users\\Coolway26\\Desktop\\ceshiOut.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int b;
while ((b = bis.read()) != -1) {
    bos.write(b);
}

bis.close();
bos.close();

//当然，也可以一次性读入多个字节到缓冲流，通常也是这么做的
int len;
byte[] arr = new byte[1024*8];
while ((len = bis.read(arr)) != -1) {
    bos.write(arr, 0, len);
}
bis.close();
bos.close();

5.MultipartFile（springmvc会用到）

WEB接口中接收文件，springmvc提供的简化文件流操作的接口

java 复制代码

//如果不使用MultipartFile
public String fileSave(HttpServletRequest request, HttpServletResponse response){
	MultipartHttpServletRequest msr = (MultipartHttpServletRequest) request;
    MultipartFile targetFile = msr.getFile("file");
}
//使用MultipartFile直接接收文件
public String fileSave(MultipartFile file){
    ...
}

//方法
public interface MultipartFile extends InputStreamSource {
	//返回参数的名称
    String getName();
	// 获取源文件的名称
    @Nullable
    String getOriginalFilename();
	// 返回文件的内容类型
    @Nullable
    String getContentType();
	// 判断文件内容是否为空
    boolean isEmpty();
	// 返回文件大小 以字节为单位
    long getSize();
	// 将文件内容转化成一个byte[] 返回
    byte[] getBytes() throws IOException;
	// 返回输入的文件流
    InputStream getInputStream() throws IOException;

    default Resource getResource() {
        return new MultipartFileResource(this);
    }

    void transferTo(File var1) throws IOException, IllegalStateException;
	// 将MultipartFile 转换换成 File 写入到指定路径
    default void transferTo(Path dest) throws IOException, IllegalStateException {
        FileCopyUtils.copy(this.getInputStream(), Files.newOutputStream(dest));
    }
}

//其他
//获取文件名
MultipartFile file = new MultipartFile();
String fileName = file.getOriginalFilename().substring(0,file.getOriginalFilename().lastIndexOf("."))
//获取文件后缀：这个后缀带'.'如：.zip，如果不想带'.'这样即可lastIndexOf(".")+1
MultipartFile file = new MultipartFile();
String fileSuffix = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."))

6.零拷贝（拓展了解，可以不掌握）

传统IO：一共需要拷贝四次，两次CPU拷贝，两次DMA拷贝

read()：把数据从磁盘读到内核缓冲区，从内核缓冲区再拷贝到用户缓冲区

write()：把数据写入socket缓冲区，最后写入网卡设备

零拷贝：进行数据IO时，数据在用户态下经历了零次CPU拷贝

缺点：零拷贝有一个缺点，不允许进程对文件内容作一些加工再发送，比如数据压缩后再发送

java 复制代码

#mmap+write
try {
    FileChannel readChannel = FileChannel.open(Paths.get("./jay.txt"), StandardOpenOption.READ);
    MappedByteBuffer data = readChannel.map(FileChannel.MapMode.READ_ONLY, 0, 1024 * 1024 * 40);
    FileChannel writeChannel = FileChannel.open(Paths.get("./siting.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    //数据传输
    writeChannel.write(data);
    readChannel.close();
    writeChannel.close();
}catch (Exception e){
    System.out.println(e.getMessage());
}

#sendfile
try {
    FileChannel readChannel = FileChannel.open(Paths.get("./jay.txt"), StandardOpenOption.READ);
    long len = readChannel.size();
    long position = readChannel.position();
    
    FileChannel writeChannel = FileChannel.open(Paths.get("./siting.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    //数据传输
    readChannel.transferTo(position, len, writeChannel);
    readChannel.close();
    writeChannel.close();
} catch (Exception e) {
    System.out.println(e.getMessage());
}
}