io流 订阅
流是一种抽象概念,它代表了数据的无结构化传递。按照流的方式进行输入输出,数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作,而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说,IO流就是以流的方式进行输入输出 [1]  。 展开全文
流是一种抽象概念,它代表了数据的无结构化传递。按照流的方式进行输入输出,数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作,而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说,IO流就是以流的方式进行输入输出 [1]  。
信息
编程语言
C++
表现形式
内部表示和外部表示
定    义
以流的方式进行输入输出
中文名
输入输出流
外文名
Input Output Stream
领    域
计算机编程
IO流概念
输入输出(IO)与流的概念输入输出(IO)是指计算机同任何外部设备之间的数据传递。常见的输入输出设备有文件、键盘、打印机、屏幕等。数据可以按记录(或称数据块)的方式传递,也可以 流的方式传递 [1]  。所谓记录,是指有着内部结构的数据块。记录内部除了有需要处理的实际数据之外,还可能包含附加信息,这些附加信息通常是对本记录数据的描述。C++IO流,特指以流的方式进行输入输出的ISO/ANSI标准C++库的输入输出类库,也就是专门负责处理IO操作的一套系统。任何需要传递的数据,都要经过这套系统的处理 [1]  。
收起全文
精华内容
参与话题
问答
  • IO流

    千次阅读 2019-10-14 19:37:21
    IO流 IO流 控制台IO流 scanf&printf getchar&putchar 文件IO流 fopen&fclose 总结 指针 链表 控制台IO流 scanf&printf scanf格式化输入,可以要求按指定格式输入,不接受TAB,回车(换行),...

    IO流

    控制台IO流

    scanf&printf

    scanf格式化输入,可以要求按指定格式输入,不接受TAB,回车(换行),空格,等。
    printf格式化输出,按指定格式输出。

    #include <stdio.h>
    
    int main() {
        int a, b;
        scanf("%dhello%d",&a, &b);  //使用了指针
        printf("%d,%d", a, b);      //没有使用指针
        return 0;
    }
    

    思考:为什么scanf使用指针而printf没有使用指针?

    getchar&putchar

    getchar从标准输入缓冲区获得一个字符,与scanf不同,可以接受TAB,回车(换行),空格,等。
    putchar向标准输出缓冲区写入一个字符

    #include <stdio.h>
    
    int main() {
        int ch;
        while ((ch = getchar()) && ch != '\n') {
            
            putchar(ch);
        }
        putchar('\n');
        return 0;
    }
    

    文件IO流

    fopen&fclose

    fopen( const char *restrict filename, const char *restrict mode ) 打开文件,输入两个参数,filename文件路径(字符串),mode打开模式(字符串)

    文件访问模式字符串 含义 解释 若文件已存在的动作 若文件不存在的动作
    “r” 打开文件以读取 从头读 打开失败
    “w” 创建文件以写入 销毁内容 创建新文件
    “a” 后附 后附到文件 写到结尾 创建新文件
    “r+” 读扩展 打开文件以读/写 从头读 错误
    “w+” 写扩展 创建文件以读/写 销毁内容 创建新文件
    “a+” 后附扩展 打开文件以读/写 写到结尾 创建新文件

    fclose( FILE *stream ) 关闭文件,舍弃读取缓冲数据,写入缓冲数据会被写入到文件中(若有未写入的),然后接除流与文件的关联。

    文件输入流:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void) {
        FILE* fp = fopen("test.txt", "r");
        if(!fp) {
            perror("File opening failed");
            return EXIT_FAILURE;
        }
    
        int c;
        while ((c = fgetc(fp)) != EOF) { // 标准C I/O读取文件循环
            putchar(c);
        }
    
        if (ferror(fp)) {
    
            puts("I/O error when reading");
    
        } else if (feof(fp)) {
    
            puts("End of file reached successfully");
        }
    
        fclose(fp);
        return 0;
    }
    

    文件输出流:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        FILE* fp = fopen("test.txt", "w");
        char str[] = "Hello world";
        int i = 0;
        for (; str[i] != 0; i++) {
            fputc(str[i], fp);
        }
    
        if (ferror(fp)) {
            puts("I/O error when writing\n");
        }
        fclose(fp);
        return 0;
    }
    

    总结

    标准输入输出流(特别是文件的输入输出流)在勤使用的状态下很快就能掌握。需要注意的一点是文件的输入输出流要记得关闭流与文件的关联。虽然在绝大多数的情况下,在main函数退出前会自动调用fclose解除关联。不排除少数文件写入错误的情况。

    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        FILE* fp = fopen("test.txt", "w");
        char str[] = "Hello world";
        int i = 0;
        for (; str[i] != 0; i++) {
            fputc(str[i], fp);
        }
    
        if (ferror(fp)) {
            puts("I/O error when writing\n");
        }
        fp = fopen("test.txt", "w");          //在未解除关联的情况下直接打开并写入一个字节,造成了错误
        fputc(0, fp);
        return 0;
    }
    
    展开全文
  • io流

    千次阅读 多人点赞 2019-05-09 14:21:54
    IO流 java.io包 1.什么是流? io流就是java中运输数据的一种载体 它能够把数据从一个地方运输到另一个地方 2.流的分类 a 根据流运输数据的方向<以内存为参考物> 输入流 输出流 b 根据数据传输时转换的类型 ...

    IO流
    java.io包
    1.什么是流?
    io流就是java中运输数据的一种载体
    它能够把数据从一个地方运输到另一个地方

    2.流的分类
    a 根据流运输数据的方向<以内存为参考物>
    输入流
    输出流

     b 根据数据传输时转换的类型
               字节流    byte           
               字符流    char  
               
               字符流主要运用于纯文本的传输   
    

    3.流的体系
    以上两种流的分类可以互相组合成下面四种
    字节输入流 字节输出流 字符输入流 字符输出流

        整个流的体系结构如下
         closeable<可关闭的>(close())          flushable<可刷新的>(flush())
     
    inputStream   OutputStream   Reader    Writer
       所有的字节输入流都是 inputStream的子类
       所有的字节输出流都是 OutputStream的子类
       所有的字符输入流都是 Reader的子类
       所有的字符输出流都是 Writer的子类
       以上4个流都实现了closeable接口
       以上2个输出流都实现了flushable接口 
    

    4.我们要学习的流<16>
    4个文件流<掌握>
    FileInputStream
    FileOutputStream
    FileReader
    FileWriter

    FileInputStream fis = new FileInputStream("D:/c.txt");
    	byte [] bytes = new byte[1024];
    	int temp;
    	while((temp=fis.read(bytes))!=-1){
    		System.out.print(new String(bytes,0,temp));
    	}
    	
    	fis.close();
    

    /*
    * 文件输出流如果指向的文件不存在
    * 则会自动创建一个
    */
    FileOutputStream fos = new FileOutputStream(“D:/a.txt”);

    	String info = "许俊皇是个皇军";
    	
    	//把数据转成byte数组《String-->数组》
    	byte [] bytes = info.getBytes();
    	
    	//fos.write(bytes);
    	fos.write(bytes,0,12);
    	
    	//刷新  强制写入
    	fos.flush();
    	
    	fos.close();
    

    public static void main(String[] args) {

    	FileReader fr=null;
    	FileWriter fw=null;
    	
    	try {
    		
    		fr=new FileReader("D:\\b.txt");
    		fw=new FileWriter("D:\\c.txt");
    		
    		char [] bytes=new char[100];
    		int i;
    		while((i=fr.read(bytes))!=-1) {
    			
    			fw.write(bytes,0,i);
    			
    		}
    		
    		fw.flush();
    		
    	}catch(IOException e){
    		
    		e.printStackTrace();
    		
    	}finally {
    		
    		if(fr!=null) {
    			
    			try {
    				fr.close();
    			}catch(IOException e) {
    				e.printStackTrace();
    			}
    		}
    		
    		if(fw!=null) {
    			try {
    				fw.close();
    			}catch(IOException e) {
    				e.printStackTrace();
    			}
    			
    		}
    	}
    }
    

    public static void main(String[] args) {
    FileInputStream file1 = null ;
    FileOutputStream file2 = null;
    try {

    		byte[] bytes = new byte[1024];
    		int a;
    		while((a=file1.read(bytes))!=-1){
    			file2.write(bytes,0,a);
    		}
    		
    		file2.flush();
    		
    	}catch(IOException e){
    		e.printStackTrace();
    	}finally {
    		if(file1 != null) {
    			try {
    				file1.close();
    			}catch(IOException e){
    				e.printStackTrace();
    			}
    			
    		}
    		if(file2 != null) {
    			try {
    				file2.close();
    			}catch(IOException e){
    				e.printStackTrace();
    			}
    			
    		}
    	}
    }
    

    4个缓冲流<掌握>
    BufferedInputStream
    BufferedOutputStream
    BufferedReader
    BufferedWriter

    public static void main(String[] args) throws IOException {
    	
    	FileInputStream fis = new FileInputStream("D:/b.txt");
    	
    	InputStreamReader  isr = new InputStreamReader(fis);
    	
    	BufferedReader br = new BufferedReader(isr);
    	
    	String temp;
    	
    	while((temp=br.readLine())!=null){
    		System.out.println(temp);
    	}
    	
    	br.close();
    
    }
    

    public static void main(String[] args) throws IOException {
    
    	FileWriter fw = new FileWriter("D:/b.txt");
    	
    	BufferedWriter bw = new BufferedWriter(fw);
        		
    	bw.write("哈哈哈  许俊黄");
    	bw.newLine();
    	bw.write("哈哈哈  张建兵");
    	bw.write("哈哈哈  许俊慌");
    	
    	bw.flush();		
    	bw.close();
    
    }
    

    2个转换流<掌握>
    InputStreramReader
    OutputSTreamWriter

    2个打印流<掌握>
    PrintWriter
    PrintStream

    2个数据流
    DataInputStream
    DataOutputStream

     序列化与反序列化流
    

    ObjectInputStream
    ObjectOutputStream

    java.io.File: 表示文件和文件夹类
    File不是流 不能直接操作文件

    展开全文
  • java基础知识点07_文件与IO流

    万次阅读 2020-11-09 18:56:11
    java基础知识点07_文件与IO流 File类的四个静态成员变量: public static void main(String[] args) { //路径分隔符,windows系统为; linux系统为: String pathseparator = File.pathSeparator; char ...

    java基础知识点07_文件与IO流

    File类的四个静态成员变量:

    public static void main(String[] args) {
    	//路径分隔符,windows系统为; linux系统为:
    	String pathseparator = File.pathSeparator;
    	char pathseparatorchar = File.pathSeparatorChar;
    	//文件分隔符, windows系统为\ linux系统为/
    	String separator = File.separator;
    	char separatorchar = File.separatorChar;
    	
    	System.out.println(pathseparator);
    	System.out.println(pathseparatorchar);
    	System.out.println(separator);
    	System.out.println(separatorchar);
    	
    }
    

    运行结果:

    ;
    ;
    \
    \
    
    pathSeparator		路径分隔符 ; 	String类型
    pathSeparatorChar	路径分隔符 ; 	char类型
    separator			文件分隔符 \		String类型
    separatorChar		文件分隔符 \		char类型
    

    获取功能的方法:

    public String getAbsolutePath()		获取绝对路径
    public String getPath()				获取构造路径(构造方法中传递的路径)
    public String getName()				获取文件名称
    public String length()				获取文件大小(单位:字节)
    

    判断功能的方法:

    public boolean exists()				判断文件或目录是否存在
    public boolean isDirectory()		判断是否是目录(不要求一定要存在)
    public boolean isFile()				判断是否是文件(不要求一定要存在)
    

    创建和删除功能的方法:

    public boolean createNewFile()		创建新文件(若文件已存在,则不会创建并返回falsepublic boolean delete()				删除文件或目录
    public boolean mkdir()				创建单级文件夹                                     
    public boolean mkdirs()				创建多级文件夹
    

    遍历目录(文件夹)的方法:

    public String[] list()			返回String数组,存储该文件夹中所有的子文件和子目录的名称
    public File[] listFiles()		返回File数组,存储该文件夹中所有的子文件和子目录的File对象
    

    IO流

    输入流 输出流
    字节流 InputStream OutputStream
    字符流(1个字符=2个字节) Reader Writer

    抽象类 字节输出流 OutputStream 的方法:

    close()
    flush()
    write(byte[] b)
    write(byte[] b,int off,int len)
    write(int b)
    

    最常用子类 FileOutputStream

    构造方法1(直接传递文件路径字符串):
    FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt");
    
    构造方法2(传递文件对象):
    File myfile = new File("D:\\temp\\a.txt");
    FileOutputStream fos = new FileOutputStream(myfile);
    
    写数据时,会将10进制的整数97转换成2进制1100001存入文件,用文本编辑器打开时,其会根据编码表将字节转换为字符a
    fos.write(97);
    释放资源,清空内存
    fos.close();
    
    数据追加写(在构造方法中添加一个trueboolean参数,就实现了数据追加写,参数为false则会覆盖源文件)
    FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt",true);
    fos.write("你好,BLU".getBytes());
    fos.close();
    
    数据换行写
    FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt",true);
    fos.write("\r\n".getBytes());
    fos.write("你好,BLU".getBytes());
    fos.close();
    

    抽象类 字节输入流 InputStream 的方法:

    int read()
    int read(byte[] b)
    void close()
    

    最常用子类 FileInputStream

    //文件内容:abc	读取结果:97 98 99 -1
    FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    //read方法每一次读取都只会读取1个字节,下一次会读取下一个字节,末尾之后读取到的值都为-1
    int len1 = fis.read();
    System.out.println(len1);
    int len2 = fis.read();
    System.out.println(len2);
    int len3 = fis.read();
    System.out.println(len3);
    int len4 = fis.read();
    System.out.println(len4);
    fis.close();
    
    循环优化:
    FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    int len = 0;
    while((len = fis.read())!=-1) {
    	System.out.println((char)len);
    }
    
    //文件复制(每次复制一个字节)
    FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    FileOutputStream fos = new FileOutputStream("D:\\temp\\b.txt");
    int len = 0;
    while((len = fis.read())!=-1) {
    	fos.write(len);
    }
    fos.close();
    fis.close();
    
    //文件加密
    package com.blu.file01;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class Test01 {
    	
    	public static void main(String[] args) throws IOException {
    		FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
    		FileOutputStream fos = new FileOutputStream("D:\\temp\\b.txt");
    		jiami(fis,fos);
    		fos.close();
    		fis.close();
    	}
    	
    	public static void jiami(FileInputStream fis,FileOutputStream fos) throws IOException {
    		byte[] bytes = new byte[204800];
    		int len = 0;
    		while((len=fis.read(bytes))!=-1) {
    			for(int i=0;i<204700;i++) {
    				bytes[i]++;
    			}
    			fos.write(bytes, 0, len);
    		}
    		
    	}
    	
    	public static void jiemi(FileInputStream fis,FileOutputStream fos) throws IOException {
    		byte[] bytes = new byte[204800];
    		int len = 0;
    		while((len=fis.read(bytes))!=-1) {
    			for(int i=0;i<204700;i++) {
    				bytes[i]--;
    			}
    			fos.write(bytes, 0, len);
    		}
    	}
    
    }
    
    展开全文
  • JavaIO流概念详解

    千次阅读 多人点赞 2016-12-20 09:03:00
    JavaIO流概念详解
    1. IO解决的问题:解决设备与设备之间的数据传输问题。 比如:硬盘------->内存     内存-------->硬盘

    2. 一、字节流

    3. 输入字节流:
    4. InputStream   所有输入字节流的基类。抽象类。
    5. FileInputStream  读取文件输入字节流。
    6. BufferedInputStream  缓冲输入字节流。该类内部其实就是维护了一个8kb字节数组而已。该类出现的目的是为了提高读读取文件数据的效率。

    7. 输出字节流:
    8. OutputStream   所有输出字节流的基类。抽象类。
    9. FileOutputStream  向文件输出数据的输出字节流。
    10. BufferedOutputStream   缓冲输出字节流。该类出现的目的是为了提高向文件写数据的效率。该类内部其实也是维护了一个8kb的字节数组而已。

    11. 二、什么情况下使用个字节流
    12. 读取到数据不需要经过编码或者解码的情况下这时候使用字节流。比如:图片数据

    13. 字符流=字节流+编码(解码)

    14. 三、字符流

    15. 输入字符流:
    16. Reader   所有输入字符流的基类。抽象类。
    17. FileReader 读取文件字符的输入字符流。
    18. BufferedReader 缓冲输入字符流。该类出现的目的是为了提高读取文件字符的效率并且扩展了功能(readLine()),它内部其实就是维护了一个8192个长度的字符数组。

    19. 输出字符流:
    20. Writer  所有输出字符流的基类。抽象类。
    21. FileWriter  向文件输出字符数据的输出字符流。
    22. BufferedWriter  缓冲输出字符流。该类出现的目的是为了提高写文件字符的效率并且扩展了功能(newLine())。

    23. 四、什么情况下使用字符流

    24. 如果读写的都是字符数据,这时候我们就使用字符流。

    25. 五、转换流

    26. 输入字节流的转换:InputStreamReader
    27. 输出字节流的转换流:OutputStreamWriter

    28. 六、转换流的作用:

    29. 1、可以把对应的字节流转换成字符流使用。
    30. 2、可以指定编码表进行读写文件的数据。
    31. 七、FileReader、FileWriter 类

    32.  FileReader、FileWriter这两个类默认是使用的gbk编码表。不能由你指定编码表读写文件数据。

    33. 八、Java流类图结构:
    34.                           注:图片来自:http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html
    展开全文
  • C++三大IO流类总结——标准IO流、文件IO流、内存IO流 IO流类一览标准IO流标准IO流的条件状态条件状态标志条件状态函数标准IO流的输入输出成员函数代码示例条件状态put和get函数getline函数标准IO的格式控制输出格式...
  • io流概述: IO流用来处理设备之间的数据传输,上传文件和下载文件,Java对数据的操作是通过流的方式,Java用于操作流的对象都在IO包中。 IO流分类 按照数据流向 输入流 读入数据 输出流 写出数据 按照数据...
  • SpringBoot上传图片和IO流的基本操作

    千次阅读 2020-03-02 15:52:33
    浅谈 我一直都觉得上传图片好复杂,除了本地上传,还有局域网上传,公网上传乱七八糟的,不仅看不懂,还不想学,因为老是觉得本地上传没啥大用处,直到今天,我才看透,什么本地不本地的,统统都是一个套路!...
  • Java-IO流

    万次阅读 多人点赞 2019-01-18 13:11:52
    1.3、IO流的分类 1.4、IO流特性 1.5、IO流常用到的五类一接口 1.6、Java IO流对象 1.6.1、输入字节流InputStream 1.6.2、输出字节流OutputStream 1.6.3、字符输入流Reader 1.6.4、字符输出流Writer 1.6.5、...
  • Java IO流学习总结(一)—— IO流分类和常用IO流汇总 IO流的分类: - 按流向分类:输入流、输出流 - 按操作对象分类:字节流、字符流 - 按功能分类:节点流、处理流 IO流的设计模式为装饰设计模式; ...
  • Java IO流划分

    2020-06-04 15:42:04
    1、Java IO 按操作方式分类结构图: 2、Java IO 按操作对象分类结构图:
  • Java实现文件写入——IO流(输入输出流详解)

    万次阅读 多人点赞 2017-09-09 20:43:12
    是一组有序的数据序列,根据操作的类型,分为输入和输出。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;程序从输入读取数据,向输出写入数据。Java是面向对象的程序语言,每一个数据都是一个...
  • Java IO流

    万次阅读 2018-10-14 01:09:56
    Java IO流中各种流的介绍和实现图片的读写
  • java io流

    千次阅读 多人点赞 2020-01-12 16:42:30
    io流 数据传输是需要通道的,io流就是一种数据通道,而io流又分为好几种,分为大类就有字节流和字符流了; 作用:可以用来进行上传和下载,比如说上传QQ头像等; 虽然说有那么多的流看起来眼花缭乱的,但是实际使用...
  • File/IO流如何复制图片

    2017-12-07 07:40:12
    * 使用io流复制图片 * @author Administrator * */ public class IoPicture { public static void main(String[] args) { FileInputStream fis=null; BufferedInputStream bis=null; FileOutputStream ...
  • Java IO流学习总结一:输入输出流

    万次阅读 多人点赞 2017-01-09 19:49:50
    Java IO流学习总结一:输入输出流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构:流的概念和作用流是一组有顺序的,有起点和终点的字节...
  • 编码问题 在IDEA中使用文件字符输入FileReader读取项目中的文本文件时 由于IDEA的默认设置为UTF-8编码 因此没有任何问题 但当读取Windows系统中创建的文本文件时 由于Windows系统的默认是GBK编码 就...java.io.Inp...
  • java基础:11、java中IO流分为几种?
  • 深入了解IO流

    千次阅读 2020-07-06 10:26:27
    IO流 流的概念 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。 程序中的输入输出都是以流的形式保存的...
  • java IO流学习总结

    万次阅读 多人点赞 2018-09-09 13:24:22
    学习了几天的java IO流,下面我来谈谈对java 输入输出流IO的个人见解吧! 转载自:https://blog.csdn.net/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念: 流是一组有顺序的,有起点和...
  • java 中 IO 有哪些?

    千次阅读 2019-04-22 15:53:46
    java 中 IO 有哪些? 按数据流向:输入和输出 输入和输出都是从程序的角度来说的。输入:数据流向程序;输出:数据从程序流出。 按处理单位:字节和字符 字节:一次读入或读出是8位二进制;字符...
  • IO流知识详解

    千次阅读 2020-03-13 11:27:19
    ########—IO流知识点—################### 1.File【文件对象】 2.使用递归打印子孙级目录和文件名称。 3.统计文件夹大小。 4.四个抽象类:InputStream、OutputStream【字节流】 Writer Reader【字符流】 5.使用...
  • Java基础---IO流

    万次阅读 2020-01-30 13:21:29
    2、IO流原理及流的分类 3、节点流(或文件流) 4、缓冲流 5、转换流 6、标准输入、输出流 7、 打印流 8、数据流 9、对象流 10、随机存取文件流 11、Path、Paths、Files类的使用 ....

空空如也

1 2 3 4 5 ... 20
收藏数 66,614
精华内容 26,645
关键字:

io流