精华内容
下载资源
问答
  • Java IO流

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

    IO中有很多中有很多种流,其实实现起来都差不多,只需要掌握其中的重点流以及会使用流即可。

    • 使用输入机制,允许程序读取外部数据(包括来自磁盘、光盘等存储设备的数据)、用户输入数据
    • 使用输出机制,允许程序记录运行状态,将程序数据输出到磁盘。光盘等存储设备中

    一、File类

    File类的API

    • String getName():获取文件名
    • String getPath():获取绝对路径/相对路径(类型为String)
    • File getAbsoluteFile:获取绝对路径(类型为File)
    • String getAbsolutePath:获取绝对路径(类型为String)
    • Strin getParent():获取父级路径
    • Path toPath:获取绝对路径/相对路径(类型为Path)
    • boolean mkdir():创建一个File对象所对应的目录

    二 、IO流

    JavaIO流是实现输出/输出的基础,它可以方便地实行数据的输入/输出操作,在Java中把不同的输入/输出源(键盘、文件、网络连接等)抽象表述为流(stream),通过流的方式允许Java程序使用相同的方式来访问不同的输入/输出源。stream是从源(source)到接收(sink)的有序数据。

    2.1 流的分类

    ① 输入流和输出流

    • 输入流:只能从中读取数据,而不能向其写入数据
    • 输出流:只能向其写入数据,而不能从中读取数据

    Java的输入流主要由InputStreamReader作为基类,而输出流则主要由OutputStreamWriter作为基类。它们都是抽象基类,无法直接创建实例。

    ② 字节流和字符流

    字节流操作的数据单元是8位的字节,而字符流操作的数据单元是16位字符。

    字节流主要由InputStreamOutputStream作为基类,而字符流则主要由ReaderWriter作为基类。

    API:

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

    ③ 节点流和处理流

    Java使用处理流来包装节点流是一种典型的装饰器设计模式,通过使用处理流来包装不同的节点流,既可以消除不同节点流的实际差异,也可以提供更方便的方法来完成输入/输出功能。

    处理流的功能主要体现在下面两个方面:

    1. 性能的提高:主要以增加缓冲的方法来提高输入/输出的效率
    2. 操作的便捷:处理流可能提供了一系列便捷的方法来一次输入/输出大批量的内容,而不是输入、输出一个或多个节点流

    ④ 字符流 Reader 和 Writer

    int read(char [] c, int off, int len);
    void write(String str, int off, int len);
    

    ⑤ 处理流

    使用处理流的典型思路是,使用处理流来包装节点流,程序通过处理流来执行输入/输出功能,让节点流与底层的I/O设备、文件交互。

    实际识别处理非常简单,只要流的构造器的参数不是一个物理节点,而是已经存在的流,那么这种流一定是处理流;而所有节点流都是直接以物理IO节点作为构造器参数的。

    通常有一个规则:如果进行输入/输出的内容是文本内容,则应该考虑使用字符流;如果进行输/输出的内容是二进制内容,则应该考虑使用字节流。(能用记事本打开的都是文本文件,WIndows下简体中文默认使用GBK字符集,而Linux下简体中文默认使用UTF-8字符集)

    重要的几个处理流:

    1) 缓冲流

    根据数据操作单位可以把缓冲流分为:

    • BufferedInputStreamBufferedOutputStream
    • BufferedReaderBufferedWriter

    对于输出的缓冲流,写出的数据会先在内存中缓存,使用flush()将会使内存中的数据立刻写出

    2) 对象流

    ObjectInputStreamObjectOutputStream

    readObject()writeObject()方法。

    	@Test
    	public void test() throws IOException{
    		FileOutputStream fos= new FileOutputStream("111.txt");
    		ObjectOutputStream oos = new ObjectOutputStream(fos);
    		//写数据
    		Person person = new Person("豪哥", 38,new Address("中国", "宝安大道", "319"));
    		oos.writeObject(person);
    		oos.close();
    		fos.close();
    	}
    	
    	@Test
    	public void test2() throws Exception{
    		FileInputStream fis = new FileInputStream("111.txt");
    		ObjectInputStream ois = new ObjectInputStream(fis);
    		//读数据
    		Person person = (Person)ois.readObject();
    		System.out.println(person.toString());
    		System.out.println(person.address.toString());
    		//关流
    		ois.close();
    		fis.close();
    	}
    

    3) 随机存取文件流

    public RandomAccessFile(File file, String mode) 
    public RandomAccessFile(String name, String mode)
    

    创建 RandomAccessFile 类实例需要指定一个 mode 参数,该参数指定RandomAccessFile的访问模式:

    • r: 以只读方式打开
    • rw:打开以便读取和写入
    • rwd:打开以便读取和写入;同步文件内容的更新
    • rws:打开以便读取和写入;同步文件内容和元数据的更新
    1. RandomAccessFile即可以读也可以写
    2. 可以在文件的任意位置进行读取和写入内容
    public class RandomAccessFileTest {
    	/* 写 */
    	@Test
    	public void test() throws Exception{
    		RandomAccessFile ra = new RandomAccessFile("222.txt", "rw");
    		//写数据
    		ra.write("abcdefg".getBytes());
    		//关流
    		ra.close();
    	}
    	/*
    	 * 读
    	 */
    	@Test
    	public void test2() throws Exception{
    		RandomAccessFile ra = new RandomAccessFile("222.txt", "rw");
    		//读
    		byte[] b = new byte[1024];
    		int len = 0;
    		while((len = ra.read(b)) != -1){
    			System.out.println(new String(b,0,len));
    		}
    		//关流
    		ra.close();
    	}
    		/*
    	 * 指针移动
    	 */
    	@Test
    	public void test3() throws Exception{
    		RandomAccessFile ra = new RandomAccessFile("222.txt", "rw");
    		/*
    		//获取指针的位置
    		long filePointer = ra.getFilePointer();
    		System.out.println(filePointer);
    		String readLine = ra.readLine();
    		System.out.println(readLine);
    		//获取指针的位置
    		System.out.println(ra.getFilePointer());
    		*/
    
    		/*
    		 * 读取从c向后的整行数据
    		 * 思路:
    		 * 1.将指针移动到c的位置
    		 * 2.读取整行内容
    		 */
    //		ra.seek(2);
    //		System.out.println(ra.readLine());
    		/*
    		 * 在c的后面写入dddd
    		 * 1.先将指针移到c的位置
    		 * 2.写入内容
    		 */
    		ra.seek(3);
    		ra.write("dddd".getBytes());
    		//关流
    		ra.close();
    	}
    	
    	/*
    	 * 在abcdefg中c的后面插入"AAAA"变成  abcAAAAdefg
    	 * 思路:
    	 * 1.先将指针移动到c的后面
    	 * 2.读取指针后面的所有数据,并保存到一个临时变量中。
    	 * 3.指针回移
    	 * 4.写入要插入的数据
    	 * 
    	 */
    	@Test
    	public void test4() throws Exception{
    		RandomAccessFile ra = new RandomAccessFile("222.txt", "rw");
    		//1.先将指针移动到c的后面
    		ra.seek(3);
    		//2.读取指针后面的所有数据,并保存到一个临时变量中。
    //		String string = ra.readLine();
    		String string = "";
    		byte[] b = new byte[1024];
    		int len = 0;
    		while((len = ra.read(b)) != -1){
    			string += new String(b,0,len);
    		}
    		//3.指针回移
    		ra.seek(3);
    		//4.写入要插入的数据
    		ra.write("AAAA".getBytes());
    //		5.继续写入临时变量中的数据
    		ra.write(string.getBytes());
    		//关流
    		ra.close();
    		
    	}
    	
    }
    

    4) 转换流(了解)
    InputStreamReaderOutputStreamWriter

    [实现过程]

    public void testMyInput() throws Exception{
        FileInputStream fis = new FileInputStream("dbcp.txt");
        FileOutputStream fos = new FileOutputStream("dbcp5.txt");
    
        InputStreamReader isr = new InputStreamReader(fis,"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
    
        BufferedReader br = new BufferedReader(isr);
        BufferedWriter bw = new BufferedWriter(osw);
        
        String str = null;
        while((str = br.readLine()) != null){
            bw.write(str);
            bw.newLine();
            bw.flush();
    	}    
    	bw.close(); 
    	br.close();}
    

    5) 打印流(了解)
    PrintStreamPrintWriter实现将基本数据类型的数据格式转化为字符串输出,提供了一系列重载的printprintln方法,用于多种数据类型的输出。

    PrintStreamPrintWriter的输出不会抛出异常,PrintStreamPrintWriter有自动flush功能。System.out返回的是PrintStream的实例

    	@Test
    		public void test() {
    			FileOutputStream fos = null;
    			try {
    				fos = new FileOutputStream(new File("text.txt"));
    			} catch (FileNotFoundException e) {
    				e.printStackTrace();
    			} 
    			// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
    			PrintStream ps = new PrintStream(fos, true);
    			if (ps != null) {
    				 // 把标准输出流(控制台输出)改成文件
    				System.setOut(ps);
    			}
    			for (int i = 0; i <= 10; i++) { // 输出ASCII字符
    				//输出的内容输出到文件上
    				System.out.print("a");
    			}	
    			//关流
    			ps.close();
    		}
    

    5) 标准输入/输出流(了解)
    System.inSystem.out分别代表了系统标准的输入和输出设备,默认输入设备是键盘,输出设备是显示器

    System.in的类型是InputStreamSystem.out的类型是PrintStream,其是OutputStream的子类FilterOutputStream的子类。

    System.out.println():println()PrintStream下的一个方法。通过System类的setInsetOut方法对默认设备进行改变。

    • public static void setIn(InputStream in)
    • public static void setOut(PrintStream out)

    [实现过程]

    	/*
    	 * 从键盘输入字符串,要求将读取到的整行字符串转成大写输出。然后继续进行输入操作, 直至当输入“e”或者“exit”
    	 * 时,退出程序。
    	 * 
    	 * 思路 : 1.需要一行一行的读数据 。字符缓冲流
    	 *  2.System.in是一个字节流,从控制读取数据
    	 *  3.使用转换流将字节点和字符缓冲流结合到一起
    	 * 4.一行一行的读取数据并判断读入的数据是否是e/exit
    	 */
    	@Test
    	public void test() throws Exception {
    		// 创建一个转换流将字节流转换字符流
    		InputStreamReader reader = new InputStreamReader(System.in);
    		// 创建一个缓冲流用来一行一行的读取数据
    		BufferedReader br = new BufferedReader(reader);
    		while (true) {
    			String str = br.readLine();
    			// 判断
    			if ("e".equals(str) || "exit".equals(str)) {
    				// 关流
    				br.close();
    				reader.close();
    				// 结束
    				return;
    			}
    			System.out.println(str.toUpperCase());
    		}
    	}
    

    2.2 实现图片的输入和输出

    @Test
    	public void test() {
    		FileInputStream fis = null;
    		FileOutputStream fos = null;
    		BufferedInputStream bis = null;
    		BufferedOutputStream bos = null;
    		try {
    			fis = new FileInputStream("JavaEE.bmp");
    			fos = new FileOutputStream("copy.bmp");
    			bis = new BufferedInputStream(fis);
    			bos = new BufferedOutputStream(fos);
    			// 读入数据并写入
    			byte[] b = new byte[1024];
    			int len = 0;
    			while ((len = bis.read(b)) != -1) {
    				bos.write(b, 0, len);
    			}
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			// 关流
    			try {
    				if (bos != null) {
    					bos.close();
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			try {
    				if (bos != null) {
    					bis.close();
    				}
    
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			try {
    				if (bos != null) {
    					fos.close();
    				}
    
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			try {
    				if (bos != null) {
    					fis.close();
    				}
    
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    展开全文
  • 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 FileWriter FileInputStream FileOutputStream
    memory(内存) CharArrayReader CharArrayWriter StringReader StringWrite ByteArrayInputStream ByteArrayOutStream
    pipe(管道) PipeReader PipeWriter PipedInputStream PipeOutPutSream

    处理流

    处理类型 字符流 字节流
    Buffering BufferReader BufferdWriter BufferedInputStream BufferedOutputSteam
    Filtering FilterReader FilterWriter FilterInputStream 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有很多应用场景,就像上面说的,数据传输都是需要流来支持。

    展开全文
  • 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

    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();
    				}	
    			}
    		}
    	}
    }
    
    
    展开全文
  • JavaIO流

    千次阅读 2017-05-22 23:32:49
    IO流概念 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。 IO流的分类 ...

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

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

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

    读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
    处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。

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

    例题:

    package monday;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import javax.imageio.stream.FileImageInputStream;
    /**
     * IO流将一个txt文件中的内容复制到另一个文件txt文件中;
     * @author Administrator
     *
     */
    public class Task3 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
                try {
                    FileInputStream input=new FileInputStream("E:\\lenovo\\java.txt");
                    FileOutputStream output=new FileOutputStream("E:\\lenovo\\abc.txt");
                    int n=input.read();
                    while(n>-1){
                        output.write(n);
                        n=input.read();
                    }
    
                    output.close();
                    input.close();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
    
        }
    
    }
    
    展开全文
  • Java IO流学习总结(一)—— IO流分类和常用IO流汇总 IO流的分类: - 按流向分类:输入流、输出流 - 按操作对象分类:字节流、字符流 - 按功能分类:节点流、处理流 IO流的设计模式为装饰设计模式; ...
  • Java IO流学习总结(二)—— 常用IO流继承关系图

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

    2013-07-05 19:10:25
    ******************************************IO流介绍***************************************************** 1.IO流是干什么的?  IO流指 的是输入输出流,用来处理设备上的数据。这里的设备指硬盘,内存,键盘...
  • java IO流学习总结

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,356
精华内容 23,742
关键字:

javaio流

java 订阅