暂时存放的java代码（方便随时看）

最新推荐文章于 2024-03-13 14:30:45 发布

Lacrimosa&L

最新推荐文章于 2024-03-13 14:30:45 发布

阅读量238

点赞数

分类专栏：规划文章标签： java

本文链接：https://blog.csdn.net/AC_872767407/article/details/113902650

版权

规划专栏收录该内容

15 篇文章 0 订阅

订阅专栏

in===============================================================

1、Constuctor

Constuctor

package com.cskaoyan.io.bytestream.in;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * @description: 构造函数
 * @author: songtao@cskaoyan.onaliyun.com
 **/


public class Constuctor {
    public static void main(String[] args) throws FileNotFoundException {
        // FileInputStream的构造方法
        //FileInputStream(File file)
        File file = new File("a.txt");
        FileInputStream in = new FileInputStream(file);
        //FileInputStream(String name)
        FileInputStream fileInputStream = new FileInputStream("a.txt");
    }
}

2、ReadDemo1

package com.cskaoyan.io.bytestream.in;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

/*
    读数据的过程：
    1.创建文件字节输入流对象
    2.利用read方法读取数据
    3.close
 */
public class ReadDemo1 {
    public static void main(String[] args) throws IOException {
        // 读取单个字节
        //readSingle();

        // 读取多个字节
        //readMuti();

        FileInputStream in = new FileInputStream("a.txt");
        byte[] bytes = new byte[4];
        int readCount = in.read(bytes, 0, 2);
        System.out.println(new String(bytes,0,readCount));
        in.close();
    }

    private static void readMuti() throws IOException {
        FileInputStream in = new FileInputStream("a.txt");
        byte[] bytes = new byte[4];
        // read(byte[] b) 返回值是读取的字节个数
        int readCount = in.read(bytes);
        System.out.println(new String(bytes,0,readCount));
        // close
        in.close();
    }

    private static void readSingle() throws IOException {
        //1.创建文件字节输入流对象
        FileInputStream in = new FileInputStream("a.txt");
        //2.利用read方法读取数据
        //read()  返回 0 到 255 范围内的 int 字节值。
        // 如果因为已经到达流末尾而没有可用的字节，则返回值 -1
        // 从输入流中读取数据的下一个字节。
        int readData = in.read();
        System.out.println(readData);
        int readData2 = in.read();
        System.out.println(readData2);
        int readData3 = in.read();
        System.out.println(readData3);
        int readData4 = in.read();
        System.out.println(readData4);
        int readData5 = in.read();
        System.out.println(readData5);
        //3.close
        in.close();
    }
}

3、

package com.cskaoyan.io.bytestream.in;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class ReadDemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("a.txt");
        byte[] bytes = new byte[4];
        int readCount = in.read(bytes);
        System.out.println(new String(bytes,0,readCount));
        // 注意
        int readCount2 = in.read(bytes);
        System.out.println(new String(bytes,0,readCount2));
        in.close();
    }
}

4、

package com.cskaoyan.io.bytestream.in;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * @description: 循环读取
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class ReadDemo3 {
    public static void main(String[] args) throws IOException {
        // 循环读取数据
        // 常规方法
        //readWhile();
        // 第二种写法
        //readWhile2();

        // 字节数组循环读取
        FileInputStream in = new FileInputStream("a.txt");
        // 这个数组就相当于容器 水桶
        byte[] bytes = new byte[1024];
        // 用于接收每次读取返回的字节个数
        int readCount;
        while ((readCount = in.read(bytes)) != -1) {
            System.out.println(new String(bytes,0,readCount));
        }
        in.close();

    }

    private static void readWhile2() throws IOException {
        FileInputStream in = new FileInputStream("a.txt");
        // 装杯的写法 固定的写法
        // 定义一个int变量 接收读取到的字节值
        int readData;
        while ((readData = in.read()) != -1) {
            System.out.print(((char) readData));
        }
        in.close();
    }

    private static void readWhile() throws IOException {
        // 创建输入流对象
        FileInputStream in = new FileInputStream("a.txt");
        // 用while true读取数据
        while (true) {
            int readData = in.read();
            if (readData == -1) {
                break;
            }
            System.out.println(((char) readData));
        }
        // close
        in.close();
    }
}

out==========================================================================
1

package com.cskaoyan.io.bytestream.out;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * @description: 构造函数
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class constructorDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // FileOutputStream(File file)
        // 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
        File file = new File("a.txt");
        FileOutputStream fileOutputStream = new FileOutputStream(file);

        // FileOutputStream(String name)
        // 创建一个向具有指定名称的文件中写入数据的输出文件流。
        FileOutputStream fileOutputStream1 = new FileOutputStream("a.txt");
    }
}

