精华内容
下载资源
问答
  • 基本字节输入流 使用基本字节输入流读取文件 FileInputStream 字节缓冲输入流 给基本的字节输入流增加一个缓冲区(数组),提高基本的字节输入流的读取效率

    基本字节输入流

    使用基本字节输入流读取文件 FileInputStream

     

     

    字节缓冲输入流

    给基本的字节输入流增加一个缓冲区(数组),提高基本的字节输入流的读取效率

     

    展开全文
  • IO流的基本认识IO:在设备和设备之间的一种数据传输!IO流的分类: 按流的方向分: 输入流: 读取...写到f盘下 按数据的类型划分: 字节流 字节输入流:InputStream :读取字节 字节输出流:OutputStream :写...

    IO流的基本认识

    IO:在设备和设备之间的一种数据传输!

    IO流的分类:

    按流的方向分:

    输入流: 读取文件   (e:\\a.txt):从硬盘上文件读取出来后输出这个文件的内容
    输出流: 写文件:将e:\\a.txt 内容读出来--->写到f盘下

    按数据的类型划分:

    字节流
    字节输入流:InputStream :读取字节
    字节输出流:OutputStream :写字节
    字符流
    字符输入流:Reader :读字符

    字符输出流:Writer :写字符

    public class FileOutputStreamDemo {
    
    	public static void main(String[] args) throws IOException {
    		
    		//创建字节输出流对象
    		//创建对象做了几件事情
    				/**
    				 * 1)构造了输出流对象 (系统创建对象)
    				 * 2)指向了当前项目下输出fos.txt
    				 */
              FileOutputStream fos = new  FileOutputStream("fos.txt");
            //写数据
      		// 使用流对象给文件中写入数据
              //void write(byte[] b) 
             // 将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
      		fos.write("hello".getBytes());
      		byte[] bytes = new String().getBytes();
      		// byte[] getBytes(String charsetName) 
            //使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。 
      	//关闭资源
      			/**
      			 * 1)将文件和流对象不建立关系了 (fos对象不指向fos.txt)
      			 * 2)及时释放掉流对象所占用的内存空间
      			 */
      			fos.close(); 
      			/**
      			 * 如果关闭流对象了,那么就不能对流对象进行操作了
      			 */
    //  			fos.write("java".getBytes());//java.io.IOException: Stream Closed :流已经关闭了
      			
      		}
              
    		
    	}
    

     需求:在当项目下输出一个文件,fos.txt文件(文本文件)

    只要文本文件,优先采用字符流,字符流在字节流之后出现的
    使用字节流进行操作
    无法创建字节输出流对象:OutputSteam :抽象类,不能实例化
    又学习过File类,并且当前是对文件进行操作,子类:FileOutputSteam进行实例化

    File+InputStream
    File+OutputStream
    FileXXX  (FileReader)
    FileXXX  (FileWriter)

    开发步骤:

    1)创建字节输出流对象
    2)写数据

    3)关闭资源

    输出流:

                    void write(byte[] b) 
                                             将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
                    void write(byte[] b, int off, int len) 
                                              将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
                    void write(int b) 
                                               将指定字节写入此文件输出流。 
                               输入流的write方法没有返回值
                              参数是int b 一次写入自定义b个字节
                              参数是byte[] b 一次写入b.lenth个字节
                              参数是 byte[] b, int off, int len  一次写入b.lenth个字节  从off到len

     需求:输出文本文件,给文本文件中添加一些数据 
     问题:
    写一些数据,这些数据并没有换行,如何实现换行的效果...
    针对不同的操作系统,里面的换行符合不一样的
    windows: \r\n
    Linx:\n
    mac:\r
     一些高级记事本针对任意的换行会有换行的效果
     问题:如何末尾追加数据呢
     public FileOutputStream(File file, boolean append):指定为true,末尾追加数据

    public class FileOutputStreamDemo {
    
    	public static void main(String[] args) throws InterruptedException, IOException {
    		
    		//创建输出流对象
    		FileOutputStream  fos = new FileOutputStream ("yb.txt",true);
    		//写入
    		for(int i= 0 ; i < 10 ; i++) {
    			fos.write(("java"+i).getBytes());
    			fos.write("\r\n".getBytes());	
    		}
    		//释放资源
    		fos.close();
    		
    	}
    }
    
    


     IO流中加入异常处理(try...catch...)

    public class FileOutputStreamDemo2 {
    
    	public static void main(String[] args) {
    		
    
    		// 方式1) 分别进行异常处理
    		// 创建字节文件输出流对象
    		/*
    		 * FileOutputStream fos = null ; try { fos = new FileOutputStream("fos.txt") ; }
    		 * catch (FileNotFoundException e) { e.printStackTrace(); }
    		 * 
    		 * //写数据 try { fos.write("hello".getBytes()); } catch (IOException e) {
    		 * e.printStackTrace(); }
    		 * 
    		 * //释放资源 try { fos.close(); } catch (IOException e) { e.printStackTrace(); }
    		 */
    
    		// 方式2: 一起处理 (针对整个资源没有释放,不好)
    		// try {
    		// FileOutputStream fos = new FileOutputStream("fos2.txt") ;
    		// fos.write("java".getBytes());
    		// fos.close();
    		// } catch (IOException e) {
    		// e.printStackTrace();
    		// }
    
    		// 方式3:经常这样使用:try...catch...finally...
    		// finally中访问这个对象,需要将对象放到try语句外面
    		FileOutputStream fos = null;
    		//写数据
    		try {
    			fos= new FileOutputStream("yb1.txt");
    			fos.write("javase".getBytes());
    		}catch(IOException e){
    			e.printStackTrace();
    		}
    		//释放资源
    		finally {
    			if(fos!=null)
    		try {
    			fos.close();
    		}catch(IOException e2){
    			e2.printStackTrace();
    		}
    	}
    }
    }

    输入流:

    读数据,一个一个读,自己理解by是已经读取的字节数
    输入流的read(),返回值是一个int类型
    无参类型代表读取一个字节的数据
    read(byte[]b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
    read(byte[] b, int off, int len) 
                    从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    输出语句的new String(bys,0,lenth)是因为bys对象没有重写tostring(),不能直接输出,
    创建一个String对象就可以在控制面板上看到

    需求:去读取当前项目下的fis.txt这个文件内容,将文件的内容输出在控制台上
    InputStream抽象类:字节输入流
    FileInputStream
    构造方法:
    public FileInputStream(String name)
     开发步骤:
    1)创建字节文件输入流对象
    2)读数据
    3)释放资源 
     读数据方式:
    public abstract int read():一次读取一个字节
    public int read(byte[] b):一次读取一个字节数组 (读取实际的字节数)

    public class FileInputStreamDemo {
    
    	public static void main(String[] args) throws IOException {
    		
    		//创建输入流对象
    		FileInputStream fis = new FileInputStream("yb.txt");
    		//	
    		//创建一个字节文件输入流对象
    		//方式1:一次读取一个字节
    		//FileInputStream fis  = new FileInputStream("fis.txt") ;
    //		FileInputStream fis  = new FileInputStream("FileOutputStreamDemo.java") ;
    		//开始读取:第一次读取
    	/*	int by = fis.read() ;
    		System.out.println(by);
    		System.out.println((char)by);
    		
    		//第二次读取
    		by = fis.read() ;
    		System.out.println(by);
    		System.out.println((char)by);
    		
    		//第三次读取
    		by = fis.read() ;
    		System.out.println(by);
    		System.out.println((char)by);
    		
    		//第四次读取
    		by = fis.read() ;
    		System.out.println(by);
    		System.out.println((char)by);
    		
    		//第五次读取
    		by = fis.read() ;
    		System.out.println(by);
    		System.out.println((char)by);
    		
    		
    		//上述代码重读高,使用循环改进,循环的结束条件是什么呀?
    		//第六次读取
    		by = fis.read() ;
    		System.out.println(by);*/
    		//结束条件就是:如果文件读到末尾了,没有字节数了,所以是一个-1
    		/*int by = fis.read() ;
    		while(by!=-1) {
    			System.out.print((char)by);
    			//继续获取字节
    			by = fis.read() ;
    		}*/
    		
    		//最终版代码:可不可以将 赋值,判断写在一块呢?
    		int by = 0 ;
    		while((by=fis.read())!=-1) {
    			System.out.print((char)by);
    		}
    		
    		//释放资源
    		fis.close();
    	}
    }

    输入流和输出流结合运用:

    这个案例是一个字节一个字节的读写

     复制文本文件。
    将当前项目下的a.txt文件的内容读取出来,复制到b.txt文件中
     源文件: a.txt --->  读取文件的内容---->FileInputStream
     目的地文件: b.txt----> 输出文件 --->FileOutputStream

    public class CopyFileDemo {
    
    	public static void main(String[] args) throws IOException {
    		
    		//创建输出流对象
    		FileOutputStream fos = new FileOutputStream("yb2.txt");
    		//创建输入流对象
    		FileInputStream fis = new FileInputStream("yb.txt");
    		//读数据,一个一个读,自己理解by是已经读取的字节数
    		//输入流的read(),返回值是一个int类型
    		//无参类型代表读取一个字节的数据
    		//read(byte[]b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
    		//read(byte[] b, int off, int len) 
            //从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    		//输出语句的new String(bys,0,lenth)是因为bys对象没有重写tostring(),不能直接输出,
    		//创建一个String对象就可以在控制面板上看到
    		int by = 0 ;
    		while ((by = fis.read())!=-1) {
    			//写数据,一个一个写
    			/*
    			 *  void write(byte[] b) 
                                             将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
                    void write(byte[] b, int off, int len) 
                                              将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
                    void write(int b) 
                                               将指定字节写入此文件输出流。 
                               输入流的write方法没有返回值
                              参数是int b 一次写入自定义b个字节
                              参数是byte[] b 一次写入b.lenth个字节
                              参数是 byte[] b, int off, int len  一次写入b.lenth个字节  从off到len
    			 */
    			fos.write(by);
    			
    		}
    		//释放资源
    		fis.close();
    		fos.close();
    	}
    }
    

    这个案例读写都是以byte [] bys数组形式
     源文件: yb.txt
      目的地文件: fos.txt
     源文件: FileInputStream --->读取
    public class CopyFileDemo1 {
    
    	public static void main(String[] args) throws IOException {
    		
    		//创建输入流对象
    		FileInputStream fis = new FileInputStream("yb.txt");
    		//创建输出流对象
    		FileOutputStream fos = new FileOutputStream ("fos.txt");
    		//读数据
    		int len = 0 ;
    		byte [] bys = new byte [1024];
    		while((len = fis.read(bys))!=-1) {
    			//写数据
    			fos.write(bys, 0, len);
    		}
    		//释放资源
    		fis.close();
    		fos.close();
    	}
    }
    

      目的地文件: FileOutputStream--->写入

    展开全文
  • 字节输入流:io包中的InputStream为所有字节输入流的父类。 Int read();读入一个字节(每次一个); 可先使用new byte[]=数组,调用read(byte[] b) read (byte[])返回值可以表示有效数;read (byte[])返回值为-1...

    字节输入流:io包中的InputStream为所有字节输入流的父类。

    Int read();读入一个字节(每次一个);

    可先使用new  byte[]=数组,调用read(byte[] b)

    read (byte[])返回值可以表示有效数;read (byte[])返回值为-1表示结束。

     

    字节输出流:io包中的OutputStream位所有字节输入流的父类。

    Write和输入流中的read相对应。

     

    在流中close()方法由程序员控制。因为输入输出流已经超越了VM的边界,所以有时可能无法回收资源。

    原则:凡是跨出虚拟机边界的资源都要求程序员自己关闭,不要指望垃圾回收。

    以Stream结尾的类都是字节流。

    如果构造FileOutputStream的同时磁盘会建立一个文件。如果创建的文件与磁盘上已有的文件名重名,就会发生覆盖。

    用FileOutputStream中的boolean,则视,添加情况,将数据覆盖重名文件还是将输入内容放在文件的后面。(编写程序验证)

     

    DataOutputStream:输入数据的类型。

    因为每中数据类型的不同,所以可能会输出错误。

    所有对于:DataOutputStream

              DataInputStream

              两者的输入顺序必须一致。

    过滤流:

     bufferedOutputStream

     bufferedInputStream

    用于给节点流增加一个缓冲的功能。
    在VM的内部建立一个缓冲区,数据先写入缓冲区,等到缓冲区的数据满了之后再一次性写出,效率很高。

    使用带缓冲区的输入输出流的速度会大幅提高,缓冲区越大,效率越高。(这是典型的牺牲空间换时间)

    切记:使用带缓冲区的流,如果数据数据输入完毕,使用flush方法将缓冲区中的内容一次性写入到外部数据源。用close()也可以达到相同的效果,因为每次close都会使用flush。一定要注意关闭外部的过滤流。

     

    (非重点)管道流:也是一种节点流,用于给两个线程交换数据。

    PipedOutputStream

    PipedInputStream

    输出流:connect(输入流)

     

    RondomAccessFile类允许随机访问文件

    GetFilepoint()可以知道文件中的指针位置,使用seek()定位。

    Mode(“r”:随机读;”w”:随机写;”rw”:随机读写)

    练习:写一个类AJAVA A file1 file2

    file1要求是系统中已经存在的文件。File2是还没有存在的文件。

    执行完这个命令,那么file2就是file1中的内容。

     

    字符流:reader\write只能输纯文本文件。

    FileReader类:字符文件的输出

     

    字节流与字符流的区别:

    字节流的字符编码:

    字符编码把字符转换成数字存储到计算机中,按ASCii将字母映射为整数。

    把数字从计算机转换成相应的字符的过程称为解码。

    编码方式的分类:

    ASCII(数字、英文):1个字符占一个字节(所有的编码集都兼容ASCII

    ISO8859-1(欧洲):1个字符占一个字节

    GB-2312/GBK1个字符占两个字节

    Unicode: 1个字符占两个字节(网络传输速度慢)

    UTF-8:变长字节,对于英文一个字节,对于汉字两个或三个字节。

     

    原则:保证编解码方式的统一,才能不至于出现错误。

    Io包的InputStreamread称为从字节流到字符流的桥转换类。这个类可以设定字符转换方式。

    OutputStreamred:字符到字节

    Bufferreadreadline()使得字符输入更加方便。

    I/O流中,所有输入方法都是阻塞方法。

    Bufferwrite给输出字符加缓冲,因为它的方法很少,所以使用父类printwrite,它可以使用字节流对象,而且方法很多。

     

    练习:做一个记事本

    swing/JfileChoose: getSelect file()

    InputStreeamReader:把字节变为字符

    JAVA中对字符串长无限制  bufferedReaderir

    转载于:https://www.cnblogs.com/borter/p/10744124.html

    展开全文
  • 1. 字节输入流: 1.1 InputStream类的常用方法 1. available() 方法,获取与之关联的文件剩余可读的字节数。 2. int read() 方法,读取输入流。读取输入流的下一个字节,返回一个0-255之间的int类型整数。如果到达流...

    1. 字节输入流:

    1.1 InputStream类的常用方法

    1. available() 方法,获取与之关联的文件剩余可读的字节数。
    2. int read() 方法,读取输入流。读取输入流的下一个字节,返回一个0-255之间的int类型整数。如果到达流的末端,返回-1。
    3. int read(byte[] b) 方法,读取输入流。读取多个字节,存入字节数组b,返回实际读入的字节数。如果到达流的末端,返回-1。
    4. int read (byte[] b, int off, int len); 方法,读取输入流。每次读取len个字节,存入字节数组b,从off下标开始存储。如果到达流的末端,返回-1。
    5. close() 方法,关闭当前流,释放与该流相关的资源,防止资源泄露。在带资源的try语句中将被自动调用。关闭流之后还试图读取字节,会出现IOException异常。
    1.2 InputStream类的子类:文件输入流FileInputStream
    FileInputStream 用于读取本地文件中的字节数据,继承自InputStream类

    1.2.1 FileInputStream构造方法和常用方法

    1.2.1.1构造方法

    1. FileInputStream(File file); 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的 File 对象 file 指定。
    2. FileInputStream(String name); 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的路径名 name 指定。

    1.2.1.2 常用方法

    1. read() 方法,读取输入流。读取输入流的下一个字节,返回一个0-255之间的int类型整数。如果到达流的末端,返回-1。  
        is = new FileInputStream("test.txt");  
           int i; 
           while ((i = is.read()) != -1) {
               System.out.println("out: " + (char)i);  
           } 

    2. read(byte[] b) 方法,读取输入流。读取多个字节,存入字节数组b,返回实际读入的字节数。    
       InputStream is = null;  
           byte[] buffer = new byte[4];//每次读取4个字节
           try {
               is = new FileInputStream("test.txt");  
               is.read(buffer);  
               System.out.println("available: " + is.available());//观察在读取的过程中,available 值。
               for (byte b : buffer) {  
                   System.out.println((char)b);  
               }
           }...

    3. read (byte[] b, int off, int len); 方法,读取输入流。每次读取len个字节,存入字节数组b,从off下标开始存储。
    4. close() 方法,关闭当前流,释放与该流相关的资源,防止资源泄露。在带资源的try语句中将被自动调用。关闭流之后还试图读取字节,会出现IOException异常。

    5. skip(long n) 方法,跳过(放弃)当前流的n个字节,返回实际跳过的字节数。

    示例代码:

    	File file = new File("a.txt");
    		if (file.exists()) {
    
    			try (FileInputStream is = new FileInputStream(file)) {
    				// 第一种方法
    				byte[] b = new byte[10];
    				while (true) {
    					int read2 = is.read(b, 0, 10);// 等价于 is.read(b);
    					if(read2==-1){
    						break;
    					}
    					String string = new String(b, 0, read2); 
    					System.out.print(string);
    				}
    
    				// 第二种方法
    //				byte[] b = new byte[10];
    //				int read = -1;
    //				while ((read = is.read(b, 0, 10)) != -1) {
    //					String string = new String(b, 0, read); // is.read(b);
    //					System.out.print(string);
    //				}
    
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}


    2 字节输出流:

    2.1 OutputStream类的常用方法

    1. write (int b); 将指定的字节写入此输出流。
    2. write(byte[] byte); 将 b.length 个字节从指定的 byte 数组写入此输出流。
    3. write(byte[] byte, int off, int len); 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
    4. flush();  用于清空缓存里的数据,并通知底层去进行实际的写操作。(强制把缓存区里面的数据写入到文件)
    5. close();关闭当前流,释放与该流相关的资源。

    2.2 OuputStream类的子类:文件输出类FileOutputStream

    提供了文件的基本写入能力,继承自 OuputStream类

    注意:

    1. 如果进行写操作的文件不存在,则自动创建该文件。
    2. 如果文件所在的路径也不存在则报错。

    2.2.1 FileOutputStream构造方法和常用方法

    2.2.1.1 构造方法


    1. public FileOutputStream(String name); 通过打开一个到实际文件的连接来创建一个FileOutputStream,该文件通过文件系统中的路径名 name 指定。
    2. public FileOutputStream(String name,boolean append);通过打开一个到实际文件的连接来创建一个FileOutputStream,该文件通过文件系统中的路径名 name 指定。如果第二个参数为true,则将字节写入文件末尾处,而不是写入文件开始处。
    3. public FileOutputStream(File file):通过打开一个到实际文件的连接来创建一个FileOutputStream,该文件通过文件系统中的 File 对象 file 指定。 
    4. public FileOutputStream(File file,boolean append);通过打开一个到实际文件的连接来创建一个FileOutputStream,该文件通过文件系统中的 File 对象 file 指定。如果第二个参数为true,则将字节写入文件末尾处,而不是写入文件开始处。

    2.2.1.2 常用方法

    1. write (int b); 将指定的字节写入此输出流。
        
       try {
           	File file = new File("test.txt");
           	OutputStream fos = new FileOutputStream(file);
           	byte b = 'a';
           	fos.write(b);
           	fos.flush();
           	fos.close();
           }...

    2. write(byte[] byte); 将 b.length 个字节从指定的 byte 数组写入此输出流。
       
       try {
           	File file = new File("test.txt");
           	OutputStream fos = new FileOutputStream(file);
           	byte b[]= "abcdefg".getBytes();
           	fos.write(b);
           	fos.flush();
           	fos.close();
           }...
      
    3. write(byte[] byte, int off, int len); 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
        
       try {
           	File file = new File("test.txt");
           	OutputStream fos = new FileOutputStream(file);
           	byte b[]= "abcdefg".getBytes();
           	fos.write(b,1,3);
           	fos.flush();
           	fos.close();
           }...
       
    4. flush();  用于清空缓存里的数据,并通知底层去进行实际的写操作。(强制把缓存区里面的数据写入到文件)
    5. close();关闭当前流,释放与该流相关的资源。
    示例代码:
    File file = new File("Test.txt");
    		try {
    			// 如果该file不存在,在 输出流会自动创建该(空)文件
    //			OutputStream os = new FileOutputStream(file);//覆盖源文件内容,写入
    			OutputStream os = new FileOutputStream(file, true);//在源文件的末尾追加写入
    			os.write(66);// 写一个字节
    			os.close();
    			System.out.println("写入完毕...");
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}

    3 字节缓冲流

    BufferedInputStream与BufferedOutputStream分别是FilterInputStream类和FilterOutputStream类的子类,实现了装饰设计模式。提高了读写性能。

    3.1字节输入缓冲流 BufferedInputStream

    BufferedInputStream是带缓冲区的输入流,默认缓冲区大小是8Kb,能够减少访问磁盘的次数,提高文件读取性能;

    使用方式:

      try {
        	File file = new File("test.txt");
        	InputStream fos = new FileInputStream(file);
        	BufferedInputStream bis = new BufferedInputStream(fos,2*1024);//2*1024设置需要的缓冲区大小
        	byte b[] =new byte[1024];
        	while (bis.read(b)!=-1) {
        		for (byte c : b) {
        			System.out.println((char)c);
        		}
        	}
        	bis.close();
        }

    3.2 字节输出缓冲流 BufferedOutputStream

    BufferedOutputStream是带缓冲区的输出流,能够提高文件的写入效率。

    使用方式:
     
       try {
        	File file = new File("test.txt");
        	OutputStream fos = new FileOutputStream(file);
        	BufferedOutputStream bos =new BufferedOutputStream(fos,2*1024);//2*1024设置需要的缓冲区大小
        	byte b = "a";
        	bos.write(b);
        	bos.flush();//带有缓冲区,所以必须刷新。
        	bos.close();
        }...

    3.3 字节缓冲输入流特有的方法

    1. mark(int readlimit) 方法(只有BufferedInputStream才支持),在流的当前位置做个标记,参数readLimit指定这个标记的“有效期”,如果从标记处开始往后,已经获取或者跳过了readLimit个字节,那么这个标记失效,不允许再重新回到这个位置(通过reset方法)。也就是你想回头不能走得太远呀,浪子回头不一定是岸了,跳过(获取)了太多字节,标记就不再等你啦。多次调用这个方法,前面的标记会被覆盖。


       
       如果我们在 M 处做标记,readLimit为绿色部分,当流的指针在 A 处的时候,这个标记依然有效,可是一旦指针跑到 B 处,标记就失效了。
    2. reset() 方法(只有BufferedInputStream才支持),用于重定位到最近的标记。如果在这之前mark方法从来没被调用,或者标记已经无效,会抛出IOException。如果没有抛出这个异常,将当前位置重新定位到最近的标记位置。
        
       InputStream is = null;  
                   try {
                       is = new BufferedInputStream(new FileInputStream("test.txt"));  
                       is.mark(4);  
                       is.skip(2);  
                       is.reset();  
                       System.out.println((char)is.read());  
                   } finally {  
                       if (is != null) {  
                           is.close();  
                       }  
                   }
           }



    展开全文
  • 字节输入流 字节输出流 字符输入流 字符输出流 InputStream OutputStream Reader Writer (抽象类) FileInputstream FileOutputStream FileReader Filewriter (实现类) 一、FileInputstream文件字节输入流的...
  • IO流字节输入输出流IO流java IO流原理流的分类InputStream 字节输入流InputStream 应用实例OutputStream 字节输出流OutputStream 应用实例 IO流 java IO流原理 1、I/O是input/Output的缩写,I/O技术是非常实用的技术...
  • 文件字节输入流

    2019-04-06 19:45:59
    2. 文件字节输入流是可以使用FileInputStream类,这个类是InputStream的子类(以字节为单位读取文件),该类的实例方法都是从InputStream继承过来的 常用的两个构造方法有: FileInputStream(String ...
  • java.io.InputStream:字节输入流 此抽象类是表示字节输入流的所有类的超类 定义了所有子类共性的方法: int read()从输入流中读取数据的下一个字节 in read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在...
  • 字节输出流和字节输入流

    千次阅读 2019-06-23 16:10:38
    字节输出流和输入流1. 字节输出流 之前介绍的File文件操作类可以关联本地文件系统,实现文件的创建,删除和查询一些文件信息。但是File类不支持对文件内容进行操作,如果要处理文件内容,必须通过流的方式。 流分为...
  • 怎么确定输入输出的方向?...字节输入流(InputStream)   InputStreams是Java标准库提供的最基本的输入流,位于java.io包里。它不是一个具体的类或者接口,而是一个抽象类。同时它是所有字节输入
  • FileInputStream(文件字节输入流) 按照字节方式读取文件 public static void main(String[] args) { //文件路径 //String s = "abc";//相对路径,相对当前而言,在当前路径下载 FileInputStream fis = null...
  • 文件字节输入流用到的包: import java.io.FileInputStream; import java.io.IOException; 1、文件字节输入流(FileInputStream)简介: 文件字节输入流:FileInputStream extends InputStream InputStream:是一个...
  • 字节输入流操作步骤

    2019-04-11 23:53:09
    * 字节输入流操作步骤: * A:创建字节输入流对象 * B:调用read()方法读取数据,并把数据显示在控制台 * C:释放资源 * * 读取数据的方式: * A:int read():一次读取一个字节 * B:int read(byte[] b):一...
  • InputStream 字节输入流基类 操作步骤: 步骤1:打开特定类型的输入流,可能会抛出FileNotFoundException FileInputStream inputStream = new FileInputStream(path); 步骤2:读取数据操作,-1表示读取结束,可能会...
  • 文件字节输入流 一.使用输入流的4个基本步骤: (1)设定输入流的源。 (2)创建指向源的输入流。 (3)让输入流读取源中的数据。 (4)关闭输入流。 二.具体实现 1~2步的实现:可以使用下列构造方法: ...
  • import java.io.FileInputStream; import java.io.IOException;... 字节输入流一次读取多个字节的方法: int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。 明确两件事情: ...
  • package ... import java.io.*; public class Example01 { public static void main(String[] args) throws Exception { //创建一个文件字节输入流 FileInputStream fis = new FileInputStream(...
  • 字节输入流 read 读取文件

    千次阅读 2017-08-21 21:37:04
    字节输入流read方法可以传入不同的参数,实现读取文件的方式就不一样,推荐使用方法二。
  • import java.io.FileInputStream;...字节输入流一次读取多个字节的方法: int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。 明确两件事情: 1.方法的参数byte[]的作用? 起到...
  • Java 字节输入流的一些方法

    千次阅读 2017-08-21 21:51:55
    字节输入流的一些方法。。。。
  • 输入流——读取数据 数据类型不同,有:字节流和字符流。 字节流的抽象基类:InputStream、OutputStream 字符流的抽象基类:Reader、Writer 字节输出流OutputStream 如,写出数据到文件,是文件字节输出流...
  • FileOutputStream,FileInputStream介绍@Test /** * 字节输入流与字节输出流 * FileOutputStream,FileInputStream介绍 * */ public void test2(){
  • 1、字节输入流操作(向文件写数据):FileInputStream a) 构造方法  FileInputStream(File file)  FileInputStream(String name) b) 字节输入流操作步骤  i. 创建字节输入流对象  ii. 调用read()方法读取数据并...
  • java字节输入流InputStream详解

    千次阅读 2018-04-12 04:42:34
    -------------------------java字节输入流InputStream详解--------------------- 因为InputStream是抽象类,我们要学习的是它的子类。 构造器 FileInputStream(File file) 通过打开一个到实际文件的连接来创建一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,708
精华内容 8,283
关键字:

字节输入流