ioStream

最新推荐文章于 2023-02-14 16:38:11 发布
最新推荐文章于 2023-02-14 16:38:11 发布
阅读量96 收藏
点赞数 1
文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61447142/article/details/126672881
版权

流

  • 概念：内存与存储设备之间传输数据的通道

  • 流的分类：

    • 按方向

      • 输入流：将<存储设备>中的内容读入到<内存>中

      • 输出流：将<内存>中的内容写入到<存储设备>中

    • 按单位

      • 字节流：以字节为单位，可读写所有数据

      • 字符流：以字符为单位，只能读写文本数据

    • 按功能

      • 节点流：具有实际传输数据的读写功能

      • 过滤流：在节点流的基础上增强功能

字节流

package com.ioStream.ioStream_1;
​
import java.io.FileInputStream;
​
/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 * @author Pan
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("E:\\IDEA_ioStream\\aaa.txt");
        //2.读取文件
        //单个字符
//        System.out.println("============单个字节读取=========");
//        int data = 0;
//        while ((data = fis.read()) != -1){
//            System.out.print((char) data);
//        }
        //多个字符
        System.out.println();
        System.out.println("============多个字节读取=========");
        byte[] buf = new byte[1024];
       int count = 0;
       while ((count = fis.read(buf)) != -1){
           System.out.println(new String(buf,0,count));
       }
​
        //3.关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}
package com.ioStream.ioStream_1;
​
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
​
/**
 * 演示FileOutputStream的使用
 * 文件字节输出流
 * @author Pan
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建一个文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("E:\\IDEA_ioStream\\bbb.txt",true);
        //2.写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String string = "Hello,World!";
        fos.write(string.getBytes());
​
        fos.close();
        System.out.println("执行完毕");
    }
​
}
package com.ioStream.ioStream_1;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
​
/**
 * 使用文件字节流实现文件的复制
 * @author Pan
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("E:\\IDEA_ioStream\\001.jpg");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("E:\\IDEA_ioStream\\002.jpg");
        //2.实现复制（一边读，一边写）
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf)) != -1){
            fos.write(buf,0,count);
        }
        //3.关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

  • 缓冲流：BufferedInputStream/BufferedOutputStream

    • 提高IO效率，减少访问磁盘次数

    • 数据存储在缓冲区中，flush是将缓冲区内的内容写入文件中，也可以直接调用close()---内部调用flush

package com.ioStream.ioStream_1;
​
import java.io.BufferedInputStream;
import java.io.FileInputStream;
​
/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 * @author Pan
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("E:\\IDEA_ioStream\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
//        int data = 0;
//        while ((data = bis.read()) != -1){
//            System.out.print((char) data);
//        }
​
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = bis.read(buf)) != -1){
            System.out.print(new String(buf,0,count));
        }
​
        //3.关闭
        bis.close();
        System.out.println();
        System.out.println("执行完毕");
​
    }
}
package com.ioStream.ioStream_1;
​
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
​
/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 * @author Pan
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("E:\\IDEA_ioStream\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("Hello,World!\r\n".getBytes());//写入8K缓冲区
            bos.flush();//刷新到硬盘
        }
        //3.关闭（内部调用flush方法）
        bos.close();
        System.out.println("执行完毕");
    }
}

对象流

  • 对象流：ObjectOutputStream/ObjectInputStream

    • 增强了缓冲区的功能

    • 增强了读写8种基本数据类型和字符串功能

    • 增强了读写对象的功能

      • readObject()：从流中读取一个对象

      • writeObject(Object obj)：向流中写入一个对象

  • 使用流传输对象的过程称为序列化，反序列化

package com.ioStream.ioStream_1;
​
import java.io.Serializable;
import java.util.Objects;
​
/**
 * 学生类
 * @author Pan
 */
public class Student implements Serializable {//标记接口，可序列化
    private static final long serialVersionUID = 100L;//序列化版本号ID
    private String name;
    private /*transient*/ int age;//使用transient修饰后不能序列化
​
​
    public Student() {
    }
​
    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 +
                '}';
    }
