import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* @Description 字节输出流,写文件
*/
public class OutputStreamTest {
public static void main(String[] args) {
// 1. 实例化一个管道,连接文件和程序。
// 对于FileOutputStream来说,如果目标文件不存在,则会自动的创建。
// 当无法创建这个文件的时候(父级目录不存在),创建会失败,会触发 FileNotFoundException 。
try (OutputStream outputStream = new FileOutputStream("file\\day25\\dst", true)) {
// 2. 准备需要写入到这个文件中的数据
String message = "你好,师姐";
// 3. 将数据写入到输出流中,由输出流写入到文件中
outputStream.write(message.getBytes());
// 冲刷缓冲区,将缓冲区中的数据强制流动到文件中。
// 在流关闭的时候,会自动的调用。
outputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.6. 案例: 文件拷贝
2.6.1. 需求分析
实现, 将一个文件拷贝到另外一个地方。 注意, 这个不是剪切, 拷贝完成之后, 原文件还在。
实现方式: 借助两个流来完成。
- 使用字节流输入, 循环读取原文件中的数据。
- 使用字节输出流, 将每次读取到的数据, 写入到目标文件中。
2.6.2. 示例代码
import java.io.*;
/**
* @Description 使用字节流实现文件的拷贝
*/
public class FileCopy {
public static void main(String[] args) {
boolean ret = copy("C:\\Users\\luds\\Desktop\\src.mp4", "C:\\Users\\luds\\Desktop\\dst.mp4");
System.out.println(ret);
}
/**
* 实现功能: 将源文件中的数据拷贝到目标文件
* @param srcPath 原文件路径
* @param dstPath 目标文件路径
* @return 拷贝的结果
*/
private static boolean copy(String srcPath, String dstPath) {
// 1. 判断目标路径上,是否有文件存在
File dst = new File(dstPath);
if (dst.exists()) {
return false;
}
// 2. 实现文件的拷贝
try (InputStream inputStream = new FileInputStream(srcPath);
OutputStream outputStream = new FileOutputStream(dst)) {
// 拷贝的过程
// 2.1. 实例化一个字节数组
byte[] array = new byte[1024];
// 2.2. 声明一个整型变量,用来记录每次读取到了多少个字节的数据
int length = 0;
// 2.3. 循环读取数据
while ((length = inputStream.read(array)) != -1) {
// 2.4. 将读取到的数据,写入到输出流中
outputStream.write(array, 0, length);
}
// 2.5. 冲刷缓冲区
outputStream.flush();
return true;
}
catch (IOException e) {
e.printStackTrace();
return false;
}
}
}
2.7. Reader
2.7.1. Reader的简介
这是一个字符输入流。 从方向来说, 是一个输入流, 数据是从文件中流动到程序中, 是为了读取文件中的数据的。 从数据单位来说, 这个流中流动的数据是以字符为单位的。
2.7.2. 读取文件
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
* @Description 字符输入流读取数据
*/
public class ReaderTest {
public static void main(String[] args) {
// 读取过程与字节输入流完全相同,只需要将使用到的类换一下即可。
try (Reader reader = new FileReader("file\\day25\\src")) {
// 1. 实例化一个字符数组
char[] array = new char[100];
// 2. 声明一个变量,用来记录每次读取到了多少个数据
int length = 0;
// 3. 循环读取数据
while ((length = reader.read(array)) != -1) {
String str = new String(array, 0, length);
System.out.print(str);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
2.8. Writer
2.8.1. Writer的简介
字符输出流。 从方向上来分, 是一个输出流, 数据从程序中流动到文件中, 实现文件的写操作。 从流中流动的数据单位来分, 是一个字符流, 流中流动的数据是以字符为单位的。
2.8.2. 文件的写操作
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
* @Description 使用字符流写数据
*/
public class WriterTest {
public static void main(String[] args) {
// 1. 实例化相关的类
try (Writer writer = new FileWriter("file\\day25\\target", true)) {
// 2. 将数据写入到输出流中
writer.write("hello, world");
// 3. 冲刷缓冲区
writer.flush();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
2.9. 案例: 文件拷贝
2.9.1. 需求分析
实现, 将一个文件拷贝到另外一个地方。 注意, 这个不是剪切, 拷贝完成之后, 原文件还在。
实现方式: 借助两个流来完成。
- 使用字符输入流, 循环读取原文件中的数据。
- 使用字符输出流, 将每次读取到的数据, 写入到目标文件中。
2.9.2. 示例代码
/**
* 使用字符流实现文件的拷贝
* @param srcPath 原文件路径
* @param dstPath 目标文件路径
*/
private static void fileCopy2(String srcPath, String dstPath) {
// 2. 循环读取目标文件中的数据
try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
// 3. 循环读取源文件中的数据
char[] array = new char[100];
int length = 0;
while ((length = reader.read(array)) != -1) {
// 4. 将读取到的数据写入到输出流
writer.write(array, 0, length);
}
writer.flush();
return true;
}
catch (IOException e) {
e.printStackTrace();
return false;
}
}
3. 常见的其他流
3.1. 缓冲流
3.1.1. 缓冲流的简介
给普通的IO流, 套上一个缓冲区。 所有的使用缓冲流进行的读写操作, 都是和缓冲区进行交互的, 避免了频繁的IO操作。 这样一来, 带来的好处就是可以提高读写的效率。 这个缓冲区, 其实是一个数组。
常见的缓冲流:
- BufferedInputStream : 缓冲字节输入流
- BufferedOutputStream : 缓冲字节输出流
- BufferedReader : 缓冲字符输入流
- BufferedWriter : 缓冲字符输出
3.1.2. 缓冲字节流
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @Description BufferedInputStream使用
*/
public class BufferedInputStreamTest {
public static void main(String[] args) {
// 过程和InputStream一模一样的
// 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
// 在这里,BufferedInputStream构造方法中的InputStream对象,只是用来做当前的对象的实例化,在使用结束的时候,理论上来讲,是需要关闭的
// 实际在使用中,使用结束后,只需要关闭BufferedInputStream即可。
try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\day26\\source"))) {
// 1. 实例化一个字节数组
byte[] array = new byte[1024];
// 2. 声明一个整型变量,用来记录每次读取了多少个字节数据
int length = 0;
// 3. 循环读取
while ((length = bufferedInputStream.read(array)) != -1) {
// 4. 将读取到的数据转成字符串输出到控制台
String msg = new String(array, 0, length);
System.out.println(msg);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* @Description BufferedOutputStream
*/
public class BufferedOutputStreamTest {
public static void main(String[] args) {
// 1. 实例化一个缓冲字节输出流对象
try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("file\\day26\\target"))) {
// 2. 将数据写入到输出流中
bufferedOutputStream.write("hello world".getBytes());
bufferedOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.1.3. 缓冲字符流
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* @Description
*/
public class BufferedReaderTest {
public static void main(String[] args) {
// 借助一个字符流,实例化一个缓冲字符输入流
try (BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\day26\\src"))) {
// 从流中读取数据
char[] array = new char[100];
int length = 0;
while ((length = bufferedReader.read(array)) != -1) {
System.out.print(new String(array, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description
*/
public class BufferedWriterTest {
public static void main(String[] args) {
// 借助一个字符输出流,实例化一个缓冲字符输出流对象
try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
bufferedWriter.write("hello world");
bufferedWriter.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.1.4. 缓冲流中的特殊方法
BufferedReader 类中多了一个方法 readLine()
- 意义: 读取缓冲流中的一行数据, 可以逐行读取。 一直到读取到的数据是null, 表示数据读取完了, 没有下一行数据了。
- 注意事项: readLine() 是逐行读取, 但是, 只能读取到一行中的内容, 并不能读取走换行符。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
* @Date 2020/4/26
* @Description
*/
public class BufferedReaderSpecial {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"))) {
// 1. 定义一个字符串,用来接收每一行读取到的数据
String line = "";
// 2. 循环读取数据
while ((line = reader.readLine()) != null) {
// 3. 将读取到的数据输出
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
BufferedWriter 类中多了一个方法 newLine()
- 意义: 无参的方法, 写一个换行符。
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description
*/
public class BufferedWriterSpecial {
public static void main(String[] args) {
try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
bufferedWriter.write("hello world");
bufferedWriter.newLine();
bufferedWriter.write("你好,世界");
bufferedWriter.newLine();
bufferedWriter.write("end");
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用缓冲字符流进行文件的拷贝
import java.io.*;
/**
* @Description 使用缓冲字符流实现文本文件的拷贝
*/
public class BufferedCopy {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"));
BufferedWriter writer = new BufferedWriter(new FileWriter("file\\day26\\destination"))) {
String line = "";
while ((line = reader.readLine()) != null) {
writer.write(line);
writer.newLine();
}
writer.flush();
}
catch (IOException e) {
e.printStackTrace();
}
}
3.2. Scanner类
3.2.1. 简介
这个类, 并不是一个IO流。 是一个扫描器, 这个类最主要的作用, 是从一个文件中或者从一个流中浏览数据。 在这个类中封装了若干个方法, 方便了数据的读取。
3.2.2. API
注意事项
这里nextLine和BufferedReader中的readLine都可以读取一行数据。 但是区别在于: 结束条件不同。
- BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。
- Scanner: 如果没有下一行了,再去读取,会出现异常。 所以, 此时的结束条件是 hasNextLine() 为false。
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;
/**
* @Description Scanner类的方法
*/
public class ScannerTest {
public static void main(String[] args) {
// 其实,Scanner在使用结束之后,也是需要进行关闭的。 调用close方法。
try (Scanner scanner = new Scanner(new File("file\\day26\\src"))) {
// 读取文件中的内容
while (scanner.hasNextLine()) {
System.out.println(scanner.hasNextLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
3.3. 标准输入输出流
3.3.1. 简介
标准输入流: http://System.in : 连接了程序和控制台。 读取控制台中的内容。
标准输出流: System.out : 连接了程序和控制台。 将程序中的内容输出到控制台。
3.3.2. 标准输入流
import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;
/**
* @Description 标准输入流
*/
public class SystemInTest {
public static void main(String[] args) {
try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
byte[] array = new byte[128];
int length = 0;
while ((length = bis.read(array)) != -1) {
String str = new String(array, 0, length);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.3.3. 标准输出流
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
/**
* @Description 标准输出流
*/
public class SystemOutTest {
public static void main(String[] args) {
PrintStream original = System.out;
// PrintStream: 是一个打印流,可以将数据输出到指定位置。
try (PrintStream ps = new PrintStream(new FileOutputStream("file\\day26\\logs", true))) {
// ps.println("hello world!");
// 重定向标准输出流
System.setOut(ps);
System.out.println("123");
}
catch (IOException e) {
e.printStackTrace();
} finally {
System.setOut(original);
}
System.out.println("你好");
// System.out; 标准输出流地址
// System.out -> ps
}
}
3.4. 转换流
3.4.1. 为什么要用转换流
在进行文件读取的时候, 如果项目采用的字符集和文件的字符集不同,会出现乱码的情况。
3.4.2. 输入流
import java.io.*;
/**
* @Description 转换流
* 转换输入流:可以以指定的字符集读取某一个文件中的数据
* 转换输出流:可以以指定的字符集把数据写入到某一个文件
*/
public class TransforeTest {
public static void main(String[] args) {
read();
}
private static void read() {
// 当前的项目是 utf-8, 读取的文件是 GBK
### 给大家的福利
**零基础入门**
对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。
![](https://img-blog.csdnimg.cn/img_convert/95608e9062782d28f4f04f821405d99a.png)
同时每个成长路线对应的板块都有配套的视频提供:
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/a91b9e8100834e9291cfcf1695d8cd42.png#pic_center)
因篇幅有限,仅展示部分资料
网络安全面试题
![](https://img-blog.csdnimg.cn/img_convert/80674985176a4889f7bb130756893764.png)
绿盟护网行动
![](https://img-blog.csdnimg.cn/img_convert/9f3395407120bb0e1b5bf17bb6b6c743.png)
还有大家最喜欢的黑客技术
![](https://img-blog.csdnimg.cn/img_convert/5912337446dee53639406fead3d3f03c.jpeg)
**网络安全源码合集+工具包**
![](https://img-blog.csdnimg.cn/img_convert/5072ce807750c7ec721c2501c29cb7d5.png)
![](https://img-blog.csdnimg.cn/img_convert/4a5f4281817dc4613353c120c9543810.png)
**所有资料共282G**,朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》,可以扫描下方二维码领取(如遇扫码问题,可以在评论区留言领取哦)~
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友,可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**