18 IO流

最新推荐文章于 2024-06-12 07:30:00 发布
最新推荐文章于 2024-06-12 07:30:00 发布
阅读量341 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44962092/article/details/95468188
版权

IO流

File类

构造方法：
File(String pathname):将一个路径下的文件/文件夹构造成一个file对象

方法：createNewFile() 
          当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
          
案例：
案例：
package cn.wzx.Demo;

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

public class Demo1 {
	public static void main(String[] args) throws IOException {
		//创建一个文件的对象  ctrl+f
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		//创建
		/*boolean createNewFile = file.createNewFile();
		System.out.println(createNewFile);*/
		//删除
		/*boolean delete = file.delete();
		System.out.println(delete);*/
		//是否存在
		/*boolean exists = file.exists();
		System.out.println(exists);*/
		
		//绝对路径
		/*String absolutePath = file.getAbsolutePath();
		System.out.println(absolutePath);*/
		//获得文件名和后缀名
		/*String name = file.getName();
		System.out.println(name);*/
		//获取父路径
		/*String parent = file.getParent();
		System.out.println(parent);*/
		
		//判断是否是绝对路径
		/*boolean absolute = file.isAbsolute();
		System.out.println(absolute);
		
		//是否为文件夹
		boolean directory = file.isDirectory();
		System.out.println(directory);
		
		//是否是文件
		boolean file2 = file.isFile();
		System.out.println(file2);
		
		//
		long length = file.length();
		System.out.println(length);*/
		
		//创建文件夹
		/*boolean mkdir = file.mkdir();
		System.out.println(mkdir);*/
		
		/*boolean setReadOnly = file.setReadOnly();
		System.out.println(setReadOnly);*/
	}
}

IO流概述

IO: input输入 / output输出

IO流：是连接内存和永久存储设备的一条管道
  		输出流
    ------------>
内存              永久存储设备（硬盘 U盘  光盘  磁带）
	<-------------
	    输入流

IO流的分类

按照流的方向
输入流：将永久存储设备的数据读到程序中（内存）
输出流：将内存中程序的数据存储到永久存储设备（硬盘）
按照流的传输数据单位分
字节流：每次传输的数据最小单位是字节  字节流可以处理任何文件 音乐视频 等
字符流：一个字符等于两个字节          可以处理的文件是 记事本能打开且正确的文件  .txt  .java
按照流的功能分
节点流：负责传输主要数据的流
过滤流：增强流功能的流
所有流的父类输出流输入流
字节流OutputStreamInputStream
字符流WriterReader

字节流

字节输出流代表（文件输出流FileOutputStream）
方法：
write(int b)
write(byte[] b)
write(byte[] b,int off,int len)
close():关闭流

案例：
package cn.wzx;

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

public class Demo2 {
	public static void main(String[] args) throws Exception {
		//指定硬盘中的一个路径
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建一个文件输出流
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		
		//将数据写到文件中
		/*fileOutputStream.write(65);
		fileOutputStream.write(66);
		fileOutputStream.write(67);结果：ABC*/
		
		//字节数组
		/*byte[] b = "sdgahladfgha".getBytes();
		fileOutputStream.write(b);*/
		
		//字节数组 开始  int len
		byte[] b = "abcdefg".getBytes();
		fileOutputStream.write(b, 1, 2); //结果：bc
		
		//关流
		fileOutputStream.close();
		System.out.println("写完了");
	}
}


案例：追加输出数据  
当构造方法的第二参数为true时追加
FileOutputStream fileOutputStream = new FileOutputStream(file,true);
案例：输出换行
不同的系统有不同的写法
windows  \r\n     r return  回车   n newLine 新的一行
unix/linux  \n
macOs   \r
代码：
package cn.wzx;

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

public class Demo2 {
	public static void main(String[] args) throws Exception {
		//指定硬盘中的一个路径
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建一个文件输出流
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		
		//将数据写到文件中
		/*fileOutputStream.write(65);
		fileOutputStream.write(66);*/
		
		//字节数组
		/*byte[] b = "sdgahladfgha".getBytes();
		fileOutputStream.write(b);*/
		
		//字节数组 开始  int len
		
		byte[] b = "kashjfgkahjdfg".getBytes();
		for (int i = 0; i < b.length; i++) {
			fileOutputStream.write(b[i]);
			fileOutputStream.write("\r\n".getBytes());
		}
		
		//关流
		fileOutputStream.close();
		System.out.println("写完了");
	}
}
字节输入流（文件字节输入流FileInputStream）
构造方法：
FileInputStream(File file)
FileInputStream(String name) 

