Java常用工具——IO流

最新推荐文章于 2024-04-01 22:52:06 发布
最新推荐文章于 2024-04-01 22:52:06 发布
阅读量153 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42286362/article/details/109632523
版权

IO流

学习目标：

什么是IO流，IO流分类有哪些，IO流的功能是什么？

能够正确使用字节/字符缓冲流读写文件

能够正确处理IO流程序开发过程的异常

一、异常

概念

非正常情况，即异常就是程序出现的错误；

分类（顶层 Throwable）

a) 异常(Exception)：常说的异常，合理的应用程序可能需要捕捉的异常，如NullPointException(空指针异常)

b)错误(Error)：合理的应用程序不应该试图捕捉的问题，如StackOverFlowError(栈内存溢出)

异常处理方式

a) JVM默认的异常处理方式：在控制台打印错误信息，并终止程序；

b)开发中异常处理的方式：

♦ try—catch（finally）：捕捉异常，自己处理；

try {
    //尝试执行的代码
    //代码有异常跳到catch，没有异常则运行完直接到finally
} catch(Exception e) {
    //出现可能的异常之后的处理代码
} finally {
    //一定会执行的代码，如关闭资源
}

特点： 处理完异常后，程序会继续执行；

​ 就算之前有return，finally中的代码也会继续执行完再终止 程序；

♦throws：抛出异常，交给调用者处理,调用者必须处理异常；

pubilc void test() throws Exception {}

调用者解决异常：

a) 继续也抛出异常；特点：执行结束后，程序不在执行；

b) 采用try—catch；

try {
    //尝试执行的代码
    //代码有异常跳到catch，没有异常则运行完直接到finally
    test();
} catch(Exception e) {
    //出现可能的异常之后的处理代码
    System.out.println("代码有异常");
}
System.out.println("可以继续执行");

二、IO流

概念

I/O，即输入(Input)和输出(Output),IO流指数据像连绵的流体一样进行传输，即Java中用来传输数据的。

IO流作用

在本地磁盘和网络上操作数据；

分类

1、按数据流向分类：

♦输入流: 读取数据

♦输出流: 往外写数据

2、操作方式分类：

♦字节流

a) InputStream（字节输入流的顶层抽象类）

b) OutputStream（字节输出流的顶层抽象类）

♦字符流

a) Reader（字符输入流的顶层抽象类）

b) writer（字符输出流的顶层抽象类）

IO流体系（常用的）

1、字符流：按字符读写数据的IO流

Reader：FileReader(普通字符输入流)，BufferedReader(高效字符输入流，也叫缓冲字符输入流，自带缓冲区，大小为8192个字符，也就是16KB)

Writer：FileWriter,BufferedWriter

2、字节流：按字节读写的数据流

InputStream: FileInputStream, BufferedInputStream

OutputStream: FileOutputStream,BuferedOutputStream

三、File类

概念

文件，文件夹，一个File对象代表磁盘上的某个文件或文件夹,即就是用来操作文件（夹）路径的；

构造方法

File(String pathname)：根据字符串形式的路径来创建对应的File对象；

File(String parent, String child)：根据父目录和子目录来创建对应的File对象；

File(File parent, String child)：先将父目录封装成File对象，然后结合字符串形式的目录来获取新的File对象

成员方法（创建、判断、获取功能）

创建功能：文件不存在创建文件，存在则不创建 返回false

createNewFile()：创建文件

mkdir()和mkdirs()：创建目录

判断功能：

isDirectory()：判断File对象是否为目录

isFile()：判断File对象是否为文件

exists()：判断File对象是否存在

获取功能：

getAbsolutePath(): 获取绝对路径，以盘符开头的路径

getPath(): 获取文件的相对路径，Java中是指相对于当前项目路径来讲的

getName(): 获取文件名

list(): 获取指定目录下所有文件（夹）名称数组

listFiles(): 获取指定目录下所有文件（夹）File数组

学习代码

package filedemo;

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

/**
 * @author: @橘子先森
 * @create: 2020-11-10 19:40
 **/

