精华内容
下载资源
问答
  • Java IO流学习总结一:输入输出流

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

    Java IO流学习总结一:输入输出流

    转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/54292148
    本文出自【赵彦军的博客】

    Java IO流学习总结一:输入输出流
    Java IO流学习总结二:File
    Java IO流学习总结三:缓冲流-BufferedInputStream、BufferedOutputStream
    Java IO流学习总结四:缓冲流-BufferedReader、BufferedWriter
    Java IO流学习总结五:转换流-InputStreamReader、OutputStreamWriter
    Java IO流学习总结六:ByteArrayInputStream、ByteArrayOutputStream
    Java IO流学习总结七:Commons IO 2.5-FileUtils

    2021年 Java Okio-更加高效易用的IO库

    Java流类图结构:

    这里写图片描述

    流的概念和作用

    流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。

    IO流的分类

    • 根据处理数据类型的不同分为:字符流和字节流
    • 根据数据流向不同分为:输入流和输出流

    字符流和字节流

    字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。 字节流和字符流的区别:

    • 读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。

    • 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。

    • 字节流:一次读入或读出是8位二进制。

    • 字符流:一次读入或读出是16位二进制。

    设备上的数据无论是图片或者视频,文字,它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现,所以计算机中的最小数据单元就是字节。意味着,字节流可以处理设备上的所有数据,所以字节流一样可以处理字符数据。

    结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。

    输入流和输出流

    输入流只能进行读操作,输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。

    输入字节流 InputStream

    • InputStream 是所有的输入字节流的父类,它是一个抽象类。
    • ByteArrayInputStreamStringBufferInputStreamFileInputStream 是三种基本的介质流,它们分别从Byte 数组StringBuffer、和本地文件中读取数据。
    • PipedInputStream 是从与其它线程共用的管道中读取数据,与Piped 相关的知识后续单独介绍。
    • ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

    输出字节流 OutputStream

    • OutputStream 是所有的输出字节流的父类,它是一个抽象类。
    • ByteArrayOutputStreamFileOutputStream 是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。
    • PipedOutputStream 是向与其它线程共用的管道中写入数据。
    • ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

    总结:

    • 输入流:InputStream或者Reader:从文件中读到程序中;
    • 输出流:OutputStream或者Writer:从程序中输出到文件中;

    节点流

    节点流:直接与数据源相连,读入或读出。
    直接使用节点流,读写不方便,为了更快的读写文件,才有了处理流。
    这里写图片描述

    常用的节点流

    • 父 类 :InputStreamOutputStreamReaderWriter
    • 文 件 :FileInputStreamFileOutputStreanFileReaderFileWriter 文件进行处理的节点流
    • 数 组 :ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter 对数组进行处理的节点流(对应的不再是文件,而是内存中的一个数组)
    • 字符串 :StringReaderStringWriter 对字符串进行处理的节点流
    • 管 道 :PipedInputStreamPipedOutputStreamPipedReaderPipedWriter 对管道进行处理的节点流

    处理流

    处理流和节点流一块使用,在节点流的基础上,再套接一层,套接在节点流上的就是处理流。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。
    这里写图片描述

    常用的处理流

    • 缓冲流:BufferedInputStreanBufferedOutputStreamBufferedReaderBufferedWriter 增加缓冲功能,避免频繁读写硬盘。
    • 转换流:InputStreamReaderOutputStreamReader实现字节流和字符流之间的转换。
    • 数据流: DataInputStreamDataOutputStream 等-提供将基础数据类型写入到文件中,或者读取出来。

    转换流

    InputStreamReaderOutputStreamWriterInputStreamOutputStream作为参数,实现从字节流到字符流的转换。

    构造函数

    InputStreamReader(InputStream);        //通过构造函数初始化,使用的是本系统默认的编码表GBK。
    InputStreamReader(InputStream,String charSet);   //通过该构造函数初始化,可以指定编码表。
    OutputStreamWriter(OutputStream);      //通过该构造函数初始化,使用的是本系统默认的编码表GBK。
    OutputStreamwriter(OutputStream,String charSet);   //通过该构造函数初始化,可以指定编码表。
    

    实战演练

    • FileInputStream类的使用:读取文件内容
    package com.app;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class A1 {
    
    	public static void main(String[] args) {
    		A1 a1 = new A1();
    	
    		//电脑d盘中的abc.txt 文档
    		String filePath = "D:/abc.txt" ;
    		String reslut = a1.readFile( filePath ) ;
            System.out.println( reslut ); 
    	}
    
    
    	/**
    	 * 读取指定文件的内容
    	 * @param filePath : 文件的路径
    	 * @return  返回的结果
    	 */
    	public String readFile( String filePath ){
    		FileInputStream fis=null;
    		String result = "" ;
    		try {
    			// 根据path路径实例化一个输入流的对象
    			fis  = new FileInputStream( filePath );
    
    			//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值;
    			int size =  fis.available() ;
    			//3. 根据输入流中的字节数创建byte数组;
    			byte[] array = new byte[size];
    			//4.把数据读取到数组中;
    			fis.read( array ) ; 
    
    			//5.根据获取到的Byte数组新建一个字符串,然后输出;
    			result = new String(array);	
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			if ( fis != null) {
    				try {
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    
    		return result ;
    	}
    
    
    }
    
    
    
    • FileOutputStream 类的使用:将内容写入文件
    package com.app;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class A2 {
    
    	public static void main(String[] args) {
    		A2 a2 = new A2();
    
    		//电脑d盘中的abc.txt 文档
    		String filePath = "D:/abc.txt" ;
    
    		//要写入的内容
    		String content = "今天是2017/1/9,天气很好" ;
    		a2.writeFile( filePath , content  ) ;
    
    	}
    
    	/**
    	 * 根据文件路径创建输出流
    	 * @param filePath : 文件的路径
    	 * @param content : 需要写入的内容
    	 */
    	public void writeFile( String filePath , String content ){
    		FileOutputStream fos = null ;
    		try {
    			//1、根据文件路径创建输出流
    			fos  = new FileOutputStream( filePath );
    
    			//2、把string转换为byte数组;
    			byte[] array = content.getBytes() ;
    			//3、把byte数组输出;
    			fos.write( array );
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			if ( fos != null) {
    				try {
    					fos.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    
    }
    
    

    注意:

    1. 在实际的项目中,所有的IO操作都应该放到子线程中操作,避免堵住主线程。
    2. FileInputStream在读取文件内容的时候,我们传入文件的路径("D:/abc.txt"), 如果这个路径下的文件不存在,那么在执行readFile()方法时会报FileNotFoundException异常。
    3. FileOutputStream在写入文件的时候,我们传入文件的路径("D:/abc.txt"), 如果这个路径下的文件不存在,那么在执行writeFile()方法时, 会默认给我们创建一个新的文件。还有重要的一点,不会报异常。

    效果图:

    这里写图片描述

    • 综合练习,实现复制文件,从D盘复制到E盘
    package com.app;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class A3 {
    
    	public static void main(String[] args) {
    		A3 a2 = new A3();
    
    		//电脑d盘中的cat.png 图片的路径
    		String filePath1 = "D:/cat.png" ;
    
    		//电脑e盘中的cat.png 图片的路径
    		String filePath2 = "E:/cat.png" ;
    
    		//复制文件
    		a2.copyFile( filePath1 , filePath2 );
    
    	}
    
    	/**
    	 * 文件复制 
    	 * @param filePath_old : 需要复制文件的路径
    	 * @param filePath_new : 复制文件存放的路径
    	 */
    	public void copyFile( String filePath_old  , String filePath_new){
    		FileInputStream fis=null ;
    		FileOutputStream fout = null ;
    		try {
    			// 根据path路径实例化一个输入流的对象
    			fis  = new FileInputStream( filePath_old );
    
    			//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值;
    			int size =  fis.available() ;
    			//3. 根据输入流中的字节数创建byte数组;
    			byte[] array = new byte[size];
    			//4.把数据读取到数组中;
    			fis.read( array ) ; 
    
    			//5、根据文件路径创建输出流
    			fout = new FileOutputStream( filePath_new ) ;
    			
    			//5、把byte数组输出;
    			fout.write( array );
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			if ( fis != null) {
    				try {
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    			if ( fout != null ) {
    				try {
    					fout.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}	
    			}
    		}
    	}
    }
    
    
    展开全文
  • Java IO流处理 面试题汇总

    万次阅读 多人点赞 2018-01-27 22:17:36
    说明:本节内容来源于网络汇总 输入输出是相对于内存而言的! ...(1)java中有几种类型的?...字符和字节。...(2)谈谈Java IO里面的常见类,字节,字符、接口、实现类、方法阻塞 答:输入就...

    说明:本节内容来源于网络汇总

    这里写图片描述

    这里写图片描述

    输入输出流是相对于内存而言的!

    ##1、面试题汇总

    (1)java中有几种类型的流?

    2021-08-19更新:
    从编码方式上,分为字符流和字节流。

    如上图可知:

    • 字节流继承inputStream和OutputStream
    • 字符流继承自Reader和Writer。

    (2)谈谈Java IO里面的常见类,字节流,字符流、接口、实现类、方法阻塞

    答:输入流就是从外部文件输入到内存,输出流主要是从内存输出到文件。
    IO里面常见的类,第一印象就只知道IO流中有很多类,IO流主要分为字符流和字节流。字符流中有抽象类InputStream和OutputStream,它们的子类FileInputStream,FileOutputStream,BufferedOutputStream等。字符流BufferedReader和Writer等。都实现了Closeable, Flushable, Appendable这些接口。程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。
    java中的阻塞式方法是指在程序调用改方法时,必须等待输入数据可用或者检测到输入结束或者抛出异常,否则程序会一直停留在该语句上,不会执行下面的语句。比如read()和readLine()方法。

    (3)字符流和字节流有什么区别?

    要把一片二进制数据数据逐一输出到某个设备中,或者从某个设备中逐一读取一片二进制数据,不管输入输出设备是什么,我们要用统一的方式来完成这些操作,用一种抽象的方式进行描述,这个抽象描述方式起名为IO流,对应的抽象类为OutputStream和InputStream ,不同的实现类就代表不同的输入和输出设备,它们都是针对字节进行操作的。

    在应用中,经常要完全是字符的一段文本输出去或读进来,用字节流可以吗?
    计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符,首先要得到其对应的字节,然后将字节写入到输出流。读取时,首先读到的是字节,可是我们要把它显示为字符,我们需要将字节转换成字符。由于这样的需求很广泛,人家专门提供了字符流的包装类。

    底层设备永远只接受字节数据,有时候要写字符串到底层设备,需要将字符串转成字节再进行写入。字符流是字节流的包装,字符流则是直接接受字符串,它内部将串转成字节,再写入底层设备,这为我们向IO设别写入或读取字符串提供了一点点方便。

    (4)讲讲NIO

    答:看了一些文章,传统的IO流是阻塞式的,会一直监听一个ServerSocket,在调用read等方法时,他会一直等到数据到来或者缓冲区已满时才返回。调用accept也是一直阻塞到有客户端连接才会返回。每个客户端连接过来后,服务端都会启动一个线程去处理该客户端的请求。并且多线程处理多个连接。每个线程拥有自己的栈空间并且占用一些 CPU 时间。每个线程遇到外部未准备好的时候,都会阻塞掉。阻塞的结果就是会带来大量的进程上下文切换。
    对于NIO,它是非阻塞式,核心类:
    1.Buffer为所有的原始类型提供 (Buffer)缓存支持。
    2.Charset字符集编码解码解决方案
    3.Channel一个新的原始 I/O抽象,用于读写Buffer类型,通道可以认为是一种连接,可以是到特定设备,程序或者是网络的连接。

    (5)递归读取文件夹的文件

    package test;
    
    import java.io.File;
    
    /**
     * 
     * 递归读取文件夹的文件
     */
    public class ListFileDemo {
    	public static void listFile(String path) {
    		if (path == null) {
    			return;// 因为下面的new File如果path为空,回报异常
    		}
    		File[] files = new File(path).listFiles();
    		if (files == null) {
    			return;
    		}
    		for(File file : files) {
    			if (file.isFile()) {
    				System.out.println(file.getName());
    			} else if (file.isDirectory()) {
    				System.out.println("Directory:"+file.getName());
    				listFile(file.getPath());
    			} else {
    				System.out.println("Error");
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		ListFileDemo.listFile("D:\\data");
    
    	}
    }
    
    

    这里写图片描述
    运行结果

    Hamlet.txt
    Directory:ml-1m
    movies.dat
    ratings.dat
    README
    users.dat
    

    2、Java IO总结

    (1)明确源和目的。
    数据source:就是需要读取,可以使用两个体系:InputStream、Reader;
    数据destination:就是需要写入,可以使用两个体系:OutputStream、Writer;

    (2)操作的数据是否是纯文本数据?

       如果是:
               数据source:Reader
               数据destination:Writer 
       如果不是:
               数据source:InputStream
               数据destination:OutputStream
    

    (3)Java IO体系中有太多的对象,到底用哪个呢?
    明确操作的数据设备。
    数据source对应的设备:硬盘(File)内存(数组)键盘(System.in)
    数据destination对应的设备:硬盘(File),内存(数组),控制台(System.out)

    记住,只要一读取键盘录入,就用这句话。
    BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

    展开全文
  • java io流

    万次阅读 2018-02-08 23:26:39
    java IO流 什么是IO流 io是input/output的简称。在我们大学学习计算原理的时候,我们知道计算的组成: 输入设备,输出设备,存储器(内存,外存),运算器,控制器。 程序 = 数据结构 + 算法 ; 程序需要处理...

    java IO流

    什么是IO流

    io是input/output的简称。在我们大学学习计算原理的时候,我们知道计算的组成:
    输入设备,输出设备,存储器(内存,外存),运算器,控制器。

    程序 = 数据结构 + 算法 ;

    程序需要处理能够读取输入的数据,并且经过程序处理之后需要输出到存储器进行持久化。
    java对输入输出进行了封装,给我们提供了一系列的api,使我们脱离于对最底层硬件的操作。

    对输入输出的区分是站在程序的角度进行区分。程序读取数据叫输入,程序写数据叫输出。

    java IO的API对于新人开始接触的时候,是很懵逼的,但是如果了解装饰者模式,那么就能理解io的设计(避免类爆炸)(本文我们讨论的是Java.io)。

    IO的分类

    字节流字符流
    输入流inputSream
    输出流outputSream

    输入方向:

    • 输入流:inputStream,read,fileInputStream …..
    • 输出流:outputStream,wtite,fileOutputStream …..

    读取大小:

    • 字符流:是一个字符一个字符的往外读取数据
    • 字节流:是一个字节一个字节的往外读取数据

    处理方式:

    • 节点流:节点流为可以从一个特定的数据源读写数据(有目的地)
      • 处理流:处理流式套接在已存在流之上,通过对数据的处理为程序提供更为强大的读写能力

    缓存设置大小不能设置的太大,太占内存,设置太小消耗硬盘。

    节点流

    类型字符流字节流
    File(文件)FileReader FileWriterFileInputStream FileOutputStream
    memory(内存)CharArrayReader CharArrayWriter StringReader StringWriteByteArrayInputStream ByteArrayOutStream
    pipe(管道)PipeReader PipeWriterPipedInputStream PipeOutPutSream

    处理流

    处理类型字符流字节流
    BufferingBufferReader BufferdWriterBufferedInputStream BufferedOutputSteam
    FilteringFilterReader FilterWriterFilterInputStream FilterOutputStrem
    Object Serialization序列化ObjectInputStream ObjectOutputStream
    Data 转换流DataInputStream DataOutputStream
    ….

    转换流:用于字节数据到字符数据之间的转换。

    例子

    节点流读取写入文件

    package xuelongjiang.baseGrama.iolearn;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    /**
     * 文件读取写入 节点流
     * @Author xuelongjiang
     */
    public class readWriteFileNodeStream  {
    
        public static void main(String[] args) throws  Exception {
            //节点流处理
            FileInputStream in  = new FileInputStream("/Users/xuelongjiang/Documents/test.rtf");
            FileOutputStream out = new FileOutputStream("/Users/xuelongjiang/Documents/test1.rtf");
            byte [] buffer = new byte[1024];
            int len ;
            while ((in.read(buffer)) != -1){
                out.write(buffer);
            }
            in.close();
            out.close();
        }
    }

    处理流读取写入文件(使用缓冲流)

    package xuelongjiang.baseGrama.iolearn;
    
    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    /**
     * 文件读取处理流
     * @Author xuelongjiang
     */
    public class readWrteFileDealStream {
    
        public static void main(String[] args) throws  Exception {
            //加入处理流处理
            FileInputStream in=new FileInputStream("/Users/xuelongjiang/Documents/test.rtf");
            FileOutputStream outputStream=new FileOutputStream("/Users/xuelongjiang/Documents/test2.rtf");
            BufferedInputStream buff=new BufferedInputStream(in);
    
            byte [] arry=new  byte[100] ;
            int  i;
            while((i=buff.read(arry))!=-1){
                outputStream.write(arry);
            }
    
            outputStream.close();
            buff.close();
            in.close();
    
        }
    
    }
    

    输入输出都是用缓冲流

    package xuelongjiang.baseGrama.iolearn;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    
    /**
     * 缓冲流
     * @Author xuelongjiang
     */
    public class bufferStream {
    
        public static void main(String[] args) throws  Exception {
    
            //字符流
            char [] charBuffer = new char[1024];
            FileReader reader = new FileReader("/Users/xuelongjiang/Documents/test.rtf");
            FileWriter writer = new FileWriter("/Users/xuelongjiang/Documents/test4.rtf");
    
            BufferedWriter bufferedWriter = new BufferedWriter(writer);
            BufferedReader bufferedReader = new BufferedReader(reader);
    
    
            while ((bufferedReader.read(charBuffer)) != -1 ){
                bufferedWriter.write(charBuffer);
            }
    
            bufferedWriter.flush();//清空缓存区
            reader.close();
            bufferedReader.close();
            bufferedWriter.close();
            writer.close();
        }
    
    }
    
    

    字符流

    package xuelongjiang.baseGrama.iolearn;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.util.WeakHashMap;
    
    /**
     * 字符流
     * @Author xuelongjiang
     */
    public class charStreamReadWriteStream {
    
        public static void main(String[] args)  throws  Exception{
    
            //字符流
            char [] charBuffer = new char[1024];
            FileReader reader = new FileReader("/Users/xuelongjiang/Documents/test.rtf");
            FileWriter writer = new FileWriter("/Users/xuelongjiang/Documents/test2.rtf");
    
            while ((reader.read(charBuffer)) != -1 ){
               writer.write(charBuffer);
            }
            reader.close();
            writer.close();
    
    
        }
    
    }
    

    总结

    java io 流的类还是很多,每种场景都有很多类来处理,只要理解了装饰者模式,理解流相比会更好理解。

    对于输出地缓冲流,写出的数据,会先写入到内存中,再使用flush方法将内存中的数据刷到硬盘。所以,在使用字符缓冲流的时候,一定要先flush,然后再close,避免数据丢失。

    read 方法是一个native方法,由于c语言操作硬件的性能更好,所以read方法被定义成native,可以使用其他更高效的(此场景下的高效)语言来处理。

    io有很多应用场景,就像上面说的,数据传输都是需要流来支持。

    展开全文
  • int read(byte[] b, int off, int len)//(返回值为-1时则表明已读完数据) void write(byte[] b/char[] buff, int off, int len);
  • JavaIO流

    万次阅读 2015-11-09 17:50:48
    IO流 文件--基本概念 文件是数据源(保存数据的地方)的一种,比如大word文档、jpg文件、MP4文件...都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保存视频、声音...等   文件流--基本...

    IO

    文件--基本概念

    文件是数据源(保存数据的地方)的一种,比如大word文档、jpg文件、MP4文件...都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保存视频、声音...等

     

    文件流--基本概念

    文件在程序中是以流的形式来操作的。


    流:数据在数据源(文件)和程序(内存)之间经历的路径

    输入流:数据从数据源(文件)到程序(内存)的路径

    输出流:数据从程序(内存)到数据源(文件)的路径


    如何判断是输入流、输出流?

    以内存为参照,如果数据流向内存流动,则是输入流;反之,则是输出流。


    文件流--分类



    java流分为两种流

    1、字节流:可以用于读写二进制文件及任何类型文件

    2、字符流:可以用于读写文本文件,不能操作二进制文件


    实例1.File类的使用

    /**
     * File类的基本用法
     */
    package com.io;
    
    import java.io.*;
    
    public class IO1 {
    	public static void main(String[] args) {
    		//创建一个文件对象
    		File f1 = new File("C:\\in.txt");
    		
    		//得到文件路径
    		System.out.println("文件路径:" + f1.getAbsolutePath());
    		
    		//得到文件的大小,字节数
    		System.out.println("文件大小:" + f1.length());
    		
    		//是否可读
    		System.out.println("可读" + f1.canRead());
    		
    		//创建文件和创建文件夹
    		File f2 = new File("C:\\in2.txt");
    		//判断文件是否存在
    		if(!f2.exists()){
    			//创建一个文件
    			try {
    				f2.createNewFile();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			System.out.println("文件创建成功");
    		} else {
    			System.out.println("文件已存在,无法创建");
    		}
    		
    		File f3 = new File("C:\\file1");
    		//判断文件是否为文件夹
    		if(f3.isDirectory()){
    			System.out.println("文件夹已存在");
    		} else {
    			//创建文件夹
    			f3.mkdir();
    			System.out.println("文件夹已创建");
    		}
    		
    		//列出一个文件夹下面的所有文件
    		File f4 = new File("C:\\");
    		
    		if(f4.isDirectory()){
    			//获取文件数组
    			File[] lists = f4.listFiles();
    			for(int i = 0; i < lists.length; i++){
    				System.out.println("文件名:" + lists[i].getName());
    			}
    			
    		}
    		
    		
    	}
    
    }


    实例2.文件字节流的使用

    /**
     * FileInputStream类的使用
     */
    package com.io;
    import java.io.*;
    public class IO2 {
    
    	
    	public static void main(String[] args) {
    		//创建一个文件对象
    		File f = new File("C:\\in.txt");
    		FileInputStream fis = null;
    		//File无读写能力,所以需要使用InputStream进行读入
    		try {
    			fis = new FileInputStream(f);
    			
    			//定义一个字节数组,相当于缓存
    			byte[] bytes = new byte[1024];
    			//得到实际读取到的字节数
    			int n = 0;
    			//循环读取
    			while((n = fis.read(bytes)) != -1){
    				//把字节转换成String
    				String s = new String(bytes, 0, n);
    				System.out.println(s);
    			}
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			//关闭文件流--必须放这里
    			try {
    				fis.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    }


    /**
     * FileOutputStream类的使用
     */
    package com.io;
    import java.io.*;
    public class IO3 {
    	public static void main(String[] args) {
    		//创建文件对象
    		File f = new File("C:\\out2.txt");
    		
    		//字节输出流
    		FileOutputStream fos = null;
    		
    		try {
    			fos = new FileOutputStream(f);
    			String s = "hello,world\r\n";
    			String s2 = "hello,java\r\n";
    			//定义字节数组
    			//byte[] bytes = new byte[1024];
    			
    			fos.write(s.getBytes());
    			fos.write(s2.getBytes());
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				fos.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    }

    /**
     * 图片拷贝
     */
    package com.io;
    import java.io.*;
    public class IO4 {
    	public static void main(String[] args) {
    		//先把图片读入到内存 -> 写入到某个文件
    		//因为是二进制文件,因此只能用字节流完成
    		
    		//输入流
    		FileInputStream fis = null;
    		//输出流
    		FileOutputStream fos = null;
    		 try {
    			fis = new FileInputStream(new File("C:\\image01.jpg"));
    			fos = new FileOutputStream(new File("C:\\image01_copy.jpg"));
    			
    			byte[] buf = new byte[1024];
    			//记录实际读取到的字节
    			int n = 0;
    			//循环读取
    			while((n = fis.read(buf)) != -1){
    				//输出到指定文件
    				fos.write(buf, 0, n);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			//关闭打开的文件流
    			try {
    				fis.close();
    				fos.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    }


    实例3.文件字节流

    /**
     * 字符流
     */
    package com.io;
    import java.io.*;
    public class IO5 {
    	public static void main(String[] args) {
    		//文件读入字符流
    		FileReader fr = null;
    		//文件写出字符流
    		FileWriter fw = null;
    		
    		try {
    			//创建文件读入字符流对象
    			fr = new FileReader(new File("C:\\test.txt"));
    			//创建文件写出字符流对象
    			fw = new FileWriter(new File("C:\\test_copy.txt"));
    			
    			//读入到内存
    			//缓存char数组
    			char[] c = new char[1024];
    			//读入实际大小
    			int n = 0;
    			while((n = fr.read(c)) != -1){
    				fw.write(c, 0, n);
    			}
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			//关闭文件流
    			try {
    				fr.close();
    				fw.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    }


    实例4.缓存字节流

    /**
     * 缓冲字符流
     * 
     */
    package com.io;
    import java.io.*;
    public class IO6 {
    
    	
    	public static void main(String[] args) {
    		//缓冲字符流定义
    		BufferedReader br = null;
    		BufferedWriter bw = null;
    		
    		try {
    			//创建FileReader对象
    			FileReader fr = new FileReader(new File("C:\\test.txt"));
    			//创建FileWriter对象
    			FileWriter fw = new FileWriter(new File("C:\\test_copy2.txt"));
    			
    			//创建缓冲字符流
    			br = new BufferedReader(fr);
    			bw = new BufferedWriter(fw);
    			
    			
    			//循环读文件
    			//临时字符串
    			String s = "";
    			while((s = br.readLine()) != null){
    				//输出到文件
    				bw.write(s + "\r\n");
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			
    			//关闭缓冲字符流
    			try {
    				br.close();
    				bw.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		
    		
    
    	}
    
    }


    实例5.记事本

    /**
     * 记事本(界面+功能)
     */
    package com.notepad;
    
    import java.io.*;
    import java.awt.*;
    import java.awt.event.*;
    
    import javax.swing.*;
    
    public class NotePad extends JFrame implements ActionListener{
    	//定义组件
    	//文本域
    	JTextArea jta = null;
    	//滚动条
    	JScrollPane jsp = null;
    	//菜单条
    	JMenuBar jmb =null;
    	//菜单栏目
    	JMenu jm = null;
    	//菜单项
    	JMenuItem jmi1 = null;
    	JMenuItem jmi2 = null;
    	
    	//构造方法
    	public NotePad(){
    		//创建组件
    		jta = new JTextArea();
    		jsp = new JScrollPane(jta);
    		jmb = new JMenuBar();
    		jm = new JMenu("文件(F)");
    		jmi1 = new JMenuItem("打开(O)");
    		jmi2 = new JMenuItem("保存(S)");
    		
    		//设置助记符
    		jm.setMnemonic('F');
    		jmi1.setMnemonic('O');
    		jmi2.setMnemonic('S');
    		
    		//设置监听器
    		jmi1.addActionListener(this);
    		jmi2.addActionListener(this);
    		
    		//设置动作监听器反应命令
    		jmi1.setActionCommand("open");
    		jmi2.setActionCommand("save");
    		
    		//设置菜单条
    		setJMenuBar(jmb);
    		
    		//把菜单栏目放入菜单条
    		jmb.add(jm);
    		
    		//菜单项放入菜单栏
    		jm.add(jmi1);
    		jm.add(jmi2);
    		
    		
    		//加入到JFrame
    		add(jsp);
    		
    		
    		//设置窗体
    		setTitle("我的记事本");
    		setSize(400,300);
    		setLocationRelativeTo(null);
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setVisible(true);
    	}
    	
    	
    	public static void main(String[] args) {
    		NotePad np = new NotePad();
    
    	}
    
    	//动作监听器实现
    	@Override
    	public void actionPerformed(ActionEvent e) {
    		
    		if(e.getActionCommand().equals("open")){
    			//文件选择框
    			JFileChooser jfc = new JFileChooser();
    			jfc.setDialogTitle("打开文件");
    			jfc.showOpenDialog(null);
    			jfc.setVisible(true);
    			String file = jfc.getSelectedFile().getAbsolutePath();
    			//设置缓冲读入流
    			BufferedReader br = null;
    			try {
    				br = new BufferedReader(new FileReader(new File(file)));
    				//临时字符串
    				String s = "";
    				String all = "";
    				while((s = br.readLine()) != null){
    					//因为readLine方法会去掉回车换行
    					all += s + "\r\n";
    				}
    				jta.setText(all);
    			} catch (Exception e2) {
    				e2.printStackTrace();
    			} finally {
    				try {
    					br.close();
    				} catch (IOException e1) {
    					e1.printStackTrace();
    				}
    			}
    			
    		} else if(e.getActionCommand().equals("save")){
    			//文件选择框
    			JFileChooser jfc = new JFileChooser();
    			jfc.setDialogTitle("保存文件");
    			jfc.showSaveDialog(null);
    			jfc.setVisible(true);
    			
    			String file = jfc.getSelectedFile().getAbsolutePath();
    			//设置缓冲写出流
    			BufferedWriter bw = null;
    			try {
    				bw = new BufferedWriter(new FileWriter(new File(file)));
    				//临时存放JTextArea中的字符串
    				String s = jta.getText();
    				//将字符串按一行分割成字符串数组
    				String[] ss = s.split("\r\n");
    				//循环写入写出流
    				for(int i = 0; i < ss.length; i++){
    					bw.write(ss[i] + "\r\n");
    				}
    			} catch (Exception e2) {
    				e2.printStackTrace();
    			} finally {
    				try {
    					bw.close();
    				} catch (IOException e1) {
    					e1.printStackTrace();
    				}
    			}
    			
    		} else {
    			System.out.println("无效动作");
    		}
    		
    	}
    
    }


    ----------参考《韩顺平.循序渐进学.java.从入门到精通》

    ----------参考《JDK_API_1_6_zh_CN

    Java学习笔记--导航http://blog.csdn.net/q547550831/article/details/49819641


    展开全文
  • Java IO流学习总结三:缓冲流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/54292148 本文出自【赵彦军的博客】 InputStream |__FilterInputStream |__BufferedInputStream首先抛出一个...
  • Java IO流学习总结(一)—— IO流分类和常用IO流汇总 IO流的分类: - 按流向分类:输入流、输出流 - 按操作对象分类:字节流、字符流 - 按功能分类:节点流、处理流 IO流的设计模式为装饰设计模式; ...
  • javaIO流思维导图

    2018-07-20 16:14:17
    自己整理了一下javaIO流的相关知识点 用xmind软件做了一下
  • Java IO流学习总结(二)—— 常用IO流继承关系图

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

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

    万次阅读 多人点赞 2017-08-08 11:48:51
    java IO流面试总结
  • Java IO流学习总结七:Commons IO 2.5-FileUtils

    万次阅读 多人点赞 2017-02-10 17:40:39
    Java IO流学习总结七:Commons IO 2.5 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/54946762 本文出自【赵彦军的博客】 在上面的几篇文章中,介绍了IO的常规用法,今天介绍Commons IO框架...
  • Java IO流经典练习题

    万次阅读 多人点赞 2016-09-19 09:10:05
    本文对javaIO流的练习题做了比较详细的解答,其中有比较基础的,也有比较繁琐的,都是可以加深对javaIO流的全面的理解
  • JavaIO流概念详解

    千次阅读 多人点赞 2016-12-20 09:03:00
    JavaIO流概念详解
  • java IO流的概念理解

    万次阅读 多人点赞 2018-04-26 19:07:01
    1.Java Io流的概念,分类,类图。 1.1 Java Io流的概念     java的io是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源(键盘,文件,网络连接等)抽象表述为“流”...
  • import java.io.File; import java.io.IOException; import java.util.Arrays; /*本类用于测试文件类File*/ public class TestFile { public static void main(String[] args) throws IOException { //1.创建File...
  • Java IO流划分

    千次阅读 2020-06-04 15:42:04
    1、Java IO 按操作方式分类结构图: 2、Java IO 按操作对象分类结构图:
  • 摘要:Java IO 体系看起来类很多,感觉很复杂,但其实是 IO 涉及的因素太多了。在设计 IO 相关的类时,编写者也不是从同一个方面考虑的,所以会给人一种很乱的感觉,并且还有设计模式的使用,更加难以使用这些 IO 类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 443,633
精华内容 177,453
关键字:

Javaio流