方法：
read():从此输入流中读取一个数据字节。
read(byte[] b):每次读一个字节数组，将读到的数据存到数组中，返回值类型是int（读到的数据的长度，就是读到了几个数据）
read(byte[] b,int off,int len)

package cn.wzx;
import java.io.File;
import java.io.FileInputStream;

public class Demo3 {
	public static void main(String[] args) throws Exception{
		//指定硬盘中的一个路径
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建输入流对象
		FileInputStream fileInputStream =  new FileInputStream(file);
		int read1 = fileInputStream.read();
		System.out.println((char)read1);//打印流 （输出流）
		int read4 = fileInputStream.read();
		System.out.println(read4);//打印流 （输出流）13  \r
		int read5 = fileInputStream.read();
		System.out.println(read5);//打印流 （输出流）10   \n
		int read6 = fileInputStream.read();
		System.out.println(read6);//打印流 （输出流）-1   
		fileInputStream.close();
	}
}


案例：改造之后的代码

package cn.wzx;

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

public class Demo3 {
	public static void main(String[] args) throws Exception{
		//指定硬盘中的一个路径
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建输入流对象
		FileInputStream fileInputStream =  new FileInputStream(file);
		/*int read1 = fileInputStream.read();
		System.out.println((char)read1);//打印流 （输出流）
		int read4 = fileInputStream.read();
		System.out.println(read4);//打印流 （输出流）
		int read5 = fileInputStream.read();
		System.out.println(read5);//打印流 （输出流）
		int read6 = fileInputStream.read();
		System.out.println(read6);//打印流 （输出流）
		fileInputStream.close();*/
		
		//改造
		int read;
		
		//死循环
		while (true) {
			//判断是否为-1
			read = fileInputStream.read();
			if (read==-1) {
				break;
			}else {
				System.out.print((char)read);
			}
		}
		
		fileInputStream.close();
	}
}

案例：有逼格的代码
		int read;
		while ((read=fileInputStream.read())!=-1) {
			System.out.println((char)read);
		}

案列：
package com.baizhi.entity;

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

public class TestIOFile2 {
    public static void main(String[] args) throws Exception{
        //指定硬盘的中的一个路径
        File file = new File("E:\\ideaworkspace\\project01\\maven01\\src\\main\\resources\\File\\a.txt");
        //创建节点流
        FileInputStream fis = new FileInputStream(file);
       int r;
        byte[] b = new byte[3];
        while (true){
            r = fis.read(b);
            if(r==-1){
                break;
            }else{
                System.out.println(new String(b,0,r));
            }
        }
        fis.close();
   /*    int r;
        byte[] b = new byte[3];
        while((r=fis.read(b))!=-1){
            System.out.println(new String(b,0,r));
        }
        fis.close();*/
    }
}

文件的复制

1B = 8bit

1024B = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024PB = 1EB
1024EB = 1ZB

案例：
package cn.wzx;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo4 {
	public static void main(String[] args) throws Exception{
		//源文件的位置
		File yuanFile = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/IO上.wmv");
		//目标位置
		File mubiaoFile = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file1/赵帅私密视频.wmv");
		
		
		//输入流  输出流
		FileInputStream fInputStream = new FileInputStream(yuanFile);
		FileOutputStream fileOutputStream = new FileOutputStream(mubiaoFile);
		
		
		//一边读 一边写
		//第一种    读一个字节  写一个字节
		/*int b;
		
		while (true) {
			b = fInputStream.read();
			if (b==-1) {
				break;
			}else {
				fileOutputStream.write(b);
			}
			
		}*/
		
		//第二种
		int len;
		byte[] b = new byte[1024*1024];
		//long start = System.nanoTime();
		while ((len = fInputStream.read(b))!=-1) {
			fileOutputStream.write(b,0,len);
		}
		l//ong end = System.nanoTime();
		//System.out.println(end-start);
		//关流
		fileOutputStream.close();
		fInputStream.close();
		
		System.out.println("复制完毕");
	}
}

