java入门基础十三(File和IO流)

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量152 收藏
点赞数 3
分类专栏： java入门基础 文章标签： java eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DengShuo_shuai/article/details/119831002
版权

17 File

含义：

  1. file是文件和目录路径的抽象表示

  2. File只关注文件本身的信息，而不能操作文件里面的内容

  3. File类 – 表示文件或文件夹，不能对文件里的数据进行操作

    对文件里的数据进行操作的是：IO流

17.1 File对象

绝对路径：

File file = new File("D:\\A\\1.txt");

相对路径：

File file = new File("file01\\test.txt");

浅显来看，绝对路径是有C:这样的硬盘路径，而相对路径则没有。

绝对路径是基于整个操作系统来说的，而相对路径则是要相对于某个绝对路径来说（项目的路径）。

注：

17.2 获取文件信息

简单示例：

File file = new File("D:\\A\\1.txt");
System.out.println("获取文件绝对路径："+file.getAbsolutePath());
System.out.println("获取文件名："+file.getName());
System.out.println("文件是否可读："+file.canRead());
System.out.println("文件是否可写："+file.canWrite());
System.out.println("文件是否隐藏："+file.isHidden());
System.out.println("获取文件长度："+file.length());
System.out.println("判断是否是文件："+file.isFile());
System.out.println("判断是否是文件夹："+file.isDirectory());
System.out.println("判断文件是否存在："+file.exists());

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println("文件最后修改的时间："+sdf.format(file.lastModified()));

如果相对路径下的文件不存在，可以使用createNewFile();方法创建文件。

File file = new File("file01\\test.txt");

System.out.println("获取文件绝对路径："+file.getAbsolutePath());

//判断该文件是否存在，如果不存在就创建
if(!file.exists()){
    file.createNewFile();//创建文件方法。
}

17.3 创建文件夹和文件

创建文件夹：mkdirs();

创建文件：createNewFile();

示例：（通过路径判断是否存在文件，如果不存在就创建。）

File file = new File("file01\\file02\\test1.txt");

//获取父路径对象
File parentFile = file.getParentFile();

//如果文件夹路径不存在，就创建对应路径的文件夹
if(!parentFile.exists()){
    parentFile.mkdirs();
}
//判断文件是否存在，不存在就创建文件
if(!file.exists()){
    file.createNewFile();
}

17.4 检索文件目录

17.4.1 遍历文件夹（不考虑子文件夹）

获取当前文件夹下的所有文件（包括文件夹）：listFiles();

File file = new File("D:\\Test");
	
File[] files = file.listFiles();
for (File f : files) {
    System.out.println(f.getName()+" -- "+f.canRead());
}

拓展：使用过滤器检索遍历（查询当前文件夹下的txt文件）

File file = new File("D:\\Test");
	
File[] files = file.listFiles(new FilenameFilter() {

    @Override
    public boolean accept(File dir, String name) {
        File f = new File(dir,name);
        if(f.isFile()&&f.getName().endsWith(".txt"))
            return true;
        else 
            return false;
    }
});
//经过过滤器，在files中装入的都是符合条件的File对象。
for (File f : files) {
    System.out.println(f.getName()+" -- "+f.canRead());
}

17.4.2 检索文件（考虑子文件夹）

使用检索文件时，常常需要遍历整个文件夹下的文件（包括子文件目录），此时需要使用递归的方法。

public class Test {

	public static void main(String[] args) {
		File file = new File("file01");		
		method(file, ".txt");
		
	}
	public static void method(File file,String str){
		File[] files = file.listFiles();
		for (File f : files) {
            //判断是否是文件夹
			if(f.isDirectory()){
				method(f,str);//如果是文件夹，继续调用method方法。将文件夹传入方法。
			}
            //如果不是文件夹，则判断是否符合检索条件
			else if(f.getName().endsWith(".txt")){
				System.out.println(f.getName());
			}
		}
	}
}

17.4 删除文件夹

