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

    展开全文
  • IO流

    2019-07-14 11:33:12
    IO流IO流:1. 字节缓冲流2. 字符缓冲流3. 对象流 IO流: Reader reader = new FileReader(File file); Writer writer = new Writer writer(File file); InputStream is = new FileInputStream(File file); ...

    IO流:

    Reader reader = new FileReader(File file);
    Writer writer = new Writer writer(File file);

    InputStream is = new FileInputStream(File file);
    OutputStream os = new FileOutputStream(File file);

    缓冲流: 属于功能流,用于增强性能,提高功能,提高读写速度.
    功能流的使用:功能流包裹节点流. 功能流(节点流)

    1. 字节缓冲流

    BufferedInputStream和BufferedOutputStream

    InputStream is = new BufferedInputStream(new FileInputStream("X:/xxx/xx"))
    OutputStream os = new BufferedOutputStream(new FileOutputStream("X:/xxx/xx"))
    

    2. 字符缓冲流

    新增方法: String readLine() 读取 一个文本行
    void newLine() 写入一个行分隔符
    BufferedRead rd = new BufferedReader(new FileReader(“X:/xxx/xx”))
    BufferedWriter rw = new BufferedWriter(new FileReader(“X:/xxx/xx”))

    3. 对象流

    对象流:保留数据+数据类型
    使用方式: 对象流包节点流 对象流(节点流)
    序列化:将对象的信息状态,变为可存储,可传输的过程
    序列化输出流:ObjectOutputStream(OutputStream)
    新增方法: void writeObject(Object obj)将指定的对象写入objectOutputStream.
    反序列化输入流 ObjectInputStream(InputStream)

    注意:

    1. 不是所有类型的对象都能序列化 实现 java.io.Serializable
    2. 先序列化后反序列化 写出读入的过程一致
    3. 不是对象的所有属性都需要序列化 transient
    4. static不能被序列化
    5. 如果父类实现了Serializable接口,子类中所有内容都能序列化
    6. 如果父类没有实现,子类实现了Serializable接口,只能序列化子类中独有的内容
    public class ObjectDemo04 {
    	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
    		write("D:/bbb.txt");
    		read("D:/bbb.txt");
    	}
    	
    	//读入对象信息
    	public static void read(String pathName) throws FileNotFoundException, IOException, ClassNotFoundException{
    		//流
    		ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(pathName)));
    		//读
    		Person obj1=(Person)(is.readObject());
    		String[] obj2=(String[])(is.readObject());
    		System.out.println(obj1+"-->"+Arrays.toString(obj2));
    		//关闭
    		is.close();
    	}
    	
    	//写出对象信息
    	public static void write(String pathName) throws FileNotFoundException, IOException{
    		//构建流
    		ObjectOutputStream wr=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(pathName)));
    		Person p=new Person("李毅",25,"hehe");
    		String[] arr={"呵呵","哈哈"};
    		//写出
    		wr.writeObject(p);
    		wr.writeObject(arr);
    		
    		p.setName("老裴");
    		p.haha="lllllllllll";
    		//刷出
    		wr.flush();
    		//关闭
    		wr.close();
    	}
    }
    
    class Person implements Serializable{
    	private String name;
    	private transient int age;
    	static String haha="123345";
    	public Person() {
    		// TODO Auto-generated constructor stub
    	}
    	public Person(String name, int age,String haha) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.haha=haha;
    	}
    	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 "Person [name=" + name + ","+age+","+haha+"]";
    	}
    	
    }
    
    展开全文
  • 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);
    		}
    	}
    
    }
    
    展开全文
  • io流概述: IO流用来处理设备之间的数据传输,上传文件和下载文件,Java对数据的操作是通过流的方式,Java用于操作流的对象都在IO包中。 IO流分类 按照数据流向 输入流 读入数据 输出流 写出数据 按照数据...

    io流概述:

    IO流用来处理设备之间的数据传输,上传文件和下载文件,Java对数据的操作是通过流的方式,Java用于操作流的对象都在IO包中。

    IO流分类

    按照数据流向

    输入流 读入数据

    输出流 写出数据

    按照数据类型

    字节流

    字符流

    什么情况下使用哪种流呢?

    如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容,就用字符流,其他用字节流。

    如果你什么都不知道,就用字节流。

    IO流常用基类

    字节流的抽象基类:

    InputStream ,OutputStream。

    字符流的抽象基类:

    Reader , Writer。

    注:
    由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
    如:InputStream的子类FileInputStream。
    如:Reader的子类FileReader。

    OutputStream的子类FileOutputStream

    构造方法:

    FileOutputStream(File file)

    FileOutputStream(String name)

    推荐第二种构造方法:

    FileOutputStream outputStream = new FileOutputStream("a.txt");
    

    创建字节输出流对象了做了几件事情:

    A:调用系统功能去创建文件
    B:创建outputStream对象
    C:把foutputStream对象指向这个文件
    

    通过字节输出流写出数据到文本

    public void write(int b)
    public void write(byte[] b)
    public void write(byte[] b,int off,int len)
    

    从方法中可看出,只能通过字节写出

    outputStream.write("hello".getBytes()); 文本中出现hello
    outputStream.write(96)  //文本中出现 a
    
    byte[] bys={97,98,99,100,101};
    outputStream.write(bys,1,3); 文本中出现bcd
    

    如此写出,文本中数据不会换行,不会追加,每次写出都是覆盖原来。

    追加:
    FileOutputStream outputStream = new FileOutputStream("a.txt",true);
    //第二个参数true设置为可追加。
    
    换行 \n\r :
    for (int i = 0; i <5 ; i++) {
        outputStream.write("hello".getBytes());
        outputStream.write("\n\r".getBytes());
        }
    

    注:用完流一定要记得关闭。

    outputStream.close();
    

    完整示例:

    package io2;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    /**
     * new FileOutputStream("a.txt",true);  第二个参数true,设置为写入的数据拼接在尾部
     * \n\r 换行
     * write(bys,1,3);  写入字节数组
     */
    public class out {
        public static void main(String args[]){
            FileOutputStream outputStream = null;
            try {
                //FileOutputStream fos = new FileOutputStream(file);
                outputStream = new FileOutputStream("a.txt",true);
                /*
                 * 创建字节输出流对象了做了几件事情:
                 * A:调用系统功能去创建文件
                 * B:创建outputStream对象
                 * C:把foutputStream对象指向这个文件
                 */
    
    //            for (int i = 0; i <5 ; i++) {
    //                outputStream.write("hello".getBytes());
    //                outputStream.write("\n\r".getBytes());
    //            }
                byte[] bys={97,98,99,100,101};
                outputStream.write(bys,1,3);
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }
    
    

    InputStream的子类FileInputStream

    FileInputStream的构造方法

    FileInputStream(File file)
    FileInputStream(String name)
    

    推荐第二种构造方法:

     FileInputStream inputStream = new FileInputStream("a.txt");
    

    把刚才写的数据现在读取到控制台:

    public int read()
    public int read(byte[] b)
    

    第一个read是读一个字节,第二个read是读一个字节数组。

    //读一个字节
    int by = 0;
    while ((by=inputStream.read())!=-1){
          System.out.println((char)by);
    }
    

    读到没数据了就返回-1,这个用来判断是否读完。

    //读一个字节数组,一般是1024大小
    int len = 0 ;
    byte[] bys = new byte[1024];
    while ((len = inputStream.read(bys)) != -1) {
        System.out.println(new String(bys,0,len));
    }
    

    两个read的返回值略有不同,read()返回读取的字节,读到末尾返回-1,read(byte[] b)返回的是读到的字节个数,读到的字节放在了bytes字节数组里,读到末尾没数据了返回-1。

    两种读取方式图解:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yv0oyKLy-1603813798619)(http://p5kllyq5h.bkt.clouddn.com/174401.jpg)]

    同样的用完了流,也要及时的关闭,以防占用内存。

    inputStream.close();
    

    完整示例:

    建议以字节数组的方式读取数据。

    package io2;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    /**
     * Create by stefan
     * Date on 2018-05-27  23:00
     * Convertion over Configuration!
     */
    public class input2 {
        public static void main(String args[]){
            FileInputStream inputStream = null;
            try {
                inputStream = new FileInputStream("a.txt");
    //            byte[] bys = new byte[4];
    //            int len = inputStream.read(bys);
    //            System.out.println(new String(bys));  //bcd
    //            System.out.println(len);  //3
    //            System.out.println(inputStream.read(bys));  //-1
                int len = 0 ;
                byte[] bys = new byte[1024];
                while ((len = inputStream.read(bys)) != -1) {
                    System.out.println(new String(bys,0,len));
                }
                /**
                 *    public String(byte bytes[]) {
                 this(bytes, 0, bytes.length);
                 }
                 */
    
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }
    
    

    字节流复制文件

    利用输入流读取一个文件里的字节,再利用输出流将读取到的字节写出到另一个文件中(不存在会自动创建)

    package io2;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.Arrays;
    
    /**
     * Create by stefan
     * Date on 2018-05-27  23:19
     * Convertion over Configuration!
     */
    public class copy {
        public static void main(String args[]) throws IOException {
            FileInputStream inputStream = new FileInputStream("E:\\huge1.jpg");
            FileOutputStream outputStream = new FileOutputStream("E:\\古月.jpg");
            
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len=inputStream.read(bytes)) != -1) {
                outputStream.write(bytes,0,len);
            }
            inputStream.close();
            outputStream.close();
        }
    }
    
    

    注:复制文本、图片、mp3、视频等的方式一样。

    字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多,这是加入了数组这样的缓冲区效果。

    java本身在设计的时候,也考虑到了这样的设计思想(装饰设计模式后面讲解),所以提供了字节缓冲区流。

    字节缓冲输出流
    BufferedOutputStream
    字节缓冲输入流
    BufferedInputStream
    

    BufferedOutputStream

    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));
    bos.write("hello world".getBytes());
    bos.close();
    

    BufferedInputStream

    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
    byte[] bytes = new byte[1024];
    int len = 0;
    while ((len=bis.read(bytes)) != -1) {
        System.out.println(new String(bytes,0,len));
    }
    bis.close();
    

    注:

    • 成员方法与字节流基本一样,字节缓冲流的作用就是提高输入输出的效率。
    • 构造方法可以指定缓冲区的大小,但是我们一般用不上,因为默认缓冲区大小就足够了。
    • 为什么不传递一个具体的文件或者文件路径,而是传递一个OutputStream对象呢?原因很简单,字节缓冲区流仅仅提供缓冲区,为高效而设计的。但是呢,真正的读写操作还得靠基本的流对象实现。

    复制文件的升级:

    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
    int len = 0;
    byte[] bytes =new byte[1024];
    while ((len=bis.read(bytes)) != -1) {
        bos.write(bytes,0,len);
    }
    bis.close();
    bos.close();
    

    测试:四种复制文件的效率高低

    package io2;
    
    import java.io.*;
    
    /**
     *
     * 测试复制的时间
     * Create by stefan
     * Date on 2018-05-28  10:28
     * Convertion over Configuration!
     */
    public class copy2 {
        //一个字节一个字节的复制,耗时22697毫秒
        public static  void  fun() throws IOException {
            FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
            FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
            int by = 0;
            while ((by=fis.read()) != -1) {
                fos.write(by);
            }
            fis.close();
            fos.close();
        }
        //1024字节数组复制 耗时63毫秒
        public  static void  fun1() throws IOException {
            FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
            FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
            int len = 0;
            byte[] bytes =new byte[1024];
            while ((len=fis.read(bytes)) != -1) {
                fos.write(bytes,0,len);
            }
            fis.close();
            fos.close();
        }
        // 一个字节一个字节复制,但是用了缓冲流 耗时64毫秒
        public static   void  fun2() throws IOException {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
            int by = 0;
            while ((by=bis.read()) != -1) {
                bos.write(by);
            }
            bis.close();
            bos.close();
        }
        // 1024字节数组复制并用了缓冲流 耗时7毫秒
        public  static void  fun3() throws IOException {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
            int len = 0;
            byte[] bytes =new byte[1024];
            while ((len=bis.read(bytes)) != -1) {
                bos.write(bytes,0,len);
            }
            bis.close();
            bos.close();
        }
    
        public static void main(String args[]) throws IOException {
            long t1 = System.currentTimeMillis();
            fun3();
            long t2 = System.currentTimeMillis();
            System.out.println(t2-t1);
        }
    
    }
    
    

    经测试结果显示:
    1024字节数组复制并用了缓冲流 的方式效率最高。

    以上是本人学习笔记整理,重温java经典,欢迎各位同道中人批评指正。

    源码码云地址:
    https://gitee.com/stefanpy/java

    梦回io流完整目录:

    java基础io流——File告白(重温经典)

    java基础io流——OutputStream和InputStream的故事(温故知新)

    java基础io流——字符流的变革(深入浅出)

    java基础io流——配角也风流(不求甚解)

    展开全文
  • 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、...
  • C++三大IO流类总结——标准IO流、文件IO流、内存IO流 IO流类一览标准IO流标准IO流的条件状态条件状态标志条件状态函数标准IO流的输入输出成员函数代码示例条件状态put和get函数getline函数标准IO的格式控制输出格式...
  • Java IO流学习总结(一)—— IO流分类和常用IO流汇总 IO流的分类: - 按流向分类:输入流、输出流 - 按操作对象分类:字节流、字符流 - 按功能分类:节点流、处理流 IO流的设计模式为装饰设计模式; ...
  • Java IO流学习总结一:输入输出流

    万次阅读 多人点赞 2017-01-09 19:49:50
    Java IO流学习总结一:输入输出流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构:流的概念和作用流是一组有顺序的,有起点和终点的字节...
  • Java IO流

    万次阅读 2018-10-14 01:09:56
    Java IO流中各种流的介绍和实现图片的读写
  • Java 常用IO流操作详解

    万次阅读 多人点赞 2016-05-22 17:19:31
    IO流大家肯定不陌生,简单整理了一下常用IO流基本用法,其他的IO流以后有时间在整理。 1.基本概念IO:Java对数据的操作是通过流的方式,IO流用来处理设备之间的数据传输,上传文件和下载文件,Java用于操作流的...
  • Java IO流学习总结(二)—— 常用IO流继承关系图

    万次阅读 多人点赞 2018-04-10 20:16:35
    Java IO流学习总结(二)—— 常用IO流继承关系图 接Java IO流学习总结(一)—— IO流分类和常用IO流汇总中汇总的IO流的继承关系图如下:
  • java io流

    千次阅读 多人点赞 2020-01-12 16:42:30
    io流 数据传输是需要通道的,io流就是一种数据通道,而io流又分为好几种,分为大类就有字节流和字符流了; 作用:可以用来进行上传和下载,比如说上传QQ头像等; 虽然说有那么多的流看起来眼花缭乱的,但是实际使用...
  • 我们在进行Android java 开发的时候,经常会遇到各种IO流操作。IO流操作一般分为两类:字符流和字节流。以“Reader”结尾都是字符流,操作的都是字符型的数据;以“Stream”结尾的都是字节流,操作的都是byte数据。...
  • java IO流学习总结

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

    2013-02-18 13:44:14
    对于初学者掌握IO流操作之前起着抛砖引玉的作用。 1.IO流是干什么的?  IO流指 的是输入输出流,用来处理设备上的数据。这里的设备指硬盘,内存,键盘录入,网络传输等。 2.IO流的分类?  按处理...
  • IO流-转换流

    2018-03-29 18:04:23
    IO流就是输入/输出程序的数据流,通过IO流技术可以实现从程序中读取外部数据或者将数据从程序中输出到外部设备中。 2.java.io 输入流 输出流 字节流 InputStream OutputStream 字符流 Reader Writer 四大...
  • Java IO流复习

    2019-10-11 13:56:54
    文章目录Java.io 字符流Java.io...字符流IO流ReaderCharArrayReaderBufferedReaderLineNumberReaderFilterReaderPushbackReaderInputStreamReaderFileReaderPipedReaderStringReader 类 功能 Rea...
  • java IO流之一 IO流介绍

    千次阅读 2012-05-21 10:31:17
    1.IO流是干什么的?  IO流指 的是输入输出流,用来处理设备上的数据。这里的设备指硬盘,内存,键盘录入,网络传输等。 2.IO流的分类?  按处理数据类型来分:字节流和字符流  按流的方向来分:输入流和输入...
  • 你真的懂IO流

    千次阅读 多人点赞 2020-07-12 14:37:59
    目录什么是IO流IO流的分类输入输出流字节字符流 什么是IO流 在我们的程序运行当中,不可避免的要与数据打交道,我们应该如何获取这些数据?这就用到IO流了 IO:Input/Output,输入输出流 作用:通过IO流可以完成硬盘...
  • 前面几篇文章学习了File类的基本使用,但是发现了一个问题没有,目前我们都没有讲文件的打开和编辑修改的代码,原因就是我们需要学习IO流才能做到这些。这篇,来学习IO流的基本概念和分类以及注意事项,纯概念没有...
  • java基础:11、java中IO流分为几种?
  • Java基础之IO流

    千次阅读 多人点赞 2018-08-20 22:05:58
    IO流(利用缓冲区实现)IO流利用缓冲区实现 IO流(给图片加密) IO流(字节流读写中文) 字符流 IO流(自定义字符数组的拷贝) IO流(字符流的拷贝) IO流(自定义字符数组的拷贝) IO流(带缓冲的字符流...
  • 深入了解IO流

    千次阅读 2020-07-06 10:26:27
    IO流 流的概念 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。 程序中的输入输出都是以流的形式保存的...
  • 摘要:读完本章节,您对java 的IO流有更清晰深刻的认识,对适配器模式、装饰模式也有初步的了解。 一、关于流引用百度百科上的解释: 流是一种抽象概念,它代表了数据的无结构化传递。按照流的方式进行输入输出,...
  • Java IO流总结

    万次阅读 2019-01-24 22:57:01
    IO流可以简单的理解为两种设备的中间介质,类似于管道,我们要做的就是把这个管道搭建好。有了管道以后就可以两个设备进行一些操作(读写,复制)。 IO流根据操作数据分为字节流和字符流,根据流向分为输入流和输出流...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,969
精华内容 29,187
关键字:

io流