​
}
package com.ioStream.ioStream_1;
​
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
​
/**
 * 使用ObjectOutputStream实现对象的序列化
 * 注意事项：
 *      (1)序列化的类必须实现Serializable接口
 *      (2)序列化类中的对象属性要求实现Serializable接口
 *      (3)序列化版本号ID，保证序列化的类和反序列化的类时同一个类
 *      (4)使用transient(瞬间的)修饰属性，这个属性不能序列化
 *      (5)静态属性不能被序列化
 *      (6)序列化多个对象(借助集合实现)
 * @author Pan
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("E:\\IDEA_ioStream\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
        Student s = new Student("张三", 20);
        Student s1 = new Student("李四", 22);
        ArrayList<Student> list = new ArrayList<>();
        list.add(s);
        list.add(s1);
        oos.writeObject(list);
        //3.关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
package com.ioStream.ioStream_1;
​
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
​
/**
 * 使用ObjectInputStream实现反序列化（读取并重构成对象）
 * @author Pan
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("E:\\IDEA_ioStream\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件（反序列化）
//        Student s = (Student) ois.readObject();
//        Student s1 = (Student) ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
​
        //3.关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(s.toString());
//        System.out.println(s1.toString());
        System.out.println(list.toString());
    }
}

字符编码

  1. ISO-8859-1:收录出ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、布伯来语对应的文字符号

  2. UTF-8：针对Unicode码表的可变长度字符编码

  3. GB2312：简体中文

  4. GBK：简体中文扩充

  5. BIG5台湾，繁体中文

当编码方式和解码方式不一致，会出现乱码

字符流

package com.ioStream.ioStream_2;
​
import java.io.FileInputStream;
​
/**
 * 使用FileInputStream读取文件
 * @author Pan
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream对象
        FileInputStream fis = new FileInputStream("E:\\IDEA_ioStream\\hello.txt");
        //2.读取
        int data = 0;
        while ((data = fis.read()) != -1){//一个字节一个字节读取
            System.out.print((char) data);
        }
        //3.关闭
        fis.close();
​
    }
}
package com.ioStream.ioStream_2;
​
import java.io.FileReader;
​
/**
 * 使用FileReader读取文件
 *
 * @author Pan
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader文件字符输入流
        FileReader fr = new FileReader("E:\\IDEA_ioStream\\hello.txt");
        //2.读取
//        System.out.println("==========单个字符读取============");
//        int data = 0;
//        while ((data = fr.read()) != -1){//读取一个字符
//            System.out.print((char) data);
//        }
//        System.out.println();
        System.out.println("==========多个字符读取============");
        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();
    }
}
package com.ioStream.ioStream_2;
​
import java.io.FileWriter;
​
/**
 * 使用FileWriter写入文件
 * @author Pan
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter
        FileWriter fw = new FileWriter("E:\\IDEA_ioStream\\hello.txt",true);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            fw.write("\r\n天天向上");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕");
    }
}
package com.ioStream.ioStream_2;
​
import java.io.FileReader;
import java.io.FileWriter;
​
/**
 * 使用FileReader和FileWriter复制文件（只能复制文本文件，不能复制图片和二进制文件）
 * 使用字节流可以复制任意文件
 * @author Pan
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建
        FileReader fr = new FileReader("E:\\IDEA_ioStream\\hello.txt");
        FileWriter fw = new FileWriter("E:\\IDEA_ioStream\\helloCopy.txt");
​
        //2.复制
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count = fr.read(buf)) != -1){
//            fw.write(buf,0,count);
//        }
        int data = 0;
        while ((data = fr.read()) != -1){
            fw.write(data);
            fw.flush();
        }
​
        //3.关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

  • 缓冲流：BufferedReader/BufferedWriter

    • 高效读写

    • 支持输入换行符

    • 可一次写一行读一行

package com.ioStream.ioStream_2;
​
import java.io.BufferedReader;
import java.io.FileReader;
​
/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 * @author Pan
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流
        FileReader fr = new FileReader("E:\\IDEA_ioStream\\hello.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.读取
        //第一种方式
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count = br.read(buf)) != -1){
//            System.out.println(new String(buf,0,count));
//        }
        //第二种方式，一行一行的读取
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        
​
​
        //3.关闭
        br.close();
        System.out.println("执行完毕");
    }
}
package com.ioStream.ioStream_2;
​
import java.io.BufferedWriter;
import java.io.FileWriter;
​
/**
 * 演示BufferedWriter的使用
 * @author Pan
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建一个BufferedWriter对象
        FileWriter fw = new FileWriter("E:\\IDEA_ioStream\\writer.txt",true);
        BufferedWriter bw = new BufferedWriter(fw);
​
        //2.写入
        for (int i = 0; i < 10; i++) {
//            bw.write("好好学习，天天向上\r\n");
            bw.write("好好学习，天天向上");
            bw.newLine();//写入一个换行符（兼容性更好）
            bw.flush();
        }
​
        //3.关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

打印流

  • PrintWriter

    • 封装了print()/println()方法，支持写入后换行

    • 支持数据原样打印

package com.ioStream.ioStream_2;
​
import java.io.PrintWriter;
​
/**
 * 演示PrintWriter的使用
 * @author Pan
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintWriter pw = new PrintWriter("E:\\IDEA_ioStream\\print.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

转换流

  • 桥转换流：InputStreamReader/OutputStreamWriter

    • 可将字节流转成字符流

    • 可设置字符的编码方式

package com.ioStream.ioStream_3;
​
import java.io.FileInputStream;
import java.io.InputStreamReader;
​
/**
 * 使用InputStreamReader读取文件，指定使用的编码
 * @author Pan
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("E:\\IDEA_ioStream\\writer.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        //2.读取文件
        int data = 0;
        while ((data = isr.read()) != -1){
            System.out.print((char) data);
        }
​
        //3.关闭
        isr.close();
​
    }
}
package com.ioStream.ioStream_3;
​
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
​
/**
 * 使用OutputStreamWriter写入文件，使用指定编码
 * @author Pan
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWriter对象
        FileOutputStream fos = new FileOutputStream("E:\\IDEA_ioStream\\outWriter.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("好好学习，天天向上！\r\n");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

file类

概念：代表物理盘符中的一个文件或文件夹

补充：Properties：属性集合

  • 存储属性名和属性值

  • 属性名和属性值都是字符串类型

  • 没有泛型

  • 和流有关

package com.ioStream.ioStream_4;
​
import javax.xml.crypto.Data;
import java.io.File;
import java.io.FileFilter;
import java.util.Date;
​
/**
 * File的使用
 *  （1）分隔符
 *  （2）文件操作
 *  （3）文件姐操作
 * @author Pan
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe();
        directoryOpe();
    }
    //(1).分隔符
    public static void separator(){
        System.out.println("路径分隔符:"+File.pathSeparator);
        System.out.println("名称分隔符:"+File.separator);
    }
    //(2).文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件
        File file = new File("E:\\IDEA_ioStream\\file.txt");
//        System.out.println(file.toString());
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果:"+b);
        }
​
        //2.删除文件
​
        //2.1直接删除
//        System.out.println("删除结果："+file.delete());
​
        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);
​
        //3.获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称："+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("获取问价创建时间："+new Date(file.lastModified()).toLocaleString());
​
        //4.判断
//        System.out.println("是否可读："+file.canRead());
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
​
    }
    //(3).文件夹操作
    public static void directoryOpe() throws Exception{
        //1.创建文件夹
        File dir = new File("E:\\aaa\\bbb\\ccc");
        if (!dir.exists()){
//            dir.mkdir();//只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());//可以创建多级目录
        }
        //2.删除文件夹
​
        //2.1直接删除
//        System.out.println("删除结果"+dir.delete());//只删除最底层目录，并且必须为空目录
​
        //2.2使用jvm删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);
​
        //3.获取文件夹信息
        System.out.println("============================================");
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获取名称："+dir.getName());//底层文件夹名
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否是隐藏的："+dir.isHidden());
​
        //5.遍历文件夹
        File dir2 = new File("E:\\IDEA_ioStream");
        String[] files = dir2.list();
        System.out.println("-------------------------------------------");
        for (String s : files) {
            System.out.println(s);
​
        }
​
        System.out.println("==================FileFilter接口的使用================");
        File[] files1 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")) {
                    return true;
                }
                return false;
            }
        });
        for (File file : files1) {
            System.out.println(file.getName());
        }
​
    }
}
package com.ioStream.ioStream_4;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
​
/**
 * 演示Properties集合的使用
 * @author Pan
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建集合
        Properties properties = new Properties();
        //2.添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.遍历
        System.out.println("==============keySet()===============");
        Set<Object> keySet = properties.keySet();
        for (Object o : keySet) {
            System.out.println(o+"------"+properties.get(o));
        }
​
        System.out.println("==============entrySet()===============");
        Set<Map.Entry<Object, Object>> entries = properties.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            System.out.println(entry.getKey()+"------"+entry.getValue());
        }
        System.out.println("-------------------------");
        Iterator<Map.Entry<Object, Object>> it = entries.iterator();
        while (it.hasNext()){
            Map.Entry<Object, Object> next = it.next();
            System.out.println(next.getKey()+"------"+next.getValue());
        }
​
        //-------stringPropertyNames()--------
        System.out.println("-------stringPropertyNames()--------");
        Set<String> pronames = properties.stringPropertyNames();
        for (String proname : pronames) {
            System.out.println(proname+"------"+properties.get(proname));
        }
​
​
        //4.和流有关的方法
//        System.out.println("--------------------list方法---------------");
//        PrintWriter pw = new PrintWriter("E:\\print.txt");
//        properties.list(pw);
//        pw.close();
​
//        System.out.println("--------------------store方法（保存）---------------");
//        FileOutputStream fos = new FileOutputStream("E:\\store.properties");
//        properties.store(fos,"注释");
//        fos.close();
​
        System.out.println("--------------------load方法（加载）---------------");
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("E:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }
}

递归遍历和删除文件夹

package com.ioStream.ioStream_4;
​
import java.io.File;
​
/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 * @author Pan
 */