package com.cskaoyan.io.bytestream.out;

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

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

/*
    需求：向文本文件当中写入abcd

    写入数据步骤：
    1.创建字节流对象
    2.使用write写数据
    3.关闭io资源

  写入过程描述：
    1.创建流对象
    2.把要传输的数据通过write方法交给流对象，write方法会将待传输的数据放入数据通道，并传输。
    3.数据传输完之后，流对象使用完后，关闭流对象
 */
public class Demo {
    public static void main(String[] args) throws IOException {
        // 写入单个字节
        //writeSingle();
        // 写入字节数组
        //writeMuti();

        // 写入字节数组的部分
        FileOutputStream out = new FileOutputStream("b.txt");
        String s = "abcd";
        byte[] bytes = s.getBytes();
        out.write(bytes,0,2);
        out.close();




    }

    private static void writeMuti() throws IOException {
        // 写入字节数组
        FileOutputStream out = new FileOutputStream("b.txt");
        String s = "abcd";
        byte[] bytes = s.getBytes();
        out.write(bytes);
        out.close();
    }

    private static void writeSingle() throws IOException {
        // 1.创建文件字节输出流对象
        FileOutputStream out = new FileOutputStream("a.txt");
        // 2.write(int b)
        // 将指定的字节写入此输出流。
        out.write(97);
        out.write(98);
        out.write(99);
        out.write(100);
        // 3.关闭资源
        out.close();
    }
}

package com.cskaoyan.io.bytestream.out;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @description: 字节流写数据的常见问题
 * @author: songtao@cskaoyan.onaliyun.com
 **/

/*
字节流写数据常见问题：
    创建字节输出流到底做了哪些事情?
      1). 创建FileOutputStream对象的时候，jvm首先到操作系统，查找目标文件
        a. 当发现目标文件不存在的时候， jvm会首先创建该目标文件(内容为空)、
          b. 当发现目标文件存在的时候, jvm默认会首先清空目标文件内容让，
          FileOutputStream, 从文件头，开始写入数据
       2). 在内存中，创建FileOutputStream对象
      3）. 在FileOutputStream对象和目标文件之间建立数据传输通道
    数据写成功后，为什么要close()?
举例：
当我们正在编辑的文档，我想要去剪切的时候，会提示操作文法完成，文件已在WPS打开，被WPS占用。
Java 流底层使用的还是操作系统内核，属于操作系统的资源，不像new出来的对象一样，
能被垃圾回收，jvm不能自己处理，只能释放资源，交还给操作系统。
一般来说，需要自己close的东西，都是用了虚拟机之外的资源，
例如端口，文件等，虚拟机无法通过垃圾回收释放这些资源，
只能显式调用close方法来释放。比如释放占用的端口网络操作数据库应用等.。
在资源有限的前提下，如果不close一直占用那么别的应用程序就无法使用。

    如何实现数据的换行?
        1.系统换行符 System.lineSeparator()
        2.win："\r\n"
          linux : "\n"
          mac: "\r"
    如何实现数据的追加写入?
        public FileOutputStream(String name, boolean append)
        通过构造方法实现文件追加功能
    给I/0流操作加上异常处理
        2种方式
 */
public class Demo2 {
    public static void main(String[] args) throws IOException {
        // 实现换行
        //write1();

        // public FileOutputStream(String name, boolean append)
        // append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处
        FileOutputStream out = new FileOutputStream("b.txt",true);
        out.write("hello".getBytes());
        out.close();

    }

    private static void write1() throws IOException {
        // 创建字节流对象
        FileOutputStream out = new FileOutputStream("a.txt");
        // 写数据
        out.write("hello".getBytes());
        // 写入换行符
        // 得到一个系统换行符
        String s = System.lineSeparator();
        out.write(s.getBytes());
        out.write("\r\n".getBytes());
        out.write("\r".getBytes());
        out.write("\n".getBytes());
        // 再写数据
        out.write("world".getBytes());
        // close
        out.close();
    }
}

buffer==================================

package com.cskaoyan.io.bytestream.buffer;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @description:
 * @author: songtao@cskaoyan.onaliyun.com
 **/

/*
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
注意：
    以这种底层流作为参数传递的流，称为包装流，处理流
    参数被称为底层流，节点流


BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

 */