/*
**概念**
文件，文件夹，一个File对象代表磁盘上的某个文件或文件夹；
**构造方法**
File(String pathname)：根据字符串形式的路径来创建对应的File对象；
File(String parent, String child)：根据父目录和子目录来创建对应的File对象；
File(File parent, String child)：先将父目录封装成File对象，然后结合字符串形式的目录来获取新的File对象
**成员方法（创建、判断、获取功能）**
createNewFile()：创建文件
mkdir()和mkdirs()：创建目录
isDirectory()：判断File对象是否为目录
isFile()：判断File对象是否为文件
exists()：判断File对象是否存在
 */
public class Test {
    //main函数是所有程序的主入口，所有的代码都是从这里开始的
    public static void main(String[] args) throws IOException {

        //需求：将 D:\abc\1.txt 封装成File对象

        //方法一: 根据字符串形式的路径获取File对象
        //注意，Java中 \ 表示转义符，复制路径中 \ 会自动填写成  \\，或者写成 /
        //File file1 = new File("D:\\abc\\1.txt");
        File file1 = new File("D:/abc/1.txt");
        System.out.println("file1 " + file1);

        //方法二：根据字符串形式的父目录和子目录创建File对象
        File file2 = new File("D:/abc/","1.txt");
        System.out.println("file2 " + file2);

        //方式三：根据父目录File对象和字符串形式的子目录来获取File对象
        File file3 = new File("D:/abc/");
        File file4 = new File(file3,"1.txt");
        System.out.println("file4 " + file4);
        System.out.println("--------------------------");

        //创建功能
        //需求：在D：盘下创建 2.txt 文件
        File  file5 = new File("D:/2.txt");
        boolean flag1 = file5.createNewFile();
        System.out.println("flag1 " + flag1);

        //需求：在D:盘下创建abc文件夹
        File file6 = new File("d:/abc");
        boolean flag2 = file6.mkdir();  //make directory;创建单级目录
        System.out.println("flag2 " + flag2);

        //需求：在D:盘下创建abc/a/b/c文件夹
        File file7 = new File("D:/abc/a/b/c");
        boolean flag3 = file7.mkdirs(); //make directories;创建多级目录，也可以单级目录
        System.out.println("flag3 " + flag3);
        System.out.println("--------------------------");

        //判断功能
        File file8 = new File("D:/abc/a");
        //boolean flag4 = file8.isDirectory();
        //System.out.println("判断是否是文件夹 " + flag4);
        System.out.println("判断是否是文件夹 " + file8.isDirectory());
        System.out.println("判断是否是文件 " + file8.isFile());
        System.out.println("判断是否存在 " + file8.exists());

        //获取功能
        //在项目中创建一个lib文件夹，在文件夹中创建 1.txt文件
        File file9 = new File("lib/1.txt");
        //获取file9的绝对路径
        String absolutePath = file9.getAbsolutePath();
        System.out.println("绝对路径： " + absolutePath);    //绝对路径： D:\JavaStudy\lib\1.txt
        //获取file9的相对路径
        String path = file9.getPath();
        System.out.println("相对路径： " + path);    //相对路径： lib\1.txt
        //获取文件名
        String name = file9.getName();
        System.out.println("文件名： " + name);     //文件名： 1.txt

        //获取lib目录下所有文件（夹）的名称数组 String[]
        File file10 = new File("lib");
        String[] list = file10.list();
        for (String s : list) {
            System.out.print("lib目录下文件（夹）的名称数组：" + s + " ");
        }

        System.out.println();

        //获取lib目录下所有文件（夹）的File对象数组 File[]
        File[] files = file10.listFiles();
        for (File file : files) {
            System.out.print("lib目录下所有文件（夹）的File对象数组:" + file +" ");
        }

    }
}

四、字符流读写文件

1、字符流读数据(两种)——按单个字符读取

♦创建字符流读文件对象(Reader是抽象类，需用其子类)

Reader reader = new FileReader("readme.txt");

♦调用方法读取数据(读取一个字符，返回该字符代表的整数 a-97（ASCII码值）,若达到流的末尾，返回 -1)

int data = reader.read();

♦异常处理

throws IOException;

♦关闭资源(节约资源，提高效率)

reader.close();