过滤流

1.缓冲流BufferedOutputStream/BufferedInputStream
package cn.wzx;

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

public class Demo5 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建节点流
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		
		//创建缓冲流 过滤流   
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
		
		bufferedOutputStream.write(65);
		
		//刷新流
		bufferedOutputStream.flush();
		
		bufferedOutputStream.close();//在关流之前会先进行一步刷新流的操作
		
	}
}

2.数据过滤流：可以传输基本的数据类型的数据  8中基本数据类型DataOutputStream DataInputStream
案例：
package cn.wzx;

import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo5 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/b.dat");
		
		//创建节点流
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		
		DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
		
		dataOutputStream.writeInt(300);
		
		dataOutputStream.flush();
		dataOutputStream.close();
		
		FileInputStream fileInputStream = new FileInputStream(file);
		
		//过滤流
		DataInputStream dataInputStream = new DataInputStream(fileInputStream);
		
		int readInt = dataInputStream.readInt();
		System.out.println(readInt);
	}
}
3.ObjectOutputStream/ObjectInputStream 对象输出/输入流 需实现序列化Serializable接口
序列化：将一个对象写入一个持久存储设备（硬盘）的文件中
反序列化：将一个文件中的对象数据读入内存程序中
transient：修饰的属性不参与序列化，当序列化的时候，这个属性时默认值（即使初始化也是默认值）
案列：
package com.wzx;

import java.io.*;

public class TestIOFile3 {
    public static void main(String[] args) throws Exception {
        Student4 student4 = new Student4("王仨",18,new Address("北京","46131",1101011452L));
        File file = new File("E:\\ideaworkspace\\project01\\maven01\\src\\main\\resources\\File\\a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(student4);
        oos.flush();
        oos.close();

        FileInputStream fis = new FileInputStream(file);
        ObjectInputStream ois = new ObjectInputStream(fis);
        Object o = ois.readObject();
        if(o instanceof Student4){
            Student4 student = (Student4)o;
            System.out.println(student);
        }
        ois.close();
    }
}
class Student4 implements Serializable {
    private String name;
    private int age;
    private Address address;

    public Student4() {
    }

    public Student4(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    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;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student4{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}
class Address implements Serializable{
    private String city;
    private transient String email;
    private Long telephone;

    public Address() {
    }

    public Address(String city, String email, Long telephone) {
        this.city = city;
        this.email = email;
        this.telephone = telephone;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Long getTelephone() {
        return telephone;
    }

    public void setTelephone(Long telephone) {
        this.telephone = telephone;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", email='" + email + '\'' +
                ", telephone=" + telephone +
                '}';
    }
}

字符流

编码
编码的由来：
	世界上第一台计算机诞生在美国 发明人是冯诺依曼 现在所使用的电脑都是冯诺依曼结构 埃尼拉克（第一台计算机名字）
	现在在研究 量子计算机
	
ASCII码表  最小的码表
其他的国家也要用
	
	中国
	大陆（简体）
	GB2312(国标) 建国初期天朝政府 的某个部门 指定了码表
	刘-----1234
	洋------2345
	GBK（国标扩充）
	两岸 台湾  香港   澳门
	繁体  
	BIG5   
	1234----龍
	
	编码   解码
	
	iso8859-1   欧洲国际的码表
    
    Unicode编码  万国码  UTF-8
    因为 Linux系统采用的UTF-8
    windows  GBK
字符输出流（FileWrite）
write(int a)
write(char[] c)
write(String s)
案例：
package cn.wzx;

import java.io.File;
import java.io.FileWriter;



public class Demo7 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建节点流
		FileWriter fileWriter = new FileWriter(file,true);
		
		/*fileWriter.write('刘');
		fileWriter.write('张');
		fileWriter.write('赵');
		fileWriter.write('李');*/
		
		/*String string = "今天我又来到你的窗外";
		char[] charArray = string.toCharArray();
		fileWriter.write(charArray);*/
		
		
		String string = "最美的不是下雨天，而是和你一起躲过屋檐";
		fileWriter.write(string);
		
		
		
		
		fileWriter.flush();
		//关流
		fileWriter.close();
		System.out.println("写入完毕");
	}
}
字符输入流（FileReader）
read():每次读一个字符
read(char[] c):每次读字符数组长度，将读到的数据存储到数组中 返回值是每次读到几个字符
案例：
package cn.wzx;

import java.io.File;
import java.io.FileReader;

public class Demo7 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建节点流
		FileReader fileReader = new FileReader(file);
		