public class ListDemo {
    public static void main(String[] args) {
        listDir(new File("E:\\myfiles"));
//        deleteDir(new File("E:\\myfiles"));
    }
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        dir.getAbsolutePath();
        if (files!=null && files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file);//递归
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
​
    }
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null && files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    deleteDir(file);
                }else {
                    //递归删除文件
                    file.delete();
                }
            }
        }
        dir.delete();
    }
}
ァギキザ
关注
iostream与iostream.h的区别详细解析
09-05
在C++编程语言中，iostream和iostream.h是两个与输入输出流相关的头文件，但它们之间存在显著的差异。iostream是遵循C++标准库ISO/IEC 14882（C++98）及后续更新的C++11、C++14等版本的标准头文件，而iostream.h则是...
C++Iostream的实例
03-21
C++ Iostream 是C++标准库中的一个核心部分，它为输入输出操作提供了强大的支持。在C++中，iostream库取代了C语言中的stdio库，提供了面向对象的输入输出处理方式，使得输入输出操作更加直观和易用。下面将详细讨论...
iostream理解
神兽白泽
09-11 375
>>>>> // 输入输出流 || io流 #include <iostream>// in（输入） out（输出） stream（流） int main() { std::cout << "HelloWorld!" << std::endl;;// 打印且换行 printf("string");// 打印 system("pause");// 暂停 system("cls");// 清除屏幕 理解：clear screen
iostream库
kakakadela的博客
05-09 442
iostream包含了两个基础类型istream和ostream表示输入流和输出流 输出运算符<<: 接受两个运算对象，左侧必须为一个ostream对象，右侧为要打印的值，运算结果为左侧的运算对象，因此输出运算符可以连续使用。 输入运算符同上。 当使用一个istream对象作为条件时，即考察对象的真假，当遇到文件结束符、或无效的输入（如输入类型非法）时，istream对象非法，即为假 举例： int a,b=0;while（cin>>a)b+=a; 此处输入1 ...
【Learncpp中文翻译版】【1.5 — iostream 简介：cout、cin 和 endl】
eternity_memory的博客
08-07 602
在本课中，我们将更多地讨论std::cout，我们在中使用了它！程序输出文本到控制台。我们还将探索如何从用户那里获取输入，我们将使用它来使我们的程序更具交互性。
1.2 iostream库简介
Mirevas的博客
08-31 2218
iostream库 iostream库包含两个基础类型istream和ostream,分别表示输入流和输出流 一个流就是一个字符序列，是从IO设备读出或写入IO设备的 流想要表达的是，随着时间的推移，字符是顺序生成或消耗的 标准输入输出对象 标准库定义了四个IO对象 名为cin的istream类型对象，也称为标准输入对象 名为cout的ostream类型对象，也称为标准输出对象 名为cerr的ostream类型对象，通常用来输出警告和错误信息，也被称为标准错误 名为clog的ostream类型对象，用
基础头文件iostream
司职在下的博客
02-14 974
iostream头文件基础内容
C语言头文件 IOSTREAM
06-12
C语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAMC语言头文件 IOSTREAM...
C语言头文件 IOSTREAM.H
06-12
C语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC语言头文件 IOSTREAM.HC...
iostream 代表着什么意思？
m0_74757548的博客
01-11 2475
std 是stream的缩写，是iostream文件中标注的一个命名空间，里面规定了标识符，比如cout。iostream 是一个头文件，里面设置了输入/输出相关环境，只有包含了这个文件才能使用cout对象。#include 这条命令的意思是让iostream里面的内容包含在程序中。cout标准输出流对象，与显示器相关联的,允许使用
概念梳理：C++中iostream头文件和命名空间的基础介绍和拓展内容
Aer_7z的博客
04-18 1万+
本文主要记录C++中的iostream头文件和命名空间的内容，包含cin和cout的运行原理，std::cin和cin还有std::cout和cout之间的差别，并针对它们的使用方法展开拓展。
IOStream的用法总结
十个雨点的博客
07-14 9602
被复杂的IOStream弄晕了，因为经常会出现层层包裹的情况，学习了一天，发现其实挺有规律的，总结一下： 以输入流为例，输入流分为字节流和字符流，分别对应InputStream和Reader，而InputStreamReader是将InputStream封装成Reader的桥梁，一般会用于包装最外层的是BufferedReader，中间可能
iostream
顺其自然~专栏
11-13 1万+
iostream是指iostream库。iostream的意思是输入输出流，直接点说就是in（输入） out（输出） stream（流），取in、out的首字母与stream合成。 组成 iostream 库的基础是两种命名为 istream 和 ostream 的类型,分别表示输入流和输出流。流是指要从某种 IO 设备上读出或写入的字符序列。术语“流”试图说明字符是随着时间顺序生成或消耗的。 标准库定义了 4 个 IO 对象。处理输入时使用命名为 cin(读作 see-in)的 istream
iostream库到底是什么？存放在哪里？
ustc_sse_shenzhang的博客
10-08 7881
首先看百度百科： 那么这个库到底是什么？总感觉很神秘、和我们平常写的程序不一样，摸不着看不见的感觉。 下面我们就通过vs2010来定位这些神秘的c++库。看看他们到底长啥样~ 首先 编写一个最简单的helloworld程序。 让光标放在iostream上，点击右键，点击“打开文档<iostream>”， 就打开了这个所谓的iostream库了，如果还嫌不够具体...
C++的iostream标准库介绍+使用详解(转)
weixin_34319999的博客
11-30 1578
0 为什么需要iostream 我们从一开始就一直在利用C++的输入输出在做着各种练习，输入输出是由iostream库提供的，所以讨论此标准库是有必要的，它与C语言的 stdio库不同，它从一开始就是用多重继承与虚拟继承实现的面向对象的层次结构，作为一个c++的标准库组件提供给程序员使用。 　　iostream为内置类型对象提供了输入输出支持，同时也支持文件的输入输出，类的设计者可以通过对...
C++中头文件iostream介绍
热门推荐
网络资源是无限的
03-19 8万+
C++语言不直接处理输入输出，而是通过一簇定义在标准库中的类型来处理IO。这些类型支持从设备读取数据、向设备写入数据的IO操作，设备可以是文件、控制台窗口等。还有一些类型允许内存IO，即，从string读取数据，向string写入数据。 C++/C++11中头文件<iostream>定义了标准输入/输出流对象。包含了<iostream>也自动包含了<ios>、...
C++里面的iostream是什么
瑞新の博客：bennyrhys
03-28 2万+
刚接触c++，我感觉很有意思,记录C++走过的坑 C++编译系统提供了用于输入输出的iostream类库。iostream这个单词是由3个部分组成的，即i-o-stream，意为输入输出流。在iostream类库中包含许多用于输入输出的类。 ios是抽象基类，由他派生出istream类和ostream类，两个类名中第一个字母i和o分别代表输入（input）和输出（output）。isrream类...
iostream下载
最新发布
04-10
iostream是C++标准库中的一个头文件，用于输入输出流的操作。它提供了一些类和函数，可以方便地进行输入和输出操作。iostream包括了两个主要的类：istream和ostream，分别用于输入和输出。 要使用iostream，你不需要单独下载它，因为它是C++标准库的一部分，已经包含在编译器中。你只需要在你的C++程序中包含<iostream>头文件即可开始使用iostream库的功能。 下面是一些iostream的常用功能： 1. 输入操作：可以使用cin对象从标准输入设备（通常是键盘）读取数据。 2. 输出操作：可以使用cout对象向标准输出设备（通常是屏幕）输出数据。 3. 格式化输出：可以使用格式化控制符来控制输出的格式，如设置精度、宽度等。 4. 文件操作：可以使用fstream类来进行文件的输入输出操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值