先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
// 3.读完之后，关闭流
fis.close();
}
}
第二种读取方式：一次读取多个字节，多一个字节数组！
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class InputStreamTest {
public static void main(String[] args) throws Exception {
// 1.创建FileInputStream，并指定文件路径
FileInputStream fis = new FileInputStream(“d:\\aaa.txt”);
// 2.读取文件fis.read()：一个一个的读
// int data = 0;
// while ((data = fis.read()) != -1){
// System.out.println();
// }
// 2.1一次读取多个字节
byte[] buf = new byte[1024];
int count = 0;
while ((count = fis.read(buf)) != -1){
System.out.println(new String(buf, 0, count)); // abcdefg
}
// 3.读完之后，关闭流
fis.close();
}
}
- 文件字节输出流：
FileOutputStream——写入文件
public class FilterOutputStream extends OutputStream
这个类是过滤输出流的所有类的超类。 这些流位于已经存在的输出流（ 底层 输出流） 之上 ，它使用它作为数据的基本接收器，但是可能沿着数据方向转换或提供附加功能。
构造方法：
常用方法：
public int write(byte[] b)
一次写多个字节，将b数组中的所有字节，写入输出流中！
【参考代码】
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class FileOutPutStreamTest {
public static void main(String[] args) throws Exception {
// 创建文件输出流
FileOutputStream fos = new FileOutputStream(“d:\\bbb.txt”,true); // 加true后新的字节不会覆盖原字节
// 读入多个字节
String str = “abcdef”;
fos.write(str.getBytes());
// 关闭流
fos.close();
System.out.println(“加载完毕！”);
}
}
注：如果是文本文件最好用字符流
案例：使用文件字节流进行文件复制
复制文件：利用文件字节流，一边读取，一边写入！
注：使用字节流可以复制任意文件，而字符流却不行！
【参考代码】
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileCopyDemon {
public static void main(String[] args) throws Exception{
// 创建文件输入流
FileInputStream fis = new FileInputStream(“d:\\bbb.txt”);
// 创建文件输出流
FileOutputStream fos = new FileOutputStream(“d:\\ccc.txt”);
//复制文件：一边读取，一边写入
byte[] buf = new byte[1024];
int count = 0;// count实际读取的个数
while ((count = fis.read(buf)) != -1){
fos.write(buf, 0, count);
}
fis.close();
fos.close();
System.out.println(“复制完毕！”);
}
}
文件字节缓冲流
缓冲流： BufferedInputStream/BufferedOutputStream 。提高IO效率，减少访问磁盘的次数；数据存储在缓冲区， flush 是将缓冲区的内容写入文件中，也可以直接 close 。
- 字节输入缓冲流：
BufferedInputStream——快速读取文件
BufferedInputStream 为另一个输入流添加了功能，即缓冲输入和支持 mark 和 reset 方法的功能。 当创建 BufferedInputStream 时，将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次有多个字节。 mark 操作会记住输入流中的一点，并且 reset 操作会导致从最近的 mark 操作之后读取的所有字节在从包含的输入流中取出新的字节之前重新读取。
构造方法：
常用方法：
【参考代码】
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class BufferedInputStreamDemon {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream(“d:\\aaa.txt”);
//1. 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(fis); // 维护字节流，从缓冲区读取字节，加快效率
//2. 读取
int data = 0;
while((data = bis.read()) != -1){
System.out.println((char) data);
}
//3. 关闭缓冲流
bis.close();
}
}
- 字节输出缓冲流：
BufferedOutputStream——快速写入文件
该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，不必为写入的每个字节导致底层系统的调用。
构造方法：
常用方法：
【参考代码】
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
public class BufferedOutputStreamDemon {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream(“d:\\buff.txt”);
//1. 创建输出缓冲流
BufferedOutputStream bos = new BufferedOutputStream(fos);
//2. 写入文件
String str = “hello”;
for(int i = 0; i <= 5; i ++){
bos.write(str.getBytes()); // 写入8k缓冲区
bos.flush(); // 刷新到硬盘
}
//3. 关闭流(内部调用)
fos.close(flush方法);
}
}
四、编码方式
注：当编码方式和解码方式不一致时，就会出现乱码！
五、字符流
引入：3个字节相当于一个字符，当我们要读取汉字（字符）时，如果用字节流来读取的话，他是一个一个字节读取的，最终的结果是字节，而不是我们想要的字符了！
字符流的两个父类（抽象类）：
Reader：字符输入流
常用方法：
public int read() {}
public int read(char[] c) {}
public int read(char[] b, int off, int len) {}
Write：字符输出流
常用方法：
public void write(int n) {}
public void write(String str) {}
public void write(char[] c) {}
文件字符流
FileReader——文件字符输入流
阅读字符文件的便利课。 该类的构造函数假定默认字符编码和默认字节缓冲区大小是适当的。 要自己指定这些值，请在FileInputStream上构造一个InputStreamReader。
FileReader 是用于读取字符流。 要读取原始字节流，请考虑使用 FileInputStream 。
public class FileReader extends InputStreamReader
构造方法：
常用方法：继承父类！
public int read(char[] c);
从流中读取多个字符，讲读到内容存入c数组，返回实际读到的字符数；如果文件达到尾部，则返回-1.
【参考代码】
import java.io.FileReader;
public class FileReaderDemon {
public static void main(String[] args) throws Exception{
//1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader(“d:\\hello.txt”);
//2. 读取
//2.1 单个读取
// int data = 0;
// while ((data = fr.read()) != -1){ // 读取一个字符！
// System.out.println((char)data);
// }
char[] buf = new char[1024];
int count = 0;
while((count = fr.read(buf)) != -1){
System.out.println(new String(buf, 0, count));
}
//3. 关闭
fr.close();
}
}
FileWriter——文件字符输出流
public void write(String str);
一次写入多个字符，将b数组中所有字符，写入输出流；
【参考代码】
import java.io.FileWriter;
public class FileWriterDemon {
public static void main(String[] args) throws Exception{
//1. 创建FileWriter对象
FileWriter fw = new FileWriter(“d:\\write.txt”);
//2. 写入字符
String str = “防不胜防”;
for(int i = 0; i < str.length(); i ++){
fw.write(str);
fw.flush();
}
//3. 关闭
fw.close();
System.out.println(“执行完毕”);
}
}
案例：文件字符流实现文本文件复制
注： FileReader、FileWriter 只能复制文本文件，不能复制图片或者二进制文件！—— 文本文件有字符编码！
【参考代码】
import java.io.FileReader;
import java.io.FileWriter;
public class CopyDemon {
public static void main(String[] args) throws Exception{
//1. 创建FileReader FileWriter 对象
FileReader fr = new FileReader(“d:\\write.txt”);
FileWriter fw = new FileWriter(“d:\\write2.txt”);
//2. 读写
int data = 0;
while((data = fr.read()) != -1){
fw.write(data);
fw.flush();
}
//3. 关闭
fr.close();
fw.close();
System.out.println(“复制完毕！”);
}
}
字符缓冲流
字符缓冲流： BufferedReader/BufferedWriter
（1）高效读写
（2）支持输入换行
（3）可一次写一行，读一行。
BufferedReader——字符缓冲输入流
从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。
通常，由读取器做出的每个读取请求将引起对底层字符或字节流的相应读取请求。 因此，建议将BufferedReader包装在其read（）操 作可能昂贵的读取器上，例如FileReader
BufferedReader in = new BufferedReader(new FileReader(“foo.in”));
将缓冲指定文件的输入。 没有缓冲，每次调用read（）或readLine（）可能会导致从文件中读取字节，转换成字符，然后返回，这可能非常低效。
构造方法：
常用方法：
【参考代码】
``
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 字符缓冲流读取文件
*/
public class BufferedReaderDemon {
public static void main(String[] args) throws Exception{
//1. 创建缓冲流
FileReader fr = new FileReader(“d:\\write.txt”);
BufferedReader br = new BufferedReader(fr);
//2. 读取
//2.1 第一种读取方式
// char[] buf = new char[1024];
// int count = 0;
// while ((count = br.read(buf)) != -1){
// System.out.println(new String(buf, 0, count));
// }
//2.2 第二种读取方式。 一行一行的读取
String line = null;
while ((line = br.readLine()) != null){
System.out.println(line);
}
//3. 关闭
br.close();
}
}
BufferedWriter——字符缓冲输出流（写入字符）
将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
可以指定缓冲区大小，或者可以接受默认大小。 默认值足够大，可用于大多数用途。
提供了一个newLine（）方法，它使用平台自己的系统属性 line.separator 定义的行分隔符概念。 并非所有平台都使用换行符（‘\ n’）来终止行。 因此，调用此方法来终止每个输出行，因此优选直接写入换行符。
构造方法：
常用方法：
【参考代码】
import java.io.BufferedWriter;
import java.io.FileWriter;
public class BufferedWriterDemon {
public static void main(String[] args) throws Exception{
//1. 创建BufferedWriter对象
FileWriter fw = new FileWriter(“d:\\buffer.txt”);
BufferedWriter bw = new BufferedWriter(fw);
//2. 写入
for (int i = 0; i < 5; i ++){
bw.write(“好好学习吧！”);
bw.newLine();// 换行！
bw.flush();
}
//3. 关闭
bw.close();
}
}
打印流
PrintWriter——打印流
将对象的格式表示打印到文本输出流。 这个类实现了全部在发现 print种 方法 PrintStream。 它不包含用于编写原始字节的方法，程序应使用未编码的字节流。
不像类，如果启用自动刷新，它只会在调用的 println，printf， 或 format 方法来完成，而不是当一个换行符恰好是输出。 这些方法使用平台自己的行分隔符而不是换行符。
转换流
转换流： InputStreamReader/OutputStreamWriter
（1）可以将字节流转为字符流
（2）可设置字符的编码方式
转换流的使用：
InputStreamReader读取文件
【参考代码】
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class ZhuanHuanLiuTest {
public static void main(String[] args) throws Exception{
//1. 创建InputStreamReader对象
FileInputStream fis = new FileInputStream(“d:\\write.txt”);
InputStreamReader isr = new InputStreamReader(fis, “utf-8”); // 转换流设置编码方式
//2.读取文件
int data = 0;
while ((data = isr.read()) != -1){
System.out.println((char) data);
}
//3. 关闭
isr.close();
}
}
OutputStreamWriter——写入文件
【参考代码】
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class ZhuanHuanLiuTest {
public static void main(String[] args) throws Exception{
//1. 创建OutputStreamWriter对象
FileOutputStream fos = new FileOutputStream(“d:\\info.txt”);
OutputStreamWriter osw = new OutputStreamWriter(fos, “gbk”); // 转换流设置编码方式
//2. 写入
for(int i = 0; i < 5; i ++){
osw.write(“我爱学习\r\n”);
osw.flush();
}
//3. 关闭
osw.close();
}
}
六、对象流
对象流： ObjectInputStream/ObjectOutputStream 。
（1）增强了缓冲区功能
（2）增强了读取8种基本数据类型和字符串功能
（3）增强了读写对象的功能：
readObject() 从流中读取一个对象（反序列化）
writeObject(Object obj) 向流中写入一个对象（序列化）
使用流传输对象的过程称为序列化，和反序列化。
- 对象输出流：
ObjectOutputStream——序列化（写入对象）
ObjectOutputStream将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以 通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象。
构造方法：
常用方法：
【参考代码】
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectOutputStreamDemon {
/**
* 使用ObjectOutputStream实现对象的序列化————读入对象
* 要求：序列化类必须实现接口
*/
public static void main(String[] args) throws Exception{
//1. 创建对象流
FileOutputStream fos = new FileOutputStream(“d:\\stu.bin”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2. 序列化（写入操作）
Student student = new Student(“张三”,19);
oos.writeObject(student);
//3. 关闭(自带flush()方法了)
oos.close();
System.out.println(“序列化完毕”);
}
}
class Student implements Serializable {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return “Student{” +
“name='” + name + ‘\’’ +
“, age=” + age +
‘}’;
}
}
使用ObjectOutputStream实现对象的序列化————写入对象
要求：序列化类必须实现接口
- 对象输入流：
ObjectInputStream——反序列化（读取重构成对象）
ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象。
构造方法：
常用方法：
【参考代码】
import java.io.*;
public class ObjectInputStreamDemon {
public static void main(String[] args) throws Exception{
//1. 创建对象流
FileInputStream fis = new FileInputStream(“d:\\stu.bin”);
ObjectInputStream ois = new ObjectInputStream(fis);
//2. 读取文件（反序列化）
Student st = (Student) ois.readObject();
//3. 关闭
ois.close();
System.out.println(st.toString());// Student{name=‘张三’, age=19}
}
}
最后
Java架构进阶面试及知识点文档笔记
这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理
Java分布式高级面试问题解析文档
其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！
互联网Java程序员面试必备问题解析及文档学习笔记
Java架构进阶视频解析合集
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
构造方法：
常用方法：
【参考代码】
import java.io.*;
public class ObjectInputStreamDemon {
public static void main(String[] args) throws Exception{
//1. 创建对象流
FileInputStream fis = new FileInputStream(“d:\\stu.bin”);
ObjectInputStream ois = new ObjectInputStream(fis);
//2. 读取文件（反序列化）
Student st = (Student) ois.readObject();
//3. 关闭
ois.close();
System.out.println(st.toString());// Student{name=‘张三’, age=19}
}
}
最后
Java架构进阶面试及知识点文档笔记
这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理
[外链图片转存中…(img-MpIkUqs6-1713628200154)]
Java分布式高级面试问题解析文档
其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！
[外链图片转存中…(img-3inAyJmA-1713628200155)]
互联网Java程序员面试必备问题解析及文档学习笔记
[外链图片转存中…(img-vnkMwWU1-1713628200155)]
Java架构进阶视频解析合集
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-WoP6A7wD-1713628200156)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
