精华内容
下载资源
问答
  • 7.1 Java语言I/O的类层次 Java输入/输出流封装在包java.io中其常用的层次结构如图7.17.2所示 除了图中给出的类外实际使用中我们还会碰到File类它用来描述某个文件的信息输入/输出类中还有几个比较重要的接口例如...
  • Java输入输出流对于任何编程语言处理数据的输入输出操作都占有极其重要的地位Java语言以流的形式进行数据的输入输出处理这一章我们将为大家详细讲述输入输出流的概念文件的概念以及字节的输入输出流和字符的输入...
  • 本文档涵盖了java中标准输入输出流,包含InputStream、OutputStream字节流还有字符流以及对文件的读写操作等
  • java输入输出流的简单入门

    万次阅读 多人点赞 2019-03-30 19:17:24
    另一方面,程序在处理数据后,可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序,这就需要使用输出流。 通俗的解释就是,以我当前程序为主,我要和其他的事物进行交流,所以我必须要搭一个通道...

          程序在运行期间可能需要从外部的存储媒介或其他程序中读取所需要的数据,这就需要使用输入流,输入流的指向称为它的源;另一方面,程序在处理数据后,可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序,这就需要使用输出流。

           通俗的解释就是,以我当前程序为主,我要和其他的事物进行交流,所以我必须要搭一个通道(这个通道就是流),让我和它可以交流,我获取该事物的数据就叫输入,我给予该事物数据就叫输出。

    那么输入输出有两种形式,一是以字节的形式输入输出;二是以字符的形式输入输出。

    java.io包提供大量的流类,所有输入流都是抽象类InputStream(字节输入流)或Reader(字符输入流)的子类,而所有输出流都是抽象类OutputStream(字节输出流)或抽象类Writer(字符输出流)的子类。

    一、File类

    构造方法:

    File(String filename);//没有路径,即在当前目录

    File(String directoryPath,String filename);

    File(File dir,String filename);

    filename是文件名,directoryPath是文件路径,dir是目录

    注:文件夹即目录也是一种文件,知识没有后缀名罢了

    常用方法:

    public boolean canRead():是否可读

    public boolean canWrite():是否可写

    public boolean exists():是否存在

    public long length():获取文件长度(单位字节)

    public boolean isFile():是否是一个文件(而不是目录)

    public boolean isDirectory():是否是目录

    public boolean isHidden():是否隐藏

    public long last Modified():获取最后修改时间(从1970年至今的毫秒数)

    public String getName():获取文件名字

    public String getAbsolutePath():获取文件绝对路径

    public String getParent():获取文件父目录

    注:当构造一个File实例时,它只是说明了它把“文件夹-文件”这个模式抽象成了一个java对象,也就是说我可以用这个对象来操作实际的文件了。但是有一点就是,它并不会检测这个java对象实际对应的文件是否真实存在,所以需要判断,如果不存在就需要创建。。。

    创建目录

    File对象调用public boolean mkdir()创建一个目录,如果创建成功,返回true,否则返回false(所以你的那个File对象的filename参数的字符串应该是没有文件后缀的,才会创建出文件夹)

    public boolean mkdirs()区别:这个如果父目录不存在,帮忙创建;上面不加s,会显示创建失败。

    列出目录中的文件

    如果File对象是一个目录,那么该对象调用下列方法可列出该目录下的文件和子目录:

    public String[] list(FilenameFiler obj):以字符串形式返回目录下指定类型所有文件

    public File[] listFiles(FilenameFiler obj):以File对象形式返回目录下指定类型所有文件

    其中,FilenameFiler是一个接口,在调用以上两个方法之前,需要实现该接口中的方法:

    public boolean accept(File dir,String name)

    形如:String filename[] = file.list(filenamefiler);即可遍历完成。通俗讲,在实现接口里制定一个筛选规则,对当前文件目录依次遍历。先把文件的信息传到accept方法中,让accept方法进行判断,如果满足条件,即返回true,即会把文件信息存到数组中,返回false则不会存到数组中,这就完成了一次筛选。list()参数其实也可以省略。这里有使用此函数打印文件目录的示例:https://blog.csdn.net/qq_36923376/article/details/89884797

    创建文件

    如果File对象所指的文件不存在,可调用public boolean createNewFile()方法创建。

    删除文件

    调用public boolean delete()可以删除当前文件

    运行可执行文件

    的 当要执行机器上可执行文件时,可使用java.lang包中的Runtime类。

    Runtime ec = Runtime.getRuntime();//创建对象

    ec.exec(String command);//即可打开本地机器上的可执行文件,command是文件的绝对路径

    二、字节输入输出流

    输入流

    输入流基本步骤:

    • 设定输入流的源
    • 创建指向源的输入流
    • 让输入流读取源中的数据
    • 关闭输入流

    构造方法

    • FileInputStream(String name);
    • FileInputStream(File file);

    创建时会抛出IO异常,比如你要读的文件实际不存在,所以需要捕获处理。

    使用输入流对象读取字节

    int read():读取单个字节,返回0-255之间一个整数,如果未读出字节就返回-1

    int read(byte b[]):从源中读取b.length个字节到b中,返回实际读取的字节数目,如果未读出字节就返回-1。

    int read(byte b[],int off,int len):从源中读取len个字节到b中,返回实际读取的字节数目,如果未读出字节就返回-1。从off位置开始存放读取的数据。

    注:FileInputStream顺序读取文件,只要不关闭流,每次调用read() 方法就顺序读取源中其余内容,直到源末尾或流被关闭。尽管程序结束时会自动关闭所有打开的流,但是当程序使用完流后,显式的关闭任何打开的流仍是一个良好的习惯。

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    
    
    
    public class Main{
    	public static void main(String args[]){
    		int n=-1;
    		byte a[] = new byte[100];
            String separator = File.separator;
    		String localdisk ="E:";
    		String filepath = localdisk+separator+"1017"+separator+"make"+separator;
    		String filename = "aaa.txt";
    		File file = new File(filepath,filename);
    
    		try {
    			FileInputStream in = new FileInputStream(file);
    			while((n=in.read(a))!=-1) {//这个地方
    				String s = new String(a,0,n);
    				System.out.println(s);
    			}
    			in.close();
    
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		
    	
    	}
    
    }
    //txt内容:你好123i45like哈哈78bananas90很高兴

    输出流

    输出流基本步骤:

    • 给出输出流的目的地
    • 创建指向目的地的输出流
    • 让输出流把数据写入到目的地
    • 关闭输出流

    构造方法

    • FileOutputStream(String name);
    • FileOutputStream(File file);

    创建时会抛出IO异常,需捕获。

    注:这里构造函数还可以有第二个参数,FileOutputStream(File file,boolean append);append如果为true,则会在目的地文件的末尾继续写入字节,如果为false或缺省,则会把目的地文件内容清空即刷新文件使得文件的长度为0,从头开始写。如果输出流指向的文件不存在,Java就会创建该文件。

     

    使用输出流对象写字节

    void write(int n):输出流调用该方法向目的地写数据

    void write(byte b[]):输出流调用该方法向目的地写入一个字节数组

    void write(byte b[],int off,int len):给定字节数组中起始于偏移量off处取len个字节写到目的地。

    注:FileOutputStream顺序地写文件,只要不关闭流,每次调用write() 方法就顺序地向目的地写入内容,直到流被关闭。需要注意的是,在操作系统把程序所写到输出流上的那些字节保存到磁盘上之前,有时被存放在内存缓冲区中,通过调用close()方法,可以保证操作系统把流缓冲区的内容写到它的目的地,即关闭输出流可以把该流所用的缓冲区的内容冲洗掉。

    public class Main{
    	public static void main(String args[]){
    		File file = new File("F:\\haha\\bbb","aaa.txt");
    		try {
    			FileOutputStream out = new FileOutputStream(file,false);
    //注意这里的第二个参数,上面有讲解
    			String a = "啥事啊";
    			byte[] b = a.getBytes();
    			System.out.println(file.getName()+":"+file.length()+"byte");
    			out.write(b);
    			System.out.println(file.getName()+":"+file.length()+"byte");
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	
    	}
    
    }

    三、字符输入输出流

    前言:文件字节输入、输出流的read和write方法使用字节数组读写数据,即以字节为单位处理数据。因此字节流不能很好地操作Unicode字符,比如,一个汉字在文件中占用2个字节,如果使用字节流,读取不当会出现“乱码”现象。

    输入流

    FileReader是Reader的间接子类,是InputStreamReader的直接子类。

    构造方法:

    • FileReader(String filename);
    • FileReader(File filename);

     

    读取方法:

    同样使用read方法,和上述一致,只不过把字节数组换成字符数组,不再赘述。

    输出流

    FileWriter是Writer的子类,是OutputStreamWriter的直接子类。

    构造方法:

    • FileWriter(String filename,boolean append);
    • FileWriter(File filename,boolean append);

    注:同样,第二个参数和上面字节流一样,可以省略。

    写入方法:

    同样使用write方法,和上述一致,只不过把字节数组换成字符数组,不再赘述。

    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class Main{
    	public static void main(String args[]){
    		File file = new File("F:\\haha\\bbb","aaa.txt");
    		try {
    			int n= -1;
    			FileReader in = new FileReader(file);
    			FileWriter out = new FileWriter(file,true);
    			char[] c = {'a','b','c','d','e','f','g'};
    			System.out.println(file.getName()+":"+file.length()+"byte");
    			out.write(c,0,c.length);
    //把c数组中的字符全部写入
    			out.flush();
    //别忘了刷新
    			System.out.println(file.getName()+":"+file.length()+"byte");
    			while((n=in.read(c))!=-1) {
    //读取文件,一次读c.length长度,一次就读完了,进入while输出,第二次检测是-1,说明读完了,不进入循环
    				System.out.println(c);
    			}
    			out.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		
    	}
    
    }

    注:对于Writer流,write方法将数据首先写入到缓冲区,每当缓冲区溢出时,缓冲区的内容被自动写入到目的地,如果关闭流,缓冲区的内容会like被写入到目的地。流调用flush()方法可以立刻冲洗当前缓冲区,即将当前缓冲区的内容写入到目的地。

    四、缓冲流

    Java提供了更高级的流:BufferedReader流和BufferedWriter流,二者的源和目的地必须是字符输入流和字符输出流。

    构造函数分别是:

    BufferedReader(Reader in);

    BufferedWriter(Writer out);

    相比将与字符输入输出流的优点:

    BufferedReader流能够读取文本行,方法是readLine(),如:String strline = inline.readLine()

    BufferedWriter流可以向文件写入一个回行符,方法是newLine();

    解释:可以把BufferedReader流和BufferedWriter流称为上层流,它们的字符流参数称为底层流,java采用缓存技术将上层流和底层流连接。

    当BufferedWriter流调用flush()刷新缓存或调用close()方法关闭时,即使缓存没有溢出,底层流也会立刻将缓存的内容写入目的地。一般先关闭上层流再关闭底层流。在编写代码时只需关闭上层流,那么上层流的底层流将自动关闭。

    五、InputStreamReader

              public class InputStreamReader extends Reader

            InputStreamReader是从字节流到字符流的桥接器:它读取字节并使用特定的编码格式转换为字符。它使用的字符集可以通过名称指定,也可以明确指定,或者可以接受平台的默认字符集。

    每次调用一个InputStreamReader的read()方法都可能导致从底层字节输入流中读取一个或多个字节。为了能够有效地将字节转换为字符,可以从基础流中提取比满足当前读取操作所需的更多字节。

    为了获得最高效率,请考虑在BufferedReader中包装InputStreamReader。例如:

     BufferedReader in
       = new BufferedReader(new InputStreamReader(InputStream in,Charset cs));

    在下面的例子中,将使用URL类爬取百度首页的源码,网页是utf-8编码,所以爬过来的数据应用utf-8解码

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.URL;
    
    
    public class Main1{
    	public static void main(String args[]){
    		try {
    			URL url = new URL("http://www.baidu.com");
    			InputStream in = url.openStream();
    			BufferedReader buff = new BufferedReader(new InputStreamReader(in,"utf-8"));
    			String n=null;
    			while((n=buff.readLine())!=null) {
    				System.out.println(n);
    			}
    		} catch (IOException e) {
    			
    			e.printStackTrace();
    		}
    	}
    
    }

     

     

     

    五、随机流

    能否建立一个流,通过这个流既能读文件也能写文件呢?即随机流诞生!

    RandomAccessFile类创建的流称作随机流,当准备对一个文件进行读写操作时,创建一个指向该文件的随机流即可。

    构造方法:

    RandomAccessFile(String name, String mode);

    RandomAccessFile(File file, String mode);

    参数mode取r(只读)或rw(可读写),决定创建流对文件的访问权利。

    注:RandomAccessFile流指向文件时,不刷新文件。

            RandomAccessFile类中有一个方法seek(long a)用来定位RandomAccessFile流的读写位置,其中参数a确定读写位置距离文件开头的字节个数。另外流还可以调用getFilePointer()方法获取流的当前读写位置。

    RandomAccessFile类有好多读写的函数,可自行查阅api

         需要注意的是,RandomAccessFile流的readLine()方法在读取含有非ASCII字符的文件时(比如汉字)会出现“乱码”现象,因此,需要把readLine()读取的字符用“iso-8859-1”编码重新编码存放到byte数组中,然后再用当前机器的默认编码将该数组转化为字符串,操作如下:

    1.读取

    String str = in.readLine();

    2.用“iso-8859-1”重新编码

    byte[] b = str,getBytes("iso-8859-1");

    3.用当前机器的默认编码将该数组转化为字符串

    String content = new String(b);

    如果机器默认编码是GB2312,等价于String content = new String(b,“GB2312”);

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Java的常用输入输出语句

    万次阅读 多人点赞 2018-04-14 19:03:38
    一、概述 输入输出可以说是计算机的基本功能。作为一种语言体系,java中主要按照(stream)的模式来实现。其中数据的流向是按照计算机的方向确定的,流入计算机的数据叫做输入(inputStream),由计算机发出的...

    一、概述

       输入输出可以说是计算机的基本功能。作为一种语言体系,java中主要按照(stream)的模式来实现。其中数据的流向是按照计算机的方向确定的,流入计算机的数据流叫做输入流(inputStream),由计算机发出的数据流叫做输出流(outputStream)

    Java语言体系中,对数据流的主要操作都封装在java.io包中,通过java.io包中的类可以实现计算机对数据的输入、输出操作。在编写输入、输出操作代码时,需要用import语句将java.io包导入到应用程序所在的类中,才可以使用java.io中的类和接口。大笑

    二、输入语句

    1.使用Scanner类:

    (1)使用java.util包。  import java.util.*;

    (2)构造Scanner类对象,它附属于标准输入流System.in。   Scanner snew Scanner(System.in);

    (3)常用的next()方法系列:       nextInt():输入整数    nextLine():输入字符串     nextDouble():输入双精度数     next():输入字符串(以空格作为分隔符)。

    1. import java.util.*;  
    2. public class DEMO_1 {  
    3.     public static void main(String[] args){  
    4.         Scanner snew Scanner(System.in);  
    5.         System.out.print("输入你的姓名:");  
    6.         String name = s.nextLine();  
    7.         System.out.print("输入你的年龄:");  
    8.         int age = s.nextInt();  
    9.         System.out.println("姓名:" + name + "  年龄:" + age );  
    10.         s.close();         //若没有关闭Scanner对象将会出现警告  
    11.     }  

    注释:代码第1行创建了一个Scanner类的对象,这个对象是用来输入的。后面的代码是从控制台的输入中取出一个值,赋值给对应的变量。

    2.使用java.io.BufferedReaderjava.io.InputStreamReader

    步骤:

    (1)使用java.io包。  import java.io.*;

    (2)构造 BufferedReader类对象,它附属于标准输入流System.in。  

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    public class Sandbox4 extends Sandbox2{
        public static void main(String[] args) {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
            String str = null;  
            while(true){
                try {  
                    str = br.readLine();  
                }catch(IOException e){
                    e.printStackTrace();
                }
                if(str.equals("END"))break;
                System.out.print(str);
            }
        }
    }


    请注意:

    (1)read方法:读取单个字符。 返回:作为一个整数(其范围从 0 到 65535 (0x00-0xffff))读入的字符,如果已到达流末尾,则返回 -1 ;

    (2)readLine方法:读取一个文本行。通过下列字符之一即可认为某行已终止:换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。 返回:包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null。

    3、使用java.io.Console

    public class Sandbox4 extends Sandbox2{
        public static void main(String[] args) {
            Console console = System.console();  
            if (console == null) {  
                throw new IllegalStateException("Console is not available!");  
            } 
            String str = null;
            while(true){
                str = console.readLine("请输入"); 
                if("END".equals(str))break;
                System.out.println(str);
            }        
        }
    }

     输入问题解惑:


    注:该问题图片来源于百度知道。

    三、输出语句

    Java中的输出语句有以下四种:

    System.out.println(1111);//换行打印
    System.out.print(1111);//不换行打印
    System.out.write(2222);//字节输出
    System.out.printf("%+8.3f\n", 3.14);//按格式输出
    1. System.out.println(); 是最常用的输出语句,它会把括号里的内容转换成字符串输出到输出窗口(控制台),并且换行,当输出的是一个基本数据类型时,会自动转换成字符串,如果输出的是一个对象,会自动调用对象的toString();方法,将返回值输出到控制台
    2. System.out.print(); 与第一个很相似,区别就是上一个输出后会换行,而这个命令输出后并不换行。
    3. System.out.printf(); 这个方法延续了C语言的输出方式,通过格式化文本和参数列表输出。





    展开全文
  • Java 输入输出流

    千次阅读 多人点赞 2021-04-15 17:02:47
    Java 输入输出流(I/O流)1 File类1.1 文件的属性1.2 目录2 文件字节输入输出流二级目录三级目录3 文件字符输入输出流二级目录三级目录4 缓冲流二级目录三级目录 概述:输入输出流提供一条通道程序,可以...


    概述:输入、输出流提供一条通道程序,可以使用这条通道读取源中的数据或把数据传送到目的地。把输入流的指向称作源,程序从指向源的输入流中读取源中的数据;而输出流的指向是数据要去的一个目的地,程序通过向输出流中写入数据把数据传送到目的地。

    在这里插入图片描述

    1 File类

    File对象主要用来获取文件本身的一些信息,不涉及对文件的读写操作

    创建一个File对象的构造方法有3个,如下:

    (1) File(String filename);//filename为文件名
    (2) File(String directoryPath,String filename);//directoryPath是文件的路径
    (2) File(File dir,String filename);//dir为一个目录
    

    使用File(String filename);创建文件时,该文件位置默认为当前程序所在位置

    1.1 文件的属性

    File类的下列方法获取文件本身的一些信息。

    public String getName()//获取文件的名字。
    public boolean canRead()//判断文件是否是可读的。
    public boolean canWrite()//判断文件是否可被写入。
    public boolean exits()//判断文件是否存在。
    public long length()//获取文件的长度(单位是字节)。
    public String getAbsolutePath()//获取文件的绝对路径。
    public String getParent()//获取文件的父目录。
    public boolean isFile()//判断文件是否是一个普通文件,而不是目录。
    public boolean isDirectroy()//判断文件是否是一个目录。
    public boolean isHidden()//判断文件是否是隐藏文件。
    public long lastModified()//获取文件最后修改的时间。
    

    例子1.1(例子中使用上述的一些方法,获取某些文件的信息)

    package Example1;
    
    import java.io.File;
    
    public class Example1_1 {
        public static void main(String[] args) {
            File file = new File("D:\\lifeilin", "lifeilin.txt");//创建文件对象
            try {
                file.createNewFile();//创建一个新文件
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("文件是否存在:" + file.exists());
            System.out.println(file.getName() + "是可读的吗:" + file.canRead());
            System.out.println(file.getName() + "的长度:" + file.length());
            System.out.println(file.getName() + "的绝对路径:" + file.getAbsolutePath());
        }
    }
    

    在这里插入图片描述

    1.2 目录

    (1)创建目录
    public boolean mkdir()

    (2)列出目录中的文件

    public String[] list();用字符串形式返回目录下的全部文件。
    public File [] listFiles();File对象形式返回目录下的全部文件。
    public String[] list(FilenameFilter obj)用字符串形式返回目录下的指定类型的所有文件。
    public File [] listFiles(FilenameFilter obj)File对象形式返回目录下的指定类型所有文件。
    

    上述两方法的参数FilenameFilter是一个接口,该接口有一个方法:
    public boolean accept(File dir,String name);

    例子2(Example1_2.java ,FileAccept.java ),例子2列出当前目录(应用程序所在的目录)下全部java文件的名字)

    FileAccept.java

    package Example1_2;
    
    import java.io.*;
    
    public class FileAccept implements FilenameFilter {//FileAccept类实现FilenameFilter接口
        private String extendName;
        public void setExtendName(String s) {
            extendName="."+s;
        }
        public boolean accept(File dir,String name) { //重写接口中的方法
            return name.endsWith(extendName);
        }
    }
    

    Example1_2.java

    package Example1_2;
    
    import java.io.*;
    
    public class Example1_2 {
        public static void main(String[] args) {
            File dirFile = new File(".");
            FileAccept fileAccept = new FileAccept();
            fileAccept.setExtendName("java");
            String fileName[] = dirFile.list(fileAccept);
            for (String name : fileName) {
                System.out.println(name);
            }
        }
    }
    

    1.3 文件的创建与删除

    当使用File类创建一个文件对象后,例如
    File file=new File(“D:”,“letter.txt”);

    如果D:\目录中没有名字为letter.txt文件,文件对象file调用方法
    public boolean createNewFile();
    文件对象调用方法public boolean delete()可以删除当前文件,
    例如:
    file.delete();

    1.4 运行可执行文件

    ➢用Runtime类声明一个对象( Runtime类在java.lang包)
    Runtime ec;
    ➢然后使用该类的getRuntime()静态方法创建这个对象:
    ec=Runtime.getRuntime();
    ec可以调用 exec(String command) 方法打开本地机的可执行
    文件或执行一个操作。

    下面例子演示打开本地的记事本:

    import java.io.*;
    
    public class Example1_4 {
        public static void main(String[] args) {
            try {
                Runtime ce = Runtime.getRuntime();//创建对象
                File file = new File("c:/windows", "Notepad.exe");
                ce.exec(file.getAbsolutePath());//打开本地记事本
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }
    

    2 文件字节输入、输出流

    ➢java.io包提供了大量的流类.
    ➢Java把InputStream 抽象类的子类创建的流对象称作字节输入流;OutputStream抽象类的子类创建的流对象称作字节输出流。
    ➢针对不同的源或目的地。java.io包为程序提供了相应的输入流或输出流。这些输入、输出流绝大部分都是InputStream、OutputStream、Reader或Writer的子类。

    2.1 文件字节输入流

    使用输入流通常包括4个基本步骤:
    (1)设定输入流的源
    (2)创建指向源的输入流
    (3)让输入流读取源中的数据
    (4)关闭输入流。

    (1)构造方法:设定输入流源
    使用FileInputStream类的下列构造方法创建指向文件的输入流。

    FileInputStream(String name);//使用给定的文件名name创建FileInputStream流
    FileInputStream(File file);//使用File对象创建FileInputStream流
    //参数name和file指定的文件称为输入流的源
    

    FileInpuStream输入流打开一个到达文件的通道(源就是这个文件,输入流指向这个文件)。当创建输入流时,可能会出现错误(也被称为异常)。例如,输入流指向的文件可能不存在。当出现I/O错误,Java 生成一个出错信号,它使用IOException (IO异常)对象来表示这个出错信号。程序必须在try-catch语句中的try块部分创建输入流,在catch (捕获)块部分检测并处理这个异常。例如,为了读取一个名为hello.txt 的文件,建立一个文件输入流in。

            try {
                FileInputStream in = new FileInputStream("hello.txt");//创建指向文件hello.txt的输入流
            } catch (IOException e) {
                System.out.println("File read error:" + e);
            }
    

    或者:

    		File f = new File("hello.txt");//指定输入流的源
            try {
                FileInputStream in = new FileInputStream(f);//创建指向源输入流
            } catch (IOException e) {
                System.out.println("File read error:" + e);
            }
    

    (2)使用输入流读取字节
    文件字节流可以调用从父类继承的read方法顺序地读取文件,只要不关闭流,每次调用read方法就顺序地读取文件中的其余内容,直到文件的末尾或文件字节输入流被关闭。

    ➢int read();读取单个字节的数据,返回字节值(0~255整数) ,如果未读出字节就返回-1。
    ➢int read(byte b[]);读取b.length个字节到字节数组b中,返回实际读取的字节数。如果到达文件的末尾,则返回-1。
    ➢int read(byte b[], int off, int len);读取len个字节到字节数组b中,并返回实际读取的字节数目。如果到达文件的末尾,则返回-1,参数off指定从字节数组的某个位置开始存放读取的数据。

    (3) 关闭流
    输入流都提供了关闭方法close(),尽管程序结束时会自动关闭所有的流,但是当程序使用完流后,显示地关闭任何打开的流仍然是一个良好的习惯,如果没有关闭那些被打开的流,那么就可能不允许另一个程序操作这些所用的资源。

    下面例子使用文件字节流读文件内容:

    import java.io.*;
    
    public class Example2_1 {
        public static void main(String[] args) {
            int n = -1;
            byte[] a = new byte[100];
            try {
                File f = new File("D:\\","Example2_1.java");
                InputStream in = new FileInputStream(f);
                while ((n = in.read(a, 0, 100)) != -1) {
                    String s = new String(a, 0, n);
                    System.out.print(s);
                }
                in.close();
            } catch (IOException e) {
                System.out.println("File read Error" + e);
            }
        }
    }
    

    2.2 文件字节输出流

    ➢使用输出流通常包括4个基本步骤:
    (1)给出输出流的目的地
    (2)创建指向目的地的输出流
    (3)让输出流把数据写入到目的地
    (4)关闭输出流。

    (1)构造方法
    使用FileOutputStream类的下列具有刷新功能的构造方法创建指向文件的输出流。

    FileOutputStream(String name);
    FileOutputStream(File file);
    //参数name和file指定的文件称为输出流的目的地
    

    FileOutpuStream输出流开通一个到达文件的通道(目的地就是这个文件,输出流指向这个文件)。需要特别注意的是,如果输出流指向的文件不存在,Java 就会创建该文件,如果指向的文件是已存在的文件,输出流将刷新该文件(使得文件的长度为0)。另外,与创建输入流相同,创建输出流时,可能会出现错误(被称为异常),例如,输出流试图要写入的文件可能不允许操作或有其他受限等原因。所以必须在try-catch语句中的try块部分创建输出流,在catch (捕获)块部分检测并处理这个异常。例如,创建指向名为destin.txt的输出流out。

            try {
                FileOutputStream out = new FileOutputStream("destin.txt");//创建指向文件destin.txt的输出流
            } catch (IOException e) {
                System.out.println("File writeerror:" + e);
            }
    

    或者:

    		File f = new File("destin.txt");//指定输出流的源
            try {
                FileOutputStream out = new FileOutputStream (f);//创建指向源输出流
            } catch (IOException e) {
                System.out.println("File write:" + e);
            }
    

    可以使用FileOutputStream类的下列能选择是否具有刷新功能的构造方法创建指向文件的输出流。

    FileOutputStream(String name, boolean append) ;
    FileOutputStream(File file, boolean append) ;
    

    当用构造方法创建指向一个文件的输出流时,如果参数append取值true, 输出流不会刷新所指向的文件(假如文件已存在),输出流的write的方法将从文件的末尾开始向文件写入数据,参数append取值false, 输出流将刷新所指向的文件(假如文件已存在)。

    (2)使用输出流写字节
    输出流的wirie方法以字节单位向目的地写数据。

    void write(int n)//向目的地写入单个字节。
    void write(byte b[])//向目的地写入一个字节数组。
    void write(byte b[],int off,int len)//从字节数组中偏移量off处取len个字节写到目的地。
    

    FileOutputStream流顺序地写文件,只要不关闭流,每次调用write方法就顺序地向目的地写入内容,直到流被关闭。

    (3)关闭流
    通过调用close()方法,可以保证操作系统把流缓冲区的内容写到它的目的地,即关闭输出流可以把该流所用的缓冲区的内容冲洗掉(通常冲洗到磁盘文件上)。

    例子2.2使用文件字节输出流写文件a.txt。
    例子2.2首先使用具有刷新功能的构造方法创建指向文件a.txt的输出流、并向a.txt文件写入“新年快乐”,然后再选择使用不刷新文件的构造方法指向a.txt,并向文件写入( 即尾加)“ Happy New Year

    import java.io.*;
    
    public class Example2_2 {
        public static void main(String[] args) {
            byte[] a = "新年快乐".getBytes();
            byte[] b = "Happy New Year".getBytes();
            File file = new File("D:\\","a.txt");                         //输出的目的地
            try {
                OutputStream out = new FileOutputStream(file);      //指向目的地的输出流
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");//a.txt的大小:0字节
                out.write(a);                                    //向目的地写数据
                out.close();
                out = new FileOutputStream(file, true);             //准备向文件尾加内容
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");///a.txt的大小:8字节
                out.write(b, 0, b.length);
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");///a.txt的大小:8字节
                out.close();
            } catch (IOException e) {
                System.out.println("Error " + e);
            }
        }
    }
    

    在这里插入图片描述

    3 文件字符输入、输出流

    ➢Java把Reader抽象类的子类创建的流对象称作字符输入流;Writer抽象类的子类创建的流对象称作字符输出流。

    与FileInputStream. FileOutputStream字节流相对应的是FileReader、FileWriter字符流(文件字符输入、输出流),FileReader 和FileWriter 分别是Reader和Writer的子类,其构造方法分别是:

    FileReader(String filename) ; 
    FileReader(File filename) ;
    
    FileWriter(String filename) ; 
    FileWriter(File filename) ;
    FileWriter(String filename, boolean append) ; 
    FileWriter(File filename,boolean append) ;
    

    字符输入流和输出流的read和write方法使用字符数组读写数据,即以字符为基本单位处理数据。

    ➢1. Reader类提供的read方法以字符为单位顺序地读取源中的数据。

    int read();
    int read(char b[]);
    int read(char b[], int off, int len);
    void close();
    

    ➢2. Writer流 以字符为单位顺序地写文件,每次调用write方法就顺序地向目的地写入内容。Writer类有 如下常用的方法。

    void write(int n)//向输出流写入一个字符。
    void write(byte b[])//向输出流写入一个字符数组。
    void write(byte b[],int off,int length)//从给定字符数组中起始于偏移量off处取len个字符写到输出流。
    void close()//关闭输出流。
    

    例子3使用文件字符输入、输出流将文件a.txt的内容尾加到文件b.txt中

    import java.io.*;
    
    public class Example3 {
        public static void main(String args[]) {
            File sourceFile = new File("a.txt");  //读取的文件
            File targetFile = new File("b.txt");  //写入的文件
            char c[] = new char[19];               //char型数组
            try {
                Writer out = new FileWriter(targetFile, true); //指向目的地的输出流
                Reader in = new FileReader(sourceFile);   //指向源的输入流
                int n = -1;
                while ((n = in.read(c)) != -1) {
                    out.write(c, 0, n);
                }
                out.flush();
                out.close();
            } catch (IOException e) {
                System.out.println("Error " + e);
            }
        }
    }
    

    注:对于Writer流,write 方法将数据首先写入到缓冲区,每当缓冲区溢出时,缓冲区的内容被自动写入到目的地,如果关闭流,缓冲区的内容会立刻被写入到目的地。流调用flush0方法可以立刻冲洗当前缓冲区,即将当前缓冲区的内容写入到目的地。

    4 缓冲流

    ➢BufferedReader和BufferedWriter类创建的对象称作缓冲输入、输出流。二者的源和目的地必须是字符输入流和字符输出流。
    ➢构造方法:

    BufferedReader(Reader in);
    BufferedWriter(Writer out);
    

    BufferedReader流能够读取文本行,方法是readLine()。通过向BufferedReader 传递一个Reader子类的对象(如FileReader 的实例),来创建一个BufferedReader对象,如:

    FileReader inOne = new FileReader("Student. txt") ;
    BufferedReader inTwo = BufferedReader(inOne) ;
    

    然后inTwo流调用readLine()方法中读取Student.txt,例如:

    String strLine = inTwo. readLine() ;
    

    类似地,可以将BufferedWriter流和FileWriter 流连接在一起, 然后使用BufferedWriter流将数据写到目的地,例如:

    FileWriter tofile = new FileWriter("hello.txt") ;
    BufferedWriter out = BufferedWriter(tofile) ;
    

    然后out使用BufferedReader类的方法wite(tring s,int off,int len)把字符串s写到hello.txt中,参数off是s开始处的偏移量,len是写入的字符数量。
    另外,BufferedWriter 流有-一个独特的向文件写入一 个回行符的方法

    newLine() ;

    ➢BufferedReader和BufferedWriter类读 写文件的方法:

    readLine()//读取文本行
    write(String s,int of,int len)//把字符串s写到文件中
    newLine();// 向文件写入一个回行符
    

    由英语句子构成的文件english. txt (每句占一行):
    The arrow missed the target.
    They rejected the union demand.
    Where does this road go to?

    例子4按行读取english. txt,并在该行的后面尾加上该英语句子中含有的单词数目,然后再将该行写入到一个名字为englishCount. txt的文件中

    import java.io.*;
    import java.util.*;
    
    public class Example10_1 {
        public static void main(String[] args) {
            File fRead = new File("D:\\","english.txt");
            File fWrite = new File("D:\\","englishCount.txt");
            try {
                Writer out = new FileWriter(fWrite);//指向目的地的输出流
                BufferedWriter bufferWrite = new BufferedWriter(out);
    
                Reader in = new FileReader(fRead);//指向源的输入流
                BufferedReader bufferRead = new BufferedReader(in);
    
                String str = null;
                while ((str = bufferRead.readLine()) != null) {
                    StringTokenizer fenxi = new StringTokenizer(str);
                    int count = fenxi.countTokens();
                    str = str + " 句子中单词个数:" + count;
                    bufferWrite.write(str);
                    bufferWrite.newLine();
                }
                bufferWrite.close();
                out.close();
                in = new FileReader(fWrite);
                bufferRead = new BufferedReader(in);
                String s = null;
                System.out.println(fWrite.getName() + "内容:");
                while ((s = bufferRead.readLine()) != null) {
                    System.out.println(s);
                }
                bufferRead.close();
                in.close();
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • Java标准的输入输出流

    2020-06-03 15:37:19
    5.标准输入输出流 标准的输入输出流简单了解一下就可以了,实际开发时一般用不着。 标准的输入流 System.in表示标准的输入流,用来从读取从键盘录入的数据,本质上就是一个InputStream 看下面代码演示,从键盘录入...

    5.标准输入输出流

    标准的输入输出流简单了解一下就可以了,实际开发时一般用不着。

    标准的输入流

    System.in表示标准的输入流,用来从读取从键盘录入的数据,本质上就是一个InputStream

    看下面代码演示,从键盘录入数据。

    public class SystemInDemo{
        public static void main(String[] args){
            //System.in的数据源是控制台键盘录入的数据
            InputStream in=System.in;
    
            //读取一个字节
            int by=in.read(); //阻塞,等待用户录入
            System.out.println(by);
    
            //释放资源
            in.close();
        }
    }
    

    Java的API中提供了Scanner类已经对System.in进行了封装,读取键盘录入的数据更加方便。所以不需要我们自己使用System.in来读取键盘录入的数据

    标准的输出流

    System.out表示装的输出流,用来往控制台输出数据,本质上就是一个OutputStream

    看下面代码演示,往控制台输出数据。

    public class SystemOutDemo{
        public static void main(String[] args){
            //System.out的输出目的是控制台
            OutputStream out=System.out;
    
            //写一个字节
            out.write(97);
    
            //写多个字节
            byte[] bs={97,98,99,100};
            out.write(bs);
    
            //释放资源
            out.close();
        }
    }
    

    我们经常用的System.out.println("hello");其实就是用的标准的输出流,往控制台输出数据。 这里只是探究了一下它的原理,了解即可

    展开全文
  • JAVA实验六 输入输出流

    千次阅读 2020-12-31 14:52:10
    理解文件和的概念、Java 的层次结构,掌握 Java 提供的各种字节类和字符类的功能和使用方法。 实验内容: 1、编写一个 Java 应用程序,将已存在的扩展名为.txt 的文本文件加密后存入另一个文本文件中。按...
  • 数据压缩,文件传输 Java数据压缩与传输实例,可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、关闭输入流、关闭套接字关闭输出流、输出错误信息等Java编程小技巧...
  • public static final PrintStream out:标准输出流。通常该流对应于显示输出或者由主机环境或用户指定的另一个输出目标 我们先看标准输入流 package com.testIO; import java.io.IOException; import java...
  • A、在Java中,文件的输入输出功能是通过来实现的 B、如果要把数据写入到一个文件中,需要创建一个输入对象 C、字符在某些方面比如汉字的处理,比字节更高效 D、可以通过Reader r = new Reader(“c:\A.txt”)...
  • Java读取文件操作, 输入输出流的用法:FileInputStream、FileOutputStream类
  • 关于Java中的字节输入输出流和字符输入输出流,大致的做个学习总结。 对于任何文件来说本质上都是由字节组成的,所以在Java中来说。 字节流可以复制读取任何形式的文件,比如图片,音频等,而字符流我们一般用来...
  • 一,序言Java输入输出涉及的概念比较多,涉及的类也很多,很容易搞混,所以还是非常有必要梳理下的。二,Java语言的输入和输出是基于(stream)的,所谓的很好理解,就是向水一样向数据源中淌入数据,特点是一...
  • java中的输入流与输出流的存在是为了程序对计算机上的文件进行读写操作的,首先我们先来看一下相关的基础知识 读写文件 FileInputStream 该流用于从文件读取数据,它的对象可以用关键字 new 来创建。 有多种构造...
  • 学习Java,你需要知道这些——输入输出流(一)

    千次阅读 多人点赞 2020-05-12 18:16:05
    输入输出流的概念 预定义的I/O流类 从流的方向划分 输入流 输出流 从流的分工划分 节点流 处理流 从流的内容划分 面向字符的流 面向字节的流 java.io包的顶级层次结构 面向字符的流:专门用于字符数据 面向字节的...
  • 标准输入输出流

    2019-01-27 09:48:53
    System.in和System.out分别代表了系统标准的输入输出设备 默认输入设备是键盘,输出设备是显示器 System.in的类型是InputStream System.out的类型是PrintStream,其是OutputStream的子类FilterOutputStream 的...
  • Java输入输出处理

    2019-12-01 17:51:51
    通过不同输入输出设备间的数据传输抽象为流。 运行在内存中的应用程序,如果想从一些地方来获得数据例如文件,则可以使用上述来源创建输入流,并从其中读取数据。 同理,内存中的应用程序可以通过输出流把数据输出...
  • java输入输出流总结

    千次阅读 2014-04-04 17:17:46
     流是数据源或数据目标的输入输出设备的抽象表示。支持流输入输出的主要包是java.io,但是也有其他的包,比如java.nio.file。java.io包支持两种类型的流——包含二进制数据的字节流和包含字符数据的字符流。 ...
  • java第十章练习题(输入输出流

    千次阅读 2018-09-28 16:59:26
    第十章练习题(输入输出流)    1.下列哪项是Java语言中所定义的字节流?  A.Output  B.Reader  C.Writer  D.InputStream    2.在输入流的read方法返回哪个值的时候表示读取结束?  A. 0 ...
  • 关于java输出流flush()方法 http://blog.csdn.net/lsx991947534/article/details/45065773 下面原文的内容,我直接转过来了,有点无耻了\(^o^)/~...............,再次向原博主表示道歉和感谢^_^ 在...
  • Java(标准输入/输出流

    千次阅读 2016-08-31 20:00:22
    Java通过系统类System实现标准输入/输出的功能,定义了3个变量:in,out,和err.这3个Java中都定义为静态变量,可以直接通过System类进行调用。System.in表示标准输入,通常指从键盘输入数据;System.out表示标准...
  • 以下是博主学java的时候记的一些笔记,分享给大家,如果有错误或者以为的话,可以在下方留言 File 类   创建File对象的构造方法有以下3个: File(String filename); File(String directoryPath,String ...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java数据压缩与传输实例,可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、关闭输入流、关闭套接字关闭输出流、输出错误信息等Java编程小技巧。 Java数组倒置...
  • Java实验第四次 java题目: 分别使用字节流和字符流...使用Java输入输出流将一个文本文件的内容按行读出,每读出一行就顺序添加行号,并写入到另一个文件中。 利用面向对象的设计思想,创建学生类,学生信息包括:
  • JAVA实验六文件的输入输出的应用

    千次阅读 2016-05-31 11:35:20
    1.掌握I/O输入输出流的使用。 2.掌握文件输入输出的使用。 二、实验编程内容 1.使用文件字符输出流将一段文字存入文件,然后使用输入流读取文件中的内容。 2.将字符串加密后写入文件,然后读取该文件,并解密。 ...
  • java字符串与输入输出

    千次阅读 2020-05-01 09:54:26
    java字符串与输入输出 Java 没有内置的字符串类型, 而是在标准Java 类库中提供了一个预定义类, 很自然地叫做String。每个用双引号括起来的字符串都是String 类的一个实例: String e = ""; // an empty string ...
  • 对象输入输出流的使用:(对象先进先出,按序读取,不能跳过读取) 注意:要写入的对象的类需先实现接口Serializable 或者  Externalnalizable,如果调用了父类的构造函数,则需要父类也要实现接口Serializable ...
  •   如果在命令行方式下用下列命令启动程序: java MyProg 启动路径就是命令解释器的当前路径。   然而,如果使用集成开发环境, 那么启动路径将由 IDE 控制。 可以使用下面的调用方式找到路径的位置: String...
  • 输入输出可以说是计算机的基本功能。作为一种语言体系,java中主要按照(stream)的模式来实现。其中数据的流向是按照计算机的方向确定的,流入计算机的数据叫做输入(inputStream),由计算机发出的数据叫做...

空空如也

空空如也

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

下列是java的输入输出流的是

java 订阅