		//方法
		/*int b;
		while (true) {
			b = fileReader.read();
			if (b==-1) {
				break;
			}else {
				System.out.print((char)b);
			}
		}*/
		/*int b;
		while ((b=fileReader.read())!=-1) {
			System.out.println((char)b);
		}*/
		char[] c = new char[5];
		int len;
		while ((len=fileReader.read(c))!=-1) {
			System.out.println(new String(c,0,len));
		}
		
		fileReader.close();
	}
}
字符过滤流
1.BufferedWriter/BufferedReader 具有缓冲的字符过滤流
案例：
package cn.wzx;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Demo7 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//创建节点流
		FileWriter fileWriter = new FileWriter(file);
		
		//过滤流 
		BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
		
		//bufferedWriter.write('流');
		
		
		/*char[] c = "真情像梅花开过".toCharArray();
		bufferedWriter.write(c);*/
		
		String string = "世界上头发最多的男人";
		//bufferedWriter.write(string);
		
		bufferedWriter.write(string, 0, 3);
		
		
		bufferedWriter.close();
	}
}

案例：readLine():每次可以读一行
package cn.wzx;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;



public class Demo7 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		//节点流
		FileReader fileReader = new FileReader(file);
		//过滤流
		BufferedReader bufferedReader = new BufferedReader(fileReader);
		
		
		
		String string = "";
		while (true) {
			string = bufferedReader.readLine();
			if (string==null) {
				break;
			} else {
				System.out.println(string);
			}
		}	
	}
}

2.PrintWriter ：可以直接输出一行字符串，不用创建节点流，也具有基本数据类型的功能（将基本数据类型转换为char类型进行输出）
    
package cn.wzx;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;



public class Demo7 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		
		PrintWriter printWriter =new PrintWriter(file);
		
		printWriter.println("大将南征胆气豪");
		printWriter.println("腰横秋水雁翎刀");
		printWriter.println("风吹鼍鼓山河动");
        printWriter.println("电闪旌旗日月高");                
		printWriter.close();
		
		FileReader fileReader  = new FileReader(file);
		BufferedReader bufferedReader = new BufferedReader(fileReader);
		String string ;
		while (true) {
			string = bufferedReader.readLine();
			if (string==null) {
				break;
			} else {
				System.out.println(string);
			}
		}
	}
}


3.桥转换流OutputStreamWriter/InputStreamReader
作用：可以将一个字节流转换为一个字符流
package cn.wzx;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.PrintWriter;



public class Demo7 {
	public static void main(String[] args) throws Exception{
		File file = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		PrintWriter printWriter = new PrintWriter(file);
		printWriter.print(23);
		printWriter.flush();
		//字节流的节点流
		FileInputStream fileInputStream = new FileInputStream(file);
		InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "GBK");
		
		int read = inputStreamReader.read();
		System.out.println(read);
		int read1 = inputStreamReader.read();
		System.out.println(read1);
		
		printWriter.close();
		inputStreamReader.close();
	}
}
关于IO流异常的处理
package cn.wzx;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;