代码学习

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 10:17
 **/
public class Test {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流读取数据，lib包下的1.txt文件，内容 abc
        //1、创建字符流输入对象
        Reader reader = new FileReader("lib/1.txt"); //抛出FileNotFoundException异常
        //2、读取数据
        /*int read1 = reader.read();
        System.out.println(read1);  //a-97

        int read2 = reader.read();
        System.out.println(read2);  //a-98

        int read3 = reader.read();
        System.out.println(read3);  //a-99

        int read4 = reader.read();
        System.out.println(read4);  //读取不到数据 -1*/

        /*
            优化，循环
            因为不知道次数，所以用while循环
         */
        int read;   //ASCII码值，整数
        while ((read = reader.read()) != -1) {
            System.out.println(read);   //97 98 99
        }

        //3、释放资源
        reader.close(); //抛出IOException异常，FileNotFoundException异常属于OException异常所以可以不写
    }
}

2、字符流读数据——按字符数组读取

♦创建字符流读文件对象

Reader reader = new FileReader("readme.txt");

♦调用方法读取数据(读取字符到数组中，返回读取的 有效 字符数，若达到流的末尾，返回 -1)

c har[] chs = new char[2048];
int len = r.read(chs);

♦异常处理

throws IOException;

♦关闭资源(节约资源，提高效率)

reader.close();

代码学习

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 10:50
 **/
public class Text {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流读取数据，一次读取一个字符数组,lib包下的2.txt文件 qwertyuiop
        //1、创建字符输入流对象
        Reader reader = new FileReader("lib/2.txt");

        //2、读取数据
        //定义数组,初始长度3
        /*char[] chs = new char[3];
        int len1 = reader.read(chs);
        System.out.println(chs);    //q,w,e
        System.out.println(len1);   //3

        int len2 = reader.read(chs);
        System.out.println(chs);    //r,t,y
        System.out.println(len2);   //3

        int len3 = reader.read(chs);
        System.out.println(chs);    //u,i,o
        System.out.println(len3);   //3

        int len4 = reader.read(chs);
        System.out.println(chs);    //p,i,o 因为读取数组是覆盖，只有 g 有效覆盖了上一数组的 u
        System.out.println(len4);   //1

        int len5 = reader.read(chs);
        System.out.println(chs);    //p,i,o 没有读取到
        System.out.println(len5);   // -1*/

        /*
            优化，while循环
         */
        //定义数组
        char[] chs = new char[3];
        //定义一个变量，记录读取有效字符长度
        int len;
        while ((len = reader.read(chs)) != -1) {
            /*
                chs: 表示要操作的数组
                0: 表示起始索引
                len: 表示要操作的字符个数
             */
            //将读取到的内容，转换成字符串打印
            //String s1 = new String(chs);    //qwe rty uio pio
            String s = new String(chs,0,len);   //qwe rty uio p
            System.out.println(s);
        }

        //3、释放资源
        reader.close();
    }
}

3、字符流写数据(三种)——按单个字符写入

♦创建字符流写文件对象(Writer是抽象类，需用其子类)

Writer writer = new FileWriter("dest.txt");

♦调用方法写入数据

int a = '中'; //因为字符的底层是一个整数
writer.write(a);

♦异常处理

throws IOException;

♦关闭资源

writer.close();

4、字符流写数据——按字符数组写入

♦创建字符流写文件对象(Writer是抽象类，需用其子类)

Writer writer = new FileWriter("dest.txt");

♦调用方法写入数据

char[] chs ={'橘','子','先','森'}
writer.write(chs);

♦异常处理

throws IOException;

♦关闭资源

writer.close();

5、字符流写数据——按字符串写入

♦创建字符流写文件对象(Writer是抽象类，需用其子类)

Writer writer = new FileWriter("dest.txt");

♦调用方法写入数据

writer.write("橘子先森");

♦异常处理

throws IOException;

♦关闭资源

writer.close();

字符流写数据代码学习

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 12:05
 **/