注：在删除文件夹时，不能直接删除，因为当文件夹中含有其他文件时，无法直接删除，必须要先将文件夹内部的文件逐步删除，使用的递归思想和检索文件类似。

public class Test {
	
	public static void main(String[] args) {
		File file = new File("D:\\Test");
	
		method(file);
		
	}
	
	public static void method(File file){
		File[] listFiles = file.listFiles();
		for (File f : listFiles) {
			if(f.isDirectory()){//文件夹
				method(f);
				f.delete();
			}else if(f.isFile()){//文件
				f.delete();
			}
		}
	}
}

18 IO流

18.1 IO流的含义

注：站在程序的角度

I：In ，输入流，read读取（读取文件中的数据）

O：Out，输出流，writer写入（向文件里写入数据）

流：一点点的读取或者写入

单位：

1024KB = 1MB

1024MB= 1GB

1024GB = 1TB

1024TB = 1PB

进制：1024

18.2 分流

按照方向分：输入流、输出流

按照单位分：字节流、字符流

按照功能分：节点流/基础流、处理流

18.3 字节流

InputStream 字节输入流的基类（抽象类）

OutputStream 字节输出流的基类（抽象类）

FileInputStream extends InputStream 文件字节输入流

FileOutputStream extends OutputStream 文件字节输出流

示例：

  1. 使用文件字节输入流（FileInputStream ）向文件中添加数据。
//1.创建流对象
//FileOutputStream fos = new FileOutputStream("io.txt");
//设置成在文件末尾追加
FileOutputStream fos = new FileOutputStream("io.txt",true);

//2.写入数据
fos.write(97);//写入ASCII
fos.write("123abc".getBytes());//写入字节数组
fos.write("123abc".getBytes(),2,3);//写入字节数组，偏移量，写入字节个数

//3.关流
fos.close();
  1. 使用文件字节输出流（FileOutputStream ）从文件中读取数据。
//1.创建流对象
FileInputStream fis = new FileInputStream("io.txt");

//2.读取数据1
//int read = fis.read();//读取第一个字节，返回ASCII
//System.out.println(read);

//2.读取数据2
//读取数据 read()依次读取单个字节，读取到文件末尾返回-1
//int read;
//while((read=fis.read()) != -1){
//    System.out.print((char)read);
//}

//2.读取数据3
byte[] bs = new byte[1024];
int len;
while((len = fis.read(bs)) != -1){
    System.out.println(new String(bs, 0, len));
}

//3.关流
fis.close();

3.使用字节流复制字节文件。

FileInputStream fis = new FileInputStream("test1.txt");
FileOutputStream fos = new FileOutputStream("copy.txt");

byte [] bs=new byte [1024];
int len;
while((len=fis.read(bs))!=-1){
    fos.write(bs, 0, len);
}	
fis.close();
fos.close();
}

FilterInputStream extends InputStream 过滤器字节输入流

FilterOutputStream extends OutputStream 过滤器字节输出流

BufferedInputStream extends InputStream 带有缓冲区的字节输入流

BufferedOutputStream extends OutputStream 带有缓冲区的字节输出流

默认缓冲区大小：8192字节

示例：

  1. 使用带有缓冲区的字节输出流BufferedOutputStream 向文件中添加数据
//BufferedOutputStream 带有缓冲区的字节输出流
		
//1.创建流对象(文件末尾追加)
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test1.txt",true));

//2.写入文件
bos.write("12345".getBytes());   //12345
bos.write("12345".getBytes(),2,3);  //12345345

//3.关闭流资源
bos.close();
  1. 使用带有缓冲区的字节输入流BufferedInputStream 从文件中读取数据
//BufferedInputStream 带有缓冲区的字节输入流

//1.创建流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test1.txt"));

//2.读取文件
byte[] bs=new byte[1024];
int len;
while((len=bis.read(bs))!=-1){
    System.out.println(new String(bs, 0, len));
}
//3.关闭流资源

bis.close();
}
  1. 复制视频（.mp4）文件
BufferedInputStream bis = null;
BufferedOutputStream bos = null;