public class Demo {
    public static void main(String[] args) throws IOException {
        //FileOutputStream fileOutputStream = new FileOutputStream("a.txt");
        //BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
                new FileOutputStream(new File("a.txt")));

        // 写点数据
        bufferedOutputStream.write("hello world".getBytes());




        // 采用flush方法 把缓冲区数据刷新到流中
        //bufferedOutputStream.flush();

        // 如果不close 就没有数据
        // close放法会去调用flush方法 所以不要忘记close
        bufferedOutputStream.close();
        // 对于包装流 只要关闭自己的资源就行 会自动的关闭底层资源

    }
}

文本文件复制==================================

package com.cskaoyan.io.bytestream.ex;

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

/**
 * @description: 文本复制
 * @author: songtao@cskaoyan.onaliyun.com
 **/
// 需求：把当前java文件复制到D盘
public class Ex1 {
    public static void main(String[] args) throws IOException {
        // 单个字节
        //copy1();

        // 多个字节 0ms
        // 创建文件字节输入流对象
        FileInputStream in = new FileInputStream(
                "src\\com\\cskaoyan\\io\\bytestream\\in\\Constuctor.java");
        // 创建文件字节输出流对象
        FileOutputStream out = new FileOutputStream("D:\\copy_java.txt");
        byte[] bytes = new byte[1024];
        int readCount;
        // 边读取边复制
        //System.currentTimeMillis()获取当前时间戳
        long start = System.currentTimeMillis();
        while ((readCount = in.read(bytes)) != -1) {
            out.write(bytes,0,readCount);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        // close
        in.close();
        out.close();
    }


    // 耗时5ms
    private static void copy1() throws IOException {
        // 创建文件字节输入流对象
        FileInputStream in = new FileInputStream(
                "src\\com\\cskaoyan\\io\\bytestream\\in\\Constuctor.java");
        // 创建文件字节输出流对象
        FileOutputStream out = new FileOutputStream("D:\\copy_java.txt");
        // 采用单个字节的方式复制
        int readData;
        // 边读取边复制
        //System.currentTimeMillis()获取当前时间戳
        long start = System.currentTimeMillis();
        while ((readData = in.read()) != -1) {
            out.write(readData);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        // close
        in.close();
        out.close();
    }
}

图片文件复制==================================

package com.cskaoyan.io.bytestream.ex;

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

/**
 * @description: 复制图片
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Ex2 {
    public static void main(String[] args) throws IOException {
        //第一种方式  单个字节
        //copy1();
        // 第二种方式：字节数组的方式 耗时1ms
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("D:\\mm.jpg");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("copy_mm.jpg");
        // 边读 边写
        long start = System.currentTimeMillis();


        byte[] bytes = new byte[1024];
        int readCount;
        while ((readCount = in.read(bytes)) != -1) {
            out.write(bytes,0,readCount);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        // close
        in.close();
        out.close();

    }
    // 耗时103ms
    private static void copy1() throws IOException {
        // 第一种方式  单个字节
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("D:\\mm.jpg");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("copy_mm.jpg");
        // 边读 边写
        long start = System.currentTimeMillis();
        int readData;
        while ((readData = in.read()) != -1) {
            out.write(readData);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        // close
        in.close();
        out.close();
    }
}

视频文件复制==================================

package com.cskaoyan.io.bytestream.ex;

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

/**
 * @description: 视频的复制
 * @author: songtao@cskaoyan.onaliyun.com
 **/

public class Ex3 {
    public static void main(String[] args) throws IOException {
        // 单个字节方式
        //copy1();

        // 字节数组方式 17ms
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("D:\\aa.mp4");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("copy_aa.mp4");
        // 边读边写
        // 单个字节方式
        int readCount;
        byte[] bytes = new byte[1024];
        //long start = System.currentTimeMillis();
        while ((readCount = in.read(bytes)) != -1) {
            // 写数据
            out.write(bytes,0,readCount);
        }



        //long end = System.currentTimeMillis();
        //System.out.println(end - start);
        // close
        in.close();
        out.close();
    }
    // 8716ms
    private static void copy1() throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("D:\\aa.mp4");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("copy_aa.mp4");
        // 边读边写
        // 单个字节方式
        int readData;
        long start = System.currentTimeMillis();
        while ((readData = in.read()) != -1) {
            // 写数据
            out.write(readData);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        // close
        in.close();
        out.close();
    }
}

Lacrimosa&L

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
暂时存放的java代码（方便随时看）

in===============================================================1、ConstuctorConstuctorpackage com.cskaoyan.io.bytestream.in;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;/** * @description: 构造函数 * @aut
复制链接

扫一扫