public class WriterDemo {
    public static void main(String[] args) throws IOException {
        //通过字符流写数据
        //1、创建字符输出流对象
        Writer writer = new FileWriter("lib/1.txt");

        //2、写数据 (覆盖)
        //2.1一次写一个字符
        //writer.write('嗨');

        //2.2一次写一个指定字符数组
        //char[] chs = {'橘','子','先','森','啊'};
        //writer.write(chs);
        //writer.write(chs,2,3);  //先森啊

        //2.3一次写一个字符串
        writer.write("好好学习，天天向上");

        //3、释放资源
        writer.close();
    }
}

6、字符流拷贝文件(Reader和Writer同时使用)——按单个字符读写

♦创建字符流读文件对象(Reader是抽象类，需用其子类)

Reader reader = new FileReader("readme.txt");

♦创建字符流写文件对象(Writer是抽象类，需用其子类)

Writer writer = new FileWriter("dest.txt");

♦调用方法读取数据(读取一个字符，返回该字符代表的整数 a-97（ASCII码值）,若达到流的末尾，返回 -1)

int data = reader.read();

♦调用方法写入数据

writer.write(data);

♦异常处理

throws IOException;

♦关闭资源

reader.close();
writer.close();

代码学习

import java.io.*;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 14:07
 **/
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流拷贝文件，一次读写一个字符；将1.txt中的内容复制到2.txt文件中

        //1、创建字符流读文件对象，字符输入流对象，关联数据源文件
        //Reader reader = new FileReader("lib/1.txt");
        FileReader reader = new FileReader("lib/1.txt");

        //2、创建字符流写文件对象,字符输出流对象，关联目的地文件
        //注意：如果目的地文件不存在，程序会自动创建
        FileWriter writer = new FileWriter("lib/3.txt");

        //3、调用方法读数据，定义变量记录读取到的内容
        int len;

        //4、循环读取，只要条件满足一直读取，并将读取到的内容赋值给变量
        while ((len = reader.read()) != -1) {
            //5、调用方法写数据，将读取到的数据写入到目的地文件中
            writer.write(len);
        }

        //6、释放资源
        reader.close();
        writer.close();
    }
}

7、字符流拷贝文件(Reader和Writer同时使用)——按字符数组读写

♦创建字符流读文件对象(Reader是抽象类，需用其子类)

Reader reader = new FileReader("readme.txt");

♦创建字符流写文件对象(Writer是抽象类，需用其子类)

Writer writer = new FileWriter("dest.txt");

♦调用方法读取数据

char[] chs = new char[2048]; //最好1024整数倍，计算机底层换算单位1024

♦调用方法写入数据

writer.write(chs,0,len);

♦异常处理

throws IOException;

♦关闭资源

reader.close();writer.close();

代码学习

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 15:08
 **/
public class CopyFile2Demo {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流拷贝文件，一次读写一个字符数组
        //将1.txt文件内容复制到2.txt中

        //1、创建字符输入流对象，关联源文件
        FileReader fr = new FileReader("lib/1.txt");

        //2、创建字符输出流对象，关联目的地文件
        FileWriter fw = new FileWriter("lib/2.txt");

        //3、定义变量记录读取到的内容
        //定义一个字符数组
        char[] chs = new char[1024];    //最好1024整数倍
        //定义用来记录读取到的有效字符数
        int len;

        //4、循环读取，只要满足条件一直读取，并将读取到的内容复制给变量
        while ((len = fr.read(chs)) != -1) {
            //5、调用方法写数据，将读取到的文件写入到目的地文件中
            fw.write(chs,0,len);

        }

        //6、释放资源
        fr.close();
        fw.close();
    }
}

8、字符缓冲流拷贝文件的标准代码

(高效字符输入流，也叫缓冲字符输入流,自带缓冲区，大小为8192个字符，也就是16KB，只能拷贝 纯文本文件 )

成员方法：

readLine(); 一次读取一行数据并返回读取到的内容，读取不到返回null；

newLine();根据当前操作系统给出对应的换行符；

♦创建字符流读文件对象

BufferedReader br = new BufferedReader(new FileReader("readme.txt"));

♦创建字符流写文件对象

BufferedWriter bw = new BufferedWriter(new FileWriter("dest.txt"));

♦异常处理

throws IOException;

♦使用while循环读取数据