try {
    bis = new BufferedInputStream(new FileInputStream("test1.mp4"));
    bos = new BufferedOutputStream(new FileOutputStream("copy.mp4"));
    
    byte[] bs = new byte[4];
    int len;
    while ((len = bis.read(bs)) != -1) {
        bos.write(bs, 0, len);
    } 
}catch (FileNotFoundException e) {
    e.printStackTrace(); 
}catch (IOException e) {
    e.printStackTrace();
}
finally{
    if(bis != null){
        try {
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if(bos != null){
        try {
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注：1.在向文件中添加数据时，若路径下没有文件，将会默认创建文件。

​ 2.使用字节流时，不能出现文字等字符，若需操作含有字符的文件，可以使用字符流。

使用区别：
在这里插入图片描述

18.4 字符流

Reader 字符输入流的基类（抽象类）

Writer 字符输出流的基类（抽象类）

InputStreamReader extends Reader 字符输入转换流（字节流转换字符流）

OutputStreamWriter extends Writer 字符输出转换流（字节流转换字符流）

应用场景：获取到的流是字节流，但是要去做字符操作

注意：使用转换流一般都加上编码格式

示例：

  1. 使用 字符输出转换流（OutputStreamWriter ）向文件中添加数据。
//1.创建流对象
		
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test1.txt"));
//设置编码格式
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test1.txt"),"UTF-8");
//文件末尾写入
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test1.txt",true),"UTF-8");
//2.写入数据

osw.write(97);//写入ASCII码
//写入字符数组
osw.write("晚风依旧很温柔~~~".toCharArray(), 2, 5);
//写入字符串
osw.write("晚风依旧很温柔~~~");
osw.write("晚风依旧很温柔~~~",7,3);

//3.关闭资源
osw.close();
  1. 使用 字符输入转换流（InputStreamWriter ）从文件中读取数据。
//1.创建流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("test1.txt"));

//2.读取数据1,单个读取
int read;
while((read = isr.read()) != -1){
    System.out.println((char)read);
}

//2.读取数据2，多个读取
char [] read=new char [1024];
int len;
while((len = isr.read(read)) != -1){
    System.out.println(new String(read,0,len));
}
//3.关闭资源
isr.close();

3.复制文本文件

//创建流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("test1.txt"));

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("copy.txt"));

char[] cs =new char[1024];
int len;
while((len=isr.read(cs))!=-1){
    osw.write(cs,0,len);
}
isr.close();
osw.close();

FileReader extends InputStreamReader 文件字符输入流

FileWriter extends OutputStreamWriter 文件字符输出流

示例：

  1. 使用文件字符输出流（FileWriter ）向文件中添加字符数据
FileWriter fw = new FileWriter("test1.txt");
fw.write("晚风依旧很温柔~~~");
fw.close();
  1. 使用文件字符输入流（FileReader ）从文件中获取字符数据
FileReader fr = new FileReader("test1.txt");

char[] cs =new char[1024];
int len;
while((len=fr.read(cs))!=-1){
    System.out.println(new String(cs,0,len));
}
fr.close();
  1. 复制文件
FileReader fr = new FileReader("test1.txt");
FileWriter fw = new FileWriter("copy.txt");
char[] cs =new char[1024];
int len;
while((len=fr.read(cs))!=-1){
    fw.write(cs,0,len);
}
fr.close();
fw.close();

BufferedReader extends Reader 带有缓冲区的字符输入流

BufferedWriter extends Writer 带有缓冲区的字符输出流

默认缓冲区大小：8192字符

示例：

  1. 使用带有缓冲区的字符输出流（BufferedWriter）向文件中添加字符数据
//BufferedWriter 带有缓冲区的字符输出流

//默认缓冲区：8192字符
BufferedWriter bw = new BufferedWriter(new FileWriter("test1.txt"));
//自定义缓冲区大小
//BufferedWriter bw = new BufferedWriter(new FileWriter("test1.txt"),1000);
//在文件末尾追加
//BufferedWriter bw = new BufferedWriter(new FileWriter("test1.txt",true));

//写入数据
bw.write("BufferedWriter 晚风依旧很温柔~~~");
//关闭资源
bw.close();
  1. 使用带有缓冲区的字符输入流（BufferedReader ）从文件中获取字符数据
//BufferedReader 带缓存区的字符输入流		
//创建流对象
BufferedReader br = new BufferedReader(new FileReader("test1.txt"));

//读出数据1
char [] cs =new char[1024];
int len;
while((len=br.read(cs))!=-1){
    System.out.println(new String(cs,0,len));
}

//读取数据2：单行读取
String line;
while((line=br.readLine())!=null){
    System.out.println(line);
}
//关闭资源
br.close();
  1. 复制文件1（依次复制会失去原有格式）
BufferedReader br = new BufferedReader(new FileReader("test1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));

char[] cs =new char[1024];
int len;
while((len=br.read(cs))!=-1){
    bw.write(cs,0,len);
}

br.close();
bw.close();
  1. 复制文件2（单行的复制）
BufferedReader br = new BufferedReader(new FileReader("test1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));

char[] cs =new char[1024];
String line;
while((line=br.readLine())!=null){
    bw.write(line);//单行添加字符到文件
    bw.newLine();//手动加入换行
}	
br.close();
bw.close();

注：1.使用字符的输入输出转换流时，一般手动加上编码格式，以免读出的字符乱码。

​ 2.在复制文本文件时，如果直接依照字符数组复制，会导致复制后的文件失去原有的格式，所有的字符都在文件第一行中，而显示异常。所有需要单行读取和单行添加，并且要在每次添加之后手动再添加一个换行。（复制的文件会比原来的文件多上一行）

使用区别：
在这里插入图片描述

拓展：

以上流的复制文件都是针对单个文件，而对整个文件夹的复制可见java例题
复制整个文件夹到指定文件夹下

18.5 各种流

18.5.1 对象流

ObjectInputStream 对象输入流

ObjectOutputStream 对象输出流

序列化概念：

序列化：将程序中的对象写入到文件中 — 钝化

反序列化：将文件中的对象读取到程序中 — 活化

注：

  1. 一个类的对象要想通过对象流写入到文件中，该类就必须实现序列化接口（Serializable）

  2. Serializable叫做序列化接口，该接口没有让我们去实现任何的方法，这种接口叫做标记型接口

  1. transient修饰属性后，该属性不会随着对象写入到文件中

  2. static静态属性也不会随着对象写入到文件中

  3. 对象写入文件之后，会特殊编码，只能够通过对象输出流获取，且获取的顺序要和写入一致。

示例1：

写入常见类对象

//ObjectOutputStream 对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

oos.writeInt(500);
oos.writeDouble(20.2);
oos.writeObject(new Date());

oos.close();

获取写入的对象

//ObjectInputStream 对象输入流
		
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

int readInt = ois.readInt(); //500

double readDouble = ois.readDouble();//20.2

Date date = (Date)ois.readObject();//装入时的时间

System.out.println(readInt);
System.out.println(readDouble);
System.out.println(date);

示例2：

自定义对象类

import java.io.Serializable;

public class Student implements Serializable{//实现序列化接口
   
    //手动设置序列化版本号
	private static final long serialVersionUID = 1L;
	private String name;
	private String carldId;
	
	//构造方法
	public Student() {	
	}

	public Student(String name, String carldId) {
		this.name = name;
		this.carldId = carldId;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getCarldId() {
		return carldId;
	}

	public void setCarldId(String carldId) {
		this.carldId = carldId;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", carldId=" + carldId + "]";
	}	
}

写入自定义对象

//ObjectOutputStream 对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

oos.writeObject(new Student("小红","001"));
oos.writeObject(new Student("小张","002"));
oos.writeObject(new Student("小明","003"));
oos.writeObject(null);
oos.close();

读取自定义对象

//ObjectInputStream 对象输入流
		
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

Student stu;
while((stu=(Student)ois.readObject())!=null){
    System.out.println(stu);
}
ois.close();

写入自定义对象注意：

  1. 在自定义类中必须需要实现序列化接口（implements Serializable）。
  2. 手动设置序列化版本号（非必须，但若是不手动设置，在写入对象之后，一旦自定义类发生结构发生变化（如增加成员方法…等）都会导致默认的序列化版本号发生变化，从而无法被读出。）
  3. 小技巧：在写入对象时，可以在末尾写入一个null对象，这样在循环依次获取这个文件中的对象时，可以使用null对象为结束标志。

18.5.2 打印流

18.5.2.1 PrintStream

字节打印流

示例:

//创建流对象
//PrintStream ps = new PrintStream("test1.txt");

//FileOutputStream -> PrintStream (在文件末尾追加)
PrintStream ps = new PrintStream(new FileOutputStream("test1.txt",true));
ps.println("输了你，赢了世界又如何~~~~");
ps.close();
18.5.2.2 PrintWriter

字符打印流

示例：

//PrintWriter pw = new PrintWriter("test1.txt");

//FileOutputStream -> PrintWriter (在文件末尾追加) 文件字节流转化为字符打印流
//PrintWriter pw = new PrintWriter(new FileOutputStream("test1.txt",true));

//FileWriter--->PrintWriter 文件字符流转化为字符打印流
PrintWriter pw = new PrintWriter(new FileWriter("test1.txt",true));
pw.println("我想我永远不会懂~~~");
pw.close();
18.5.2.3 重定向

获取系统标准的输入流（方向：控制台->程序）：
InputStream in = System.in;

获取系统标准的输出流：（方向：程序->控制台）：
PrintStream out = System.out;

知识点：重定向 System.in

//重定向：（方向：文件->程序）
System.setIn(new FileInputStream("test1.txt"));		
InputStream in = System.in;

Scanner scan = new Scanner(in);
String next = scan.next();

System.out.println(next);	
scan.close();

知识点：重定向 System.out

//重定向：（方向：程序->文件）
System.setOut(new PrintStream(new FileOutputStream("test1.txt")));

PrintStream out = System.out;

out.println("晚风依旧很温柔~~");

18.5.3 随机访问流（RandomAccessFile）

new RandomAccessFile(file, mode);

file：文件对象

mode：操作模式(“r”,“rw”,“rws”,“rwd”)

r以只读方式打开
rw打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件
rws打开以便读取和写入，对于 “rw”，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。
rwd打开以便读取和写入，对于 “rw”，还要求对文件内容的每个更新都同步写入到底层存储设备。
  1. 使用随机访问流向文件添加数据
//创建随机访问流对象
RandomAccessFile w = new RandomAccessFile("test2.txt", "rw");

//写入数据
w.write("美丽的泡沫~~".getBytes());

//关流
w.close();
/*
test2.txt：
美丽的泡沫~~
*/
  1. 使用随机访问流在文件末尾添加数据
//创建随机访问流对象
File file = new File("test2.txt");
RandomAccessFile w = new RandomAccessFile(file, "rw");

//设置指针在末尾
w.seek(file.length());
//写入数据
w.write("你所有承诺~~~".getBytes());

//关流
w.close();
/*
test2.txt：
美丽的泡沫~~你所有承诺~~~
*/
  1. 使用随机访问流在文件内容指定处开始添加数据
//创建随机访问流对象
File file = new File("test1.txt");
/*
test.txt：
0123456789
*/
RandomAccessFile w = new RandomAccessFile(file, "rw");

//设置指针在位置6
w.seek(6);
//写入数据
w.write("aaa".getBytes());

//关流
w.close();
/*
test.txt：
012345aaa9
*/
  1. 使用随机访问流从文件中读取数据
//1. 创建流对象
RandomAccessFile r = new RandomAccessFile("test1.txt", "r");

//2.读取数据
byte[] bs = new byte[1024];
int len;
while((len = r.read(bs)) != -1){
    System.out.println(new String(bs, 0, len));
}

//3.关流
r.close();
  1. 使用随机访问流从文件指定位置开始中读取数据
/*
test.txt：
0123456789
*/
//1. 创建流对象
RandomAccessFile r = new RandomAccessFile("test2.txt", "r");

//设置指针
r.seek(5);

//2.读取数据
byte[] bs = new byte[1024];
int len;
while((len = r.read(bs)) != -1){
    System.out.println(new String(bs, 0, len));
}

//3.关流
r.close();
/*
test.txt：
56789
*/

注：使用随机访问流在文件内容指定处开始添加数据时会从指针位置依次覆盖，直到添加完。

  1. 使用随机访问流复制文件，完成断点续传的功能
RandomAccessFile r = new RandomAccessFile("1.mp4", "r");

File file = new File("copy.mp4");
RandomAccessFile w = new RandomAccessFile(file, "rw");

int len=file.length();//以copy.mp4的末指针为随机访问的指针，让文件同步传输。
//设置指针
r.seek(len);
w.seek(len);

byte[] bs = new byte[1024];
int len;
while((len = r.read(bs)) != -1){
    w.write(bs, 0, len);
}

r.close();
w.close();

注：

  1. 随机访问流并不是随机访问，而是通过seek指针开始读写，而我们可以手动修改seek指针，让文件的读写更加“随机”。
  2. 通过随机访问流向文件中写入时，文件不可能变小（因为写入的方式为覆盖写入）。

18.5.4 内存流

内存流是建立在程序和内存之间的流，而程序也是运行在内存中，所以内存流一旦创建，将无法关闭。（无法关闭程序和内存的交互）

18.5.4.1 内存输出流

示例：

//创建内存输出流
ByteArrayOutputStream baos = new ByteArrayOutputStream();

//写入数据是将数据放入到内存中
baos.write("java入门基础13".getBytes());

//一次性读取数据
System.out.println(baos.toString());
System.out.println(new String(baos.toByteArray()));
18.5.4.2 内存输入流

示例：

//创建内存输入流（创建流时就将数据放入到内存中）
ByteArrayInputStream bis = new ByteArrayInputStream("java入门基础13".getBytes());

//获取数据
byte[] bs = new byte[1024];
int len;
while((len = bis.read(bs)) != -1){
    System.out.println(new String(bs, 0, len));
}
18.5.4.3 内存流的使用场景

​ 内存流是在内存中存取数据，所以效率会远高于其他需要和硬盘交互的流，但数据不能持久化（因为是在内存中存放，持久化需要存入硬盘（文件）中），所有当我们不需要持久化存储数据，而仅仅是需要进行数据中转的时候，就可以使用内存流，来提高效率。

最好的硕硕
关注
专栏目录
Java 基础入门 | 第十四章 File以及I/O流
洛阳泰山的博客
02-08 1191
File类的使用 java.io.File类 代表硬盘上的一个文件或者目录java.io.File类作用 每个File类的对象表示一个磁盘文件或目录，其对象属性中包含了文件或目录的相关信息，如名称、长度、所含文件个数等，调用它的方法则可以完成对文件或目录的常用管理操作，例如，创建、删除等操作。Java中文件或者目录的路径表示 Windows中文件或者目录的表示D:\test\1.txt Java中文件或者目录的表示D:\\test\\1.txt，或者D:/test/1.txtFile类的构造方法 由于F.
Java从入门到精通(十五) ~ IO流
风止的博客
08-03 1376
当我们做java开发时，需要在内存，磁盘，网络中传输数据时，可能要一次性要传输的数据很大，而我们的内存空间有限，无法完成大文件的批量传输，这时候我们就可以使用IO流，IO流传输数据就是像流水一样缓缓的流动传输。IO流是用于处理设备之间的数据传输的机制，Java中的IO流主要分为两大类：输入流和输出流。输入流用于从源读取数据，输出流用于向目标写入数据。流的概念可以看作是数据在源和目标之间的传输管道，数据可以是字节或字符。输出流：以内存为基准，将内存中的数据以字节或者字符的形式写到磁盘或者网络中的流。
JavaIO流入门1文件File
学习笔记，相关教程 分享
03-23 2065
小白能看懂的IO入门教程 之File
Java中的IO流-最全最基础的IO流概述和简介
是程序喵呀
08-23 2572
Java中的IO流是用于处理数据输入和输出的核心机制。通过应用IO流可以使Java程序能够与外部世界（如磁盘文件、网络、硬件设备等）进行数据交互。IO流的全称为输入/输出流（Input/Output Stream），它是Java编程语言中用于数据传输的一种抽象模型。流可以被想象为数据的连续流动，就像水通过管道一样，数据通过流从一个地方流向另一个地方。文件流是用来连接我们的程序与文件之间的"管道",用来读写文件中的数据。
Java 入门指南：Java IO流 —— 字符流
Zachyy的博客
08-27 1264
字符流（Character Stream）以字符为单位进行读取和写入操作，适用于处理文本文件、配置文件、文档等纯文本数据。字符流是由 Java 虚拟机将字节转换得到的，默认采用的是 Unicode 编码，我们可以通过构造方法自定义编码。
Java基础IO流
qq_52957637的博客
07-03 1469
Java基础IO流
Java IO流（超详细！）
热门推荐
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
【Java从入门到入土】 IO流
胖虎虎
04-10 966
Java IO流 听起来很高大上，其实不然就是input 和output嘛，来了解一下吧
java入门-文件与IO流
qq_36115196的博客
06-12 1158
在Java中，java.io 包提供了用于处理输入/输出（I/O）操作的类和接口。这些流（Streams）是用于在应用程序中读写数据的抽象表示
File与Io流
qq_67832732的博客
01-07 2036
IO（Input/Output）是指计算机与外部世界进行数据交换的过程。在程序中，IO通常用于读取输入数据或将输出数据写入到外部设备或文件中。Java的IO库主要分为两种类型：字节流和字符流。
零基础Java入门课程-IO流
07-01
本"零基础Java入门课程-IO流"旨在帮助那些对编程感兴趣的人快速理解和应用Java的IO流系统。 IO流是Java中处理数据传输的核心概念，它允许程序读取和写入各种数据源，如文件、网络连接、内存缓冲区等。在Java 14这个...
2020老杜最新Java零基础进阶视频教程-IO流课件
12-10
文件流是Java IO中最基础的部分，主要包括FileInputStream和FileOutputStream，分别用于处理字节输入流和字节输出流，可以直接对文件进行读写操作。 3. 缓冲流： 为了提高数据读写效率，Java提供了缓冲流，如...
Java编程语言入门 Java语言基础教程 第09课 Java的输入输出流IO 共27页.pdf
07-07
### Java的输入输出流IO知识点详解 ...以上是关于Java的输入输出流IO的基本概念和使用方法的详细介绍，对于初学者来说，理解这些基础知识是非常重要的，因为这是进行更复杂的数据处理和文件操作的基础。
JAVA-SE入门学习——第九讲IO流
06-08
JAVA-SE入门学习——第九讲IO流 在 Java 中，IO 流（Input/Output Stream）是一种基本的输入/输出机制，它允许程序读取和写入各种类型的数据。IO 流是 Java 编程语言的核心组件之一，它提供了一种通用的方式来处理...
Java基础入门教程 含习题 第08章 IO（输入输出流）（共79页）.pptx
12-26
Java的输入输出流（IO流）是Java编程中不可或缺的一部分，它主要用于处理数据的输入和输出，无论是从文件、网络还是内存。Java的IO流体系是建立在抽象概念之上的，将不同类型的输入源和输出目标连接起来，使得数据...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 136
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 814
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 873
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 252
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java入门：IO流详解
在Java编程中，IO流（Input/Output Stream）是用来处理数据输入和输出的一种机制。它允许程序从一个数据源（如硬盘文件或网络连接）读取数据，并将其写入到另一个数据目的地。流的概念是Java中进行数据传输的核心，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值