public class Demo7 {
	public static void main(String[] args){
		File file1 = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/a.txt");
		File file2 = new File("D:/MyEclipse/Workspaces/JAVASE/JAVASE/file/b.txt");
		FileOutputStream fileOutputStream  = null;
		FileInputStream fileInputStream = null;
		try {
			fileOutputStream = new FileOutputStream(file2);//节点流
			fileInputStream = new FileInputStream(file1);
			//复制
			int len;
			byte[] b =  new byte[1024*1024];
			
			while ((len = fileInputStream.read(b))!=-1) {
				fileOutputStream.write(b, 0, len);
			}
			System.out.println("复制完毕");
		} catch (Exception e) {
			System.out.println("异常解决了");
			e.printStackTrace();
		}finally{
			try {
				if (fileInputStream!=null&&fileOutputStream!=null) {//避免空指针异常
					fileInputStream.close();
					fileOutputStream.close();
				}
				
			} catch (Exception e2) {
				System.out.println("空指针异常");
			}
		}	
	}
}
勋大大
关注
专栏目录
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
文件IO流
m0_65587787的博客
02-24 234
文件IO流，我们可以这样理解：文件是用来保存数据的，文件的抽象类是File，创建File对象用于在JAVA程序中文件和目录的创建、文件的查找和文件的删除。这时候问题来了，是如何将代码和文件联系，来进行操作呢？这样的目的是什么？
18comic
03-10
18漫画
18 IO
张力的程序园
03-31 147
问题 介绍一下java中的IO 答案 冯诺依曼体系结构约束了计算机要包括存储设备、控制器、运算器、输入设备和输出设备等五大部分。java中的IO指的是在数据在内存、硬盘和输入设备输出设备之间的流转。I(Input)多只硬盘数据读到内存；O(Output)多指内存数据写到硬盘。 java中的IO相关的类或者接口包括： File: 映射文件系统 InputStream：字节输入流 OutputStr...
18 IO 字符集编码
惟愿无事
07-28 499
一个File类的对象，表示了磁盘上的文件或目录 •File类提供了与平台无关的方法来对磁盘上的文件或目录进行操作 •File类直接处理文件和文件系统。 •File类没有指定信息怎样从文件读取或向文件存储
18.IO、文件、NIO【草案四】
风中的索莉逖亚
01-25 6626
（这一个章节将讲到Java里面比较重要的一个章节，这里说一句抱歉，因为最近换工作的原因，一直没有时间继续书写教程，不过接下来我会一直坚持写下去的哈，希望大家能够支持。这个章节主要涉及到常用的文件读写，包括高级的文件IO内容——java.nio，因为这些内容在如今的一些项目里面也属于相当常见的一部分，如果有什么遗漏或者笔误的话，希望读者来Email告知：silentbalanceyh@126.com
18.2 IO流之字节流和字节缓冲流
southdreams的博客
12-08 204
IO流介绍： IO：输入/输出(Input/Output) 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传 输 IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载 IO流的分类： 按数据的流向分为： 输入流：读数据 输出流：写数据 按数据类型分为： 字节流： 字节输入流 字节输出流 字符流： 字符输入流 ...
2021-10-18 IO流之字节流
Yiyan__的博客
10-25 930
IO流概述和分类 IO流的概述 IO：输入/输出(Input/Output) 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输IO流就是用来处理设备间数据传输问题的 常见的应用：文件复制；文件上传；文件下载 IO流分类 按照数据的流向 输入流：读数据 输出流：写数据 按照数据类型来分 字节流 字节输入流；字节输出流 字符流 字符输入流；字符输出流 一般来说，我们说IO流的分类是按照数据类型来分的. 那么这两
IO流的转换流
m0_46702681的博客
06-12 1381
public object readobject() 把序列化到本地文件中的对象，读取到程序中来。但是对象的个数不确定，该如何操作呢?一旦实现了这个接口，那么就表示当前的student类可以被序列化。如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？利用字节流读取文件中的数据，每次读一整行，面且不能出现乱码。利用序列化流/对象操作输出流，把一个对象写到本地文件中👇。可以把序列化到本地文件中的对象，读取到程序中来。文件中的版本号，跟lavabean的版本号不匹配。
IO 流总结
m0_63646736的博客
01-06 1012
IO 和 NIO 的区别：这个NIO是 JDK1.7 以后有的，它们俩的主要区别是:io 是面向流，是阻塞 io，nio是面向缓冲,非阻塞的io;io 的话每次流中取一 或多个字节 ,直到读取完所有的字节 ,没有缓存到任何地方。nio 读取的是数据是有缓存，就是说他读取的数据是在缓冲里读的。另外的话，java中的各种 io 是阻塞的。就是说一个线程调用 read 或者 write() 时，这个线程就已经被阻塞了，直到读取到一些数据为止，或者是完全写入。在这个过程中不能干其他的事情。
Day 18 String和IO流
01-20
Day 18 Author: ScorpioDong 1. String类 1.1 获取方法 int length(); 获取字符串长度 char charAt(int index); 获取String字符串中指定下标位置的char类型字符，如果index超出有效范围 ...
IO流
KuoChingYang的博客
03-20 1328
一、选择题 1.可以用来描述文件或者文件夹的类是（ ） a) File b) FileStream c) OutputStream d) FileReader 答案：A 2.File类中，创建多级目录，可以通过以下那个方法（ ） a) create() b) createNewFile() c) mkdir() d) mkdirs() 答案：D 3.下列哪一个import命令可以使我们在程序中创建...
java io 流选择题_java IO流（习题）
weixin_27744023的博客
02-16 2720
javaIO流(习题)(2011-09-23 20:13:50)标签：杂谈IO 框架Key Point*File 类* 流的分类* 基本字节流* 字节过滤流* 基本字符流、桥转换* 字符过滤流* 对象序列化练习1. (File 类)以下关于File 类说法正确的是：A． 一个File 对象代表了操作系统中的一个文件或者文件夹B． 可以使用File 对象创建和删除一个文件C． 可以使用File ...
http://www.guccioutletcheaper.com 18
congashuang3011的博客
06-04 9052
item ?n n? So it is the time for us to wear the comfortabletory burch shoes That way you will be sure that you h...
ssm智能家政保洁预约系统最新完整版程序+论文.zip
10-18
基于SSM框架的智能家政保洁预约系统，是一个旨在提高家政保洁服务预约效率和管理水平的平台。该系统通过集成现代信息技术，为家政公司、家政服务人员和消费者提供了一个便捷的在线预约和管理系统。 系统的主要功能包括： 1. **用户管理**：允许消费者注册、登录，并管理他们的个人资料和预约历史。 2. **家政人员管理**：家政服务人员可以注册并更新自己的个人信息、服务类别和服务时间。 3. **服务预约**：消费者可以浏览不同的家政服务选项，选择合适的服务人员，并在线预约服务。 4. **订单管理**：系统支持订单的创建、跟踪和管理，包括订单的确认、完成和评价。 5. **评价系统**：消费者可以在家政服务完成后对服务进行评价，帮助提高服务质量和透明度。 6. **后台管理**：管理员可以管理用户、家政人员信息、服务类别、预约订单以及处理用户反馈。 系统采用Java语言开发，使用MySQL数据库进行数据存储，通过B/S架构实现用户与服务的在线交互。系统设计考虑了不同用户角色的需求，包括管理员、家政服务人员和普通用户，每个角色都有相应的权限和功能。此外，系统还采用了软件组件化、精化体系结构、分离逻辑和数据等方法，以便于未来的系统升级和维护。 智能家政保洁预约系统通过提供一个集中的平台，不仅方便了消费者的预约和管理，也为家政服务人员提供了一个展示和推广自己服务的机会。同时，系统的后台管理功能为家政公司提供了强大的数据支持和决策辅助，有助于提高服务质量和管理效率。该系统的设计与实现，标志着家政保洁服务向现代化和网络化的转型，为管理决策和控制提供保障，是行业发展中的重要里程碑。
东方财富网抓取上市公司爬虫-EMSpider.zip
最新发布
10-18
东方财富网抓取上市公司爬虫-EMSpider
卫生健康系统-java-基于springBoot智能推荐的卫生健康系统（毕业论文+开题）
10-18
本基于智能推荐的卫生健康系统有管理员和用户两个角色。用户功能有个人中心，健康视频管理，视频类型管理，科室类型管理，医生信息管理，在线预约管理，我的收藏管理等。管理员功能有个人中心，用户管理，健康视频管理，视频类型管理，科室类型管理，医生信息管理，在线预约管理，健康论坛管理，我的收藏管理，留言板管理，系统管理等。因而具有一定的实用性。 本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得基于智能推荐的卫生健康系统管理工作系统化、规范化。
pxe无人值守安装centos
10-18
pxe无人值守安装centos
java学生管理系统io流
01-06
Java学生管理系统中的IO流主要用于读取和写入学生信息到文件中。下面是一个简单的Java学生管理系统的示例代码，演示了如何使用IO流进行学生信息的读取和写入： ```java import java.io.*; import java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值