int len;
while ((len = br.read()) != -1) {
    bw.write(len);
}

♦关闭资源

br.close();
bw.close();

代码学习

import java.io.*;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 17:48
 **/
public class CopyFile3Demo {
    public static void main(String[] args) throws IOException {
        //需求：通过字符缓冲流流拷贝文件
        //将1.txt文件内容复制到2.txt中

        //1、创建字符输入流对象，关联源文件
        FileReader fr = new FileReader("lib/1.txt");
        BufferedReader br = new BufferedReader(fr);

        //2、创建字符输出流对象，关联目的地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));    //简化

        //3、定义变量记录读取到的内容

        int len;

        //4、循环读取，只要满足条件一直读取，并将读取到的内容复制给变量
        while ((len = br.read()) != -1) {
            //5、调用方法写数据，将读取到的文件写入到目的地文件中
            bw.write(len);

        }

        //6、释放资源
        fr.close();
        br.close();
        bw.close();
    }
}

五、字节流读写文件

1、字节流拷贝文件——按单个字节读写

♦创建字节流读文件对象

InputStream is = new FileInputStream("Desktop.jpg");

♦创建字节流写文件对象

OutputStream os = new FileOutoutStream("D:\\a.jpg");

♦异常处理

throw IOException;

♦使用while循环读写数据

int b;
while ((b = is.read()) != -1) {
    os.write(b);
}

♦关闭资源

is.close();
os.close();

代码学习

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

/**
 * @author: @橘子先森
 * @create: 2020-11-11 21:31
 **/
public class CopyFile5Demo {
    public static void main(String[] args) throws IOException {
        //需求：通过普通字节流，一次读写一个字节的方式，将a.jpg 复制到 b.jpg 中
        //1、创建字节输入流，关联数据源文件
        FileInputStream fis = new FileInputStream("lib/a.jpg");

        //2、创建字节输出流，关联目的地文件
        FileOutputStream fos = new FileOutputStream("lib/b.jpg");

        //3、定义变量，用来记录读取到的内容
        int len;

        //4、循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = fis.read()) != -1) {
            //5、将读取到的内容写入到目的地文件中
            fos.write(len);
        }

        //6、释放内存
        fis.close();
        fos.close();
    }
}

2、字节流拷贝文件——按字节数组读写

♦创建字节流读文件对象

InputStream is = new FileInputStream("Desktop.jpg");

♦创建字节流写文件对象

OutputStream os = new FileOutoutStream("D:\\a.jpg");

♦异常处理

throw IOException;

♦定义一个字节数组，每次读取2048个字节

byte[] b = new byte[2048];

♦使用while循环读写数据

int len;
while ((len = is.read(b)) != -1) {
    os.write(b,0,len);
}

♦关闭资源

is.close();
os.close();

代码学习

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

/**
 * @author: @橘子先森
 * @create: 2020-11-11 21:31
 **/
public class CopyFile6Demo {
    public static void main(String[] args) throws IOException {
        //需求：通过普通字节流，一次读写一个字节数组的方式，将a.jpg 复制到 b.jpg 中
        //1、创建字节输入流，关联数据源文件
        FileInputStream fis = new FileInputStream("lib/a.jpg");

        //2、创建字节输出流，关联目的地文件
        FileOutputStream fos = new FileOutputStream("lib/b.jpg");

        //3、定义变量，用来记录读取到的内容
        byte[] bys = new byte[2048];
        //用来记录读取到的有效字节数
        int len;

        //4、循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = fis.read()) != -1) {
            //5、将读取到的内容写入到目的地文件中
            fos.write(bys,0,len);
        }

        //6、释放内存
        fis.close();
        fos.close();
    }
}

3、字节缓冲流拷贝文件的标准代码

♦创建字节流读文件对象

InputStream is = new FileInputStream("Desktop.jpg");

♦创建字节流写文件对象

OutputStream os = new FileOutoutStream("D:\\a.jpg");

♦异常处理

throw IOException;

♦定义一个字节数组，每次读取2048个字节

byte[] b = new byte[2048];

♦使用while循环读写数据

int len;
while ((len = is.read(b)) != -1) {
    os.write(b,0,len);
}

♦关闭资源

is.close();
os.close();

代码学习

package demo1;

import java.io.*;

/**
 * @author: @橘子先森
 * @create: 2020-11-11 21:31
 **/
public class CopyFile7Demo {
    public static void main(String[] args) throws IOException {
        //需求：通过字节缓冲流，将a.jpg 复制到 b.jpg 中
        //1、创建字节输入流，关联数据源文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/a.jpg"));

        //2、创建字节输出流，关联目的地文件
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/b.jpg"));

        //3、定义变量，用来记录读取到的内容
        //用来记录读取到的有效字节数
        int len;

        //4、循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = bis.read()) != -1) {
            //5、将读取到的内容写入到目的地文件中
            bos.write(len);
        }

        //6、释放内存
        bis.close();
        bos.close();
    }
}
@橘子先森
关注
专栏目录
java基础——IO流——20200616
06-16 249
尚硅谷_Java零基础教程-java入门必备-初学者基从入门到精通全套完整版(宋红康主讲) P577-576 (*)表示仅需了解 文章目录1. File类的使用File类的实例化*路径分隔符File类的常用方法2. IO流原理及流的分类流的分类3. 节点流（或文件流）FileReader类read()每次读一个字符read() 每次读多个字符FileWriter复制文件：字符流FileInputStream、FileOutputStream复制文件：字节流4. 缓冲流BufferedInputStream
菜鸟学习笔记：Java提升篇5（IO流1——IO流的概念、字节流、字符流、缓冲流、转换流）
qq_41965041的博客
12-16 538
菜鸟学习笔记：Java OI流1——Collections工具类、其他容器IO流的原理及概念字节流InputStreamOutputStream IO流的原理及概念 在基础篇的讲解中大家已经了解了File对象以及它的一些方法（复习链接）。但是File的主要作用仅仅是建立文件和程序的联系，File对象的方法只能用于文件和目录的创建、文件的查找和文件的删除等功能，但无法对文件的内容做具体的操作。所以引入了现在所要讲的IO流知识点。 在Java程序中，对数据的输入输出操作以“流”的方式进行： 如果大家觉得不好理
javaIO流工具类，可以直接使用
06-03
/** * 实现将文件读取到一个byte数组 */ public static byte[] read2(String filename){ try{ InputStream in = new FileInputStream(filename); byte[] buf = new byte[in.available()]; in.read(buf); in.close(); return buf; }catch(IOException e){ throw new RuntimeException(e); } }
Java --- IO流
xinyuezitang的博客
03-30 234
一 IO流学习目标 二 学习IO (一) 基本概念 1 IO流 A 什么是IO流 I/O，即输入（Input）输出（Output），IO流指的是数据像连绵的流体一样进行传输。 B 作用 在本地磁盘或网络上传输（读/写）数据 C 分类 按数据流向分: 输入流 输出流 按操作方式分: 字节流： InputStream OutputStream 字符流： Reader W...
Java IO流的一个小工具
Simon的博客
06-23 457
考虑这样一种场景，你要为系统编写一个下载文件并缓存到本地的功能，你会用到InputSteam和OutputStream类，你可能会这么写...
java常用io流_Java常用工具_IO流
weixin_31613423的博客
02-13 124
1. 异常1.1 异常的概述image.png1.2 异常的处理方式Java中异常的顶层父类是Throwablefinally中的语句一定会执行，即使catch中有return，finally里的代码也会执行，这就是加不加finally的区别。image.pngimage.pngpackage cn.case5;public class Test4 {public static void main...
Java 学习笔记·十 —— Java 常用工具·IO流
un357951的博客
02-19 102
IO 流 异常 异常，非正常情况，就程序出现的错误 异常又可以更具体地分为，异常（Exception）和错误（Error） 异常（Exception） 合理的应用程序可能需要捕获的问题 错误（Error） 合理的应用程序不应该试图捕获的问题 异常的处理方式 异常的处理方式包括两种，捕获和抛出 捕获是自己处理异常，而抛出是调用者处理异常 JVM 默认的异常处理方式是：在控制台打印错误信息，并终止程序 开发中异常的处理方式 try...catch(finally) ：捕获，自己处理 try { /
java——IO流技术.pdf
04-03
### Java IO流技术详解 #### 一、IO流概述 在Java编程中，**IO流**(Input/Output Stream)主要用于实现数据的输入与输出操作。无论是文件读写、网络通信还是程序间的交互，几乎所有的数据交换都依赖于IO流。 #####...
IO流——文件操作字节流常用方法一览
12-22
在Java编程语言中，IO流（Input/Output Stream）是用来处理数据输入和输出的重要机制，尤其是在文件操作中。本文将详细解析文件操作字节流的常用方法，包括输入字节流`FileInputStream`和输出字节流`...
java常用工具类——个人总结
12-22
以下是我个人对Java中常用工具类的总结，主要涉及了加密、文件上传和日期处理等核心领域。 1. **加密工具类**： - `java.security` 包下的 `MessageDigest` 类用于实现消息摘要算法，如MD5和SHA，常用于数据完整性...
Java——常用工具_IO流
qq_42873479的博客
03-14 655
Java——常用工具_IO流异常处理try_catchthrowsIO流概述File类字符流读写文件字符流读数据字符流写数据字符流拷贝文件缓冲流普通用法字节流读写文件字节流拷贝文件字节缓冲流拷贝文件 异常处理 异常的分类（Trowable）： 异常（Exception）：合理的应用程序可能需要捕获的问题 错误（Error）：合理的应用程序不应该试图捕获的问题 异常处理方式 try…catch(finally)：捕获，字节处理 throws：抛出，交给调用者处理 try_catch 格式： try
Java IO流 之 File 工具封装 FileUtil
verejava的博客
06-12 448
http://www.verejava.com/?id=17160016947046public class Test2 { public static void main(String[] args) { FileUtil.createFile("test2.txt"); FileUtil.renameFile("test2.txt", "newT...
Java IO流 Commons-io工具包
qq_43623492的博客
02-08 784
Commons-io是apache开源基金组织提供的一组有关IO操作的开源工具包，用于提高IO流的开发效率。
java中的IO流
最新发布
2301_79600088的博客
04-01 869
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
Java常用工具类之IO流工具类
weixin_34409357的博客
01-18 982
package com.wazn.learn.util; import java.io.Closeable; import java.io.IOException; /** * IO流工具类 * * @author yangzhenyu * */ public class IOUtil { /** * 关闭一个或多个流对象 ...
Java入门学习第十五天——Java常用工具之IO流（异常、字符流、字节流、File类）
h_jQuery的博客
03-03 188
Java常用工具之IO流 根据API文档使用步骤查找并使用IO流体系中的类： 1.查找输入/输出流类 2.查看构造方法 3.创建输入/输出流对象 4.处理异常 5.读/写操作 6.关闭输入/输出设备 异常 异常：即非正常情况，通俗地说，异常就是程序出现的错误 异常的分类（Throwable 父类） 异常（Exception 子类）:合理的应用程序可能需要捕获的问题（可预料的），这个才是需要我们处理的异常 如：NullPointerException(空指针异常) 错误（Error 子类）:合理的应用程序不应
Java中第三方开源IO工具包commons和功能流(合并流)
SuPrEeMm的博客
02-05 2062
Commons commons 是 第三方开源 IO工具包/* * 获取扩展名 * static String getExtension(String filename) * 获取文件名字 * static String getName(String filename) * 判断是不是这个扩展名 * static boolean isExtension(String filen
Java中的IO流④——解压缩流/压缩流、常用工具包
qingwan_91的博客
12-12 357
Java中的IO流④——解压缩流/压缩流、常用工具包
【Java筑基】IO流基础之常见工具流和进程通信
半旧518的博客
07-26 503
转换流、推回输入流、标准输入输出流、进程通信
简单的发包工具——网络协议编辑器Java
09-12
一个常用的Java库是Netty，它提供了用于构建高性能、可扩展的网络应用程序的API。你可以使用Netty来创建一个网络协议编辑器，并使用它发送自定义的网络协议数据包。 下面是一个简单的示例代码，演示了如何使用Netty...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值