精华内容
下载资源
问答
  • Java(2)-Java IO输入输出

    万次阅读 多人点赞 2012-04-01 11:28:55
    Java中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的...

     

     

    1.什么是IO


          Java中I/O操作主要是指使用Java进行输入,输出操作. Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。  

          Java.io是大多数面向数据流的输入/输出类的主要软件包。此外,Java也对块传输提供支持,在核心库 java.nio中采用的便是块IO。

      流IO的好处是简单易用,缺点是效率较低。块IO效率很高,但编程比较复杂。 
          Java IO模型  :
          Java的IO模型设计非常优秀,它使用Decorator模式,按功能划分Stream,您可以动态装配这些Stream,以便获得您需要的功能。例如,您需要一个具有缓冲的文件输入流,则应当组合使用FileInputStream和BufferedInputStream。

     

    2.数据流的基本概念


            数据流是一串连续不断的数据的集合,就象水管里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据,这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说,看不到数据流在写入时的分段情况,每次可以读取其中的任意长度的数据,但只能先读取前面的数据后,再读取后面的数据。不管写入时是将数据分多次写入,还是作为一个整体一次写入,读取时的效果都是完全一样的。 

          “流是磁盘或其它外围设备中存储的数据的源点或终点。”

        在电脑上的数据有三种存储方式,一种是外存,一种是内存,一种是缓存。比如电脑上的硬盘,磁盘,U盘等都是外存,在电脑上有内存条,缓存是在CPU里面的。外存的存储量最大,其次是内存,最后是缓存,但是外存的数据的读取最慢,其次是内存,缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解,我们可以简单的理解为容器,即外存是一个容器,内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢?

         在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:

             标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流等等,java中将输入输出抽象称为流,就好像水管,将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流,将数据从内存写入外存中的称为输出流。

        流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。

    总结的基本概念如下:

    1) 数据流

        一组有序,有起点和终点的字节的数据序列。包括输入流和输出流。

      

    2) 输入流(Input  Stream):

          程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…),即是将数据源读入到程序的通信通道

         

     3) 输出流

        程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

             

    采用数据流的目的就是使得输出输入独立于设备。

    Input  Stream不关心数据源来自何种设备(键盘,文件,网络)
    Output  Stream不关心数据的目的是何种设备(键盘,文件,网络)

    4) 数据流分类:

    流序列中的数据既可以是未经加工的原始二进制数据,也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种:
     1)  字节流:数据流中最小的数据单元是字节
     2)  字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。

     

     

    3. 标准I/O


          Java程序可通过命令行参数与外界进行简短的信息交换,同时,也规定了与标准输入、输出设备,如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

    1. 命令行参数

    public class TestArgs {
    	public static void main(String[] args) {
    		for (int i = 0; i < args.length; i++) {
    			System.out.println("args[" + i + "] is <" + args[i] + ">");
    		}
    	}
    }

    运行命令:java Java C VB
    运行结果:
    args[0] is <Java>
    args[1] is <C>
    args[2] is <VB>

     

    2. 标准输入,输出数据流

    java系统自带的标准数据流:java.lang.System:

    java.lang.System 
    public final class System  extends Object{ 
       static  PrintStream  err;//标准错误流(输出)
       static  InputStream  in;//标准输入(键盘输入流)
       static  PrintStream  out;//标准输出流(显示器输出流)
    }

    注意:
    (1)System类不能创建对象,只能直接使用它的三个静态成员。
    (2)每当main方法被执行时,就自动生成上述三个对象。

    1) 标准输出流 System.out

       System.out向标准输出设备输出数据,其数据类型为PrintStream。方法:

          Void print(参数)
          Void println(参数)

    2)标准输入流 System.in

        System.in读取标准输入设备数据(从标准输入获取数据,一般是键盘),其数 据类型为InputStream。方法:

            int read()  //返回ASCII码。若,返回值=-1,说明没有读取到任何字节读取工作结束。
             int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数
    例如:
    import java.io.*;
    public class StandardInputOutput {
    	public static void main(String args[]) {
    		int b;
    		try {
    			System.out.println("please Input:");
    			while ((b = System.in.read()) != -1) {
    				System.out.print((char) b);
    			}
    		} catch (IOException e) {
    			System.out.println(e.toString());
    		}
    	}
    }
    等待键盘输入,键盘输入什么,就打印出什么:

     

    3)标准错误流

       System.err输出标准错误,其数据类型为PrintStream。可查阅API获得详细说明。

        标准输出通过System.out调用println方法输出参数并换行,而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法,包括输出参数类型为boolean、char、int、long、float和double。同时,也重载实现 了输出参数类型为char[]、String和Object的方法。其中,print(Object)和println(Object)方法在运行时将调 用参数Object的toString方法。

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class StandardInputOutput {
    	public static void main(String args[]) {
    		String s;
    		// 创建缓冲区阅读器从键盘逐行读入数据
    		InputStreamReader ir = new InputStreamReader(System.in);
    		BufferedReader in = new BufferedReader(ir);
    		System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
    				+ "\nWindows系统: ctrl-z 退出");
    		try {
    			// 读一行数据,并标准输出至显示器
    			s = in.readLine();
    			// readLine()方法运行时若发生I/O错误,将抛出IOException异常
    			while (s != null) {
    				System.out.println("Read: " + s);
    				s = in.readLine();
    			}
    			// 关闭缓冲阅读器
    			in.close();
    		} catch (IOException e) { // Catch any IO exceptions.
    			e.printStackTrace();
    		}
    	}
    }

     

    4.java.IO层次体系结构


         在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

          Java I/O主要包括如下几个层次,包含三个部分:

       1.流式部分――IO的主体部分;

       2.非流式部分――主要包含一些辅助流式部分的类,如:File类、RandomAccessFile类和FileDescriptor等类;

       3.其他类--文件读取部分的与安全相关的类,如:SerializablePermission类,以及与本地操作系统相关的文件系统的类,如:FileSystem类和Win32FileSystem类和WinNTFileSystem类。

       主要的类如下:

         1. File(文件特征与管理):用于文件或者目录的描述信息,例如生成新目录,修改文件名,删除文件,判断文件所在路径等。

         2. InputStream(二进制格式操作):抽象类,基于字节的输入操作,是所有输入流的父类。定义了所有输入流都具有的共同特征。

         3. OutputStream(二进制格式操作):抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

         Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

         4. Reader(文件格式操作):抽象类,基于字符的输入操作。

         5. Writer(文件格式操作):抽象类,基于字符的输出操作。

         6. RandomAccessFile(随机文件操作):它的功能丰富,可以从文件的任意位置进行存取(输入输出)操作

     

         Java中IO流的体系结构如图:

         

     

     

    5. 非流式文件类--File类


    在Java语言的java.io包中,由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类,因为它不负责数据的输入输出,而专门用来管理磁盘文件与目录。
     
    作用:File类主要用于命名文件、查询文件属性和处理文件目录。
    public    class   File   extends Object 
        implements Serializable,Comparable
    {}

     

    File类共提供了三个不同的构造函数,以不同的参数形式灵活地接收文件和目录名信息。构造函数:
    1)File (String   pathname)   
         例:File  f1=new File("FileTest1.txt"); //创建文件对象f1,f1所指的文件是在当前目录下创建的FileTest1.txt
    2)File (String  parent  ,  String child)
         例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意:D:\\dir1目录事先必须存在,否则异常
    3)File (File    parent  , String child)
         例:File  f4=new File("\\dir3");
              File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建
            一个对应于某磁盘文件或目录的File对象一经创建, 就可以通过调用它的方法来获得文件或目录的属性。    
           1)public boolean exists( ) 判断文件或目录是否存在
           2)public boolean isFile( ) 判断是文件还是目录 
           3)public boolean isDirectory( ) 判断是文件还是目录
           4)public String getName( ) 返回文件名或目录名
           5)public String getPath( ) 返回文件或目录的路径。
           6)public long length( ) 获取文件的长度 
           7)public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。 
           File类中还定义了一些对文件或目录进行管理、操作的方法,常用的方法有:
           1) public boolean renameTo( File newFile );    重命名文件
           2) public void delete( );   删除文件
           3)  public boolean mkdir( ); 创建目录
     
    例子:

     

    import java.io.File;
    import java.io.IOException;
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		File dir = new File("\\root");
    		File f1 = new File(dir, "fileOne.txt");
    		File f2 = new File(dir, "fileTwo.java");
    		// 文件对象创建后,指定的文件或目录不一定物理上存在
    		if (!dir.exists())
    			dir.mkdir();
    		if (!f1.exists())
    			f1.createNewFile();
    		if (!f2.exists())
    			f2.createNewFile();
    		System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());
    		System.out.println("f1 Canread=" + f1.canRead());
    		System.out.println("f1's len= " + f1.length());
    		String[] FL;
    		int count = 0;
    		FL = dir.list();
    		for (int i = 0; i < FL.length; i++) {
    			count++;
    			System.out.println(FL[i] + "is in \\root");
    		}
    		System.out.println("there are" + count + "file in //root");
    	}
    
    }

     

    说明:File类的方法:
    (1) exists()测试磁盘中指定的文件或目录是否存在
    (2) mkdir()创建文件对象指定的目录(单层目录)
    (3) createNewFile()创建文件对象指定的文件

    (4) list()返回目录中所有文件名字符串

     

    6. Java.IO流类库


    1. io流的四个基本类

          java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类:InputStream、OutputStream及Reader、Writer类,它们分别处理字节流和字符流:

    基本数据流的I/O

    输入/输出

    字节流

    字符流

    输入流

    Inputstream

    Reader

    输出流

    OutputStream

    Writer

     
    IO框架:

     

        

     

     Java中其他多种多样变化的流均是由它们派生出来的:

          JDK1.4版本开始引入了新I/O类库,它位于java.nio包中,新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

          在java.io包中, java.io.InputStream 表示字节输入流, java.io.OutputStream表示字节输出流,处于java.io包最顶层。这两个类均为抽象类,也就是说它们不能被实例化,必须生成子类之后才能实现一定的功能。

     

    2. io流的具体分类

    一、按I/O类型来总体分类:

         1. Memory 1)从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream
                       2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream
         2.Pipe管道  实现管道的输入和输出(进程间通信): PipedReader、PipedWriter、PipedInputStream、PipedOutputStream
         3.File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream
         4. ObjectSerialization 对象输入、输出 :ObjectInputStream、ObjectOutputStream
         5.DataConversion数据流 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream
         6.Printing 包含方便的打印方法 :PrintWriter、PrintStream
         7.Buffering缓冲  在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream
         8.Filtering 滤流,在数据进行读或写时进行过滤:FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过
         9.Concatenation合并输入 把多个输入流连接成一个输入流 :SequenceInputStream
        10.Counting计数  在读入数据时对行记数 :LineNumberReader、LineNumberInputStream
        11.Peeking Ahead 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream
        12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader,Writer的转换类):InputStreamReader、OutputStreamWriter

    、按数据来源(去向)分类: 
    1、File(文件): FileInputStream, FileOutputStream, FileReader, FileWriter 
    2、byte[]:ByteArrayInputStream, ByteArrayOutputStream 
    3、Char[]: CharArrayReader, CharArrayWriter 
    4、String: StringBufferInputStream, StringReader, StringWriter 
    5、网络数据流:InputStream, OutputStream, Reader, Writer 

     

     

    7. 字节流InputStream/OutputStream


     1. InputStream抽象类 

          InputStream 为字节输入流,它本身为一个抽象类,必须依靠其子类实现各种功能,此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的,且数据单位为字节(8bit);

    InputStream是输入字节数据用的类,所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法: 
      (1) public abstract int read( ):读取一个byte的数据,返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。
      (2) public int read(byte b[ ]):读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的 
      (3) public int read(byte b[ ], int off, int len):从输入流中最多读取len个字节的数据,存放到偏移量为off的b数组中。 
      (4) public int available( ):返回输入流中可以读取的字节数。注意:若输入阻塞,当前线程将被挂起,如果InputStream对象调用这个方法的话,它只会返回0,这个方法必须由继承InputStream类的子类对象调用才有用, 
      (5) public long skip(long n):忽略输入流中的n个字节,返回值是实际忽略的字节数, 跳过一些字节来读取 
      (6) public int close( ) :我们在使用完后,必须对我们打开的流进行关闭. 

             主要的子类:

            

             1) FileInputStream把一个文件作为InputStream,实现对文件的读取操作     
        2) ByteArrayInputStream:把内存中的一个缓冲区作为InputStream使用 
        3) StringBufferInputStream:把一个String对象作为InputStream 
        4) PipedInputStream:实现了pipe的概念,主要在线程中使用 
        5) SequenceInputStream:把多个InputStream合并为一个InputStream 

     

     2.OutputStream抽象类

      OutputStream提供了3个write方法来做数据的输出,这个是和InputStream是相对应的。 
      1. public void write(byte b[ ]):将参数b中的字节写到输出流。 
      2. public void write(byte b[ ], int off, int len) :将参数b的从偏移量off开始的len个字节写到输出流。 
      3. public abstract void write(int b) :先将int转换为byte类型,把低字节写入到输出流中。 
      4. public void flush( ) : 将数据缓冲区中数据全部输出,并清空缓冲区。 
      5. public void close( ) : 关闭输出流并释放与流相关的系统资源。 

     

           主要的子类:

            

          1) ByteArrayOutputStream:把信息存入内存中的一个缓冲区中 
          2) FileOutputStream:把信息存入文件中 
          3) PipedOutputStream:实现了pipe的概念,主要在线程中使用 
          4) SequenceOutputStream:把多个OutStream合并为一个OutStream 

    流结束的判断:方法read()的返回值为-1时;readLine()的返回值为null时。

    3. 文件输入流: FileInputStream类

          FileInputStream可以使用read()方法一次读入一个字节,并以int类型返回,或者是使用read()方法时读入至一个byte数组,byte数组的元素有多少个,就读入多少个字节。在将整个文件读取完成或写入完毕的过程中,这么一个byte数组通常被当作缓冲区,因为这么一个byte数组通常扮演承接数据的中间角色。

     

     

    作用:以文件作为数据输入源的数据流。或者说是打开文件,从文件读数据到内存的类。
    使用方法(1)    
       File  fin=new File("d:/abc.txt"); 
      FileInputStream in=new FileInputStream( fin);

     

    使用方法(2)
       FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

    程序举例:
    将InputFromFile.java的程序的内容显示在显示器上

     

    import java.io.IOException;
    import java.io.FileInputStream;
    ;
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		try{	
    		       FileInputStream rf=new   FileInputStream("InputFromFile.java");
    		       int n=512;   byte  buffer[]=new  byte[n];   
    		       while((rf.read(buffer,0,n)!=-1)&&(n>0)){
    		           System.out.println(new String(buffer) );
    		        }
    		        System.out.println();
    		        rf.close();
    		} catch(IOException  IOe){	    
    		      System.out.println(IOe.toString());
    		}
    
    	}
    
    }

     

    4.文件输出流:FileOutputStream类

       作用:用来处理以文件作为数据输出目的数据流;或者说是从内存区读数据入文件

          FileOutputStream类用来处理以文件作为数据输出目的数据流;一个表示文件名的字符串,也可以是File或FileDescriptor对象。 
      创建一个文件流对象有两种方法: 
      方式1: 
       File   f=new  File (“d:/myjava/write.txt ");
            FileOutputStream  out= new FileOutputStream (f);
      方式2: 
      FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt "); 
      方式3:构造函数将 FileDescriptor()对象作为其参数。 
      FileDescriptor() fd=new FileDescriptor(); 
      FileOutputStream f2=new FileOutputStream(fd); 
      方式4:构造函数将文件名作为其第一参数,将布尔值作为第二参数。 
      FileOutputStream f=new FileOutputStream("d:/abc.txt",true); 
      注意: (1)文件中写数据时,若文件已经存在,则覆盖存在的文件;(2)的读/写操作结束时,应调用close方法关闭流。 

     

    程序举例:使用键盘输入一段文章,将文章保存在文件write.txt中
    import java.io.IOException;
    import java.io.FileOutputStream;
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		try {
    			System.out.println("please Input from      Keyboard");
    			int count, n = 512;
    			byte buffer[] = new byte[n];
    			count = System.in.read(buffer);
    			FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");
    			wf.write(buffer, 0, count);
    			wf.close(); // 当流写操作结束时,调用close方法关闭流。
    			System.out.println("Save to the write.txt");
    		} catch (IOException IOe) {
    			System.out.println("File Write Error!");
    		}
    	}
    
    }

    5. FileInputStream流和FileOutputStream的应用

    利用程序将文件file1.txt 拷贝到file2.txt中。
    import java.io.File;
    import java.io.IOException;
    import java.io.FileOutputStream;
    import java.io.FileInputStream;
    
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		try {
    			File inFile = new File("copy.java");
    			File outFile = new File("copy2.java");
    			FileInputStream finS = new FileInputStream(inFile);
    			FileOutputStream foutS = new FileOutputStream(outFile);
    			int c;
    			while ((c = finS.read()) != -1) {
    				foutS.write(c);
    			}
    			finS.close();
    			foutS.close();
    		} catch (IOException e) {
    			System.err.println("FileStreamsTest: " + e);
    		}
    	}
    
    }
    

     

    6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

            

     

          

           计算机访问外部设备非常耗时。访问外存的频率越高,造成CPU闲置的概率就越大。为了减少访问外存的次数,应该在一次对外设的访问中,读写更多的数据。为此,除了程序和流节点间交换数据必需的读写机制外,还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区,一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

     

    BufferedInputStream:当向缓冲流写入数据时候,数据先写到缓冲区,待缓冲区写满后,系统一次性将数据发送给输出设备。

    BufferedOutputStream :当从向缓冲流读取数据时候,系统先从缓冲区读出数据,待缓冲区为空时,系统再从输入设备读取数据到缓冲区。

    1)将文件读入内存:

    BufferedInputStreamFileInputStream相接

      FileInputStream in=new  FileInputStream( “file1.txt ” );

      BufferedInputStream bin=new  BufferedInputStreamin); 

    2)将内存写入文件:

    BufferedOutputStream FileOutputStream相接

    FileOutputStreamout=new FileOutputStream(“file1.txt”);

    BufferedOutputStream  bin=new BufferedInputStream(out);


    3)键盘输入流读到内存
    BufferedReader标准的数据流相接 
     InputStreamReader sin=new InputStreamReader (System.in) ;
    BufferedReader bin=new             BufferedReader(sin);
    import java.io.*;
    
    public class ReadWriteToFile {
    	public static void main(String args[]) throws IOException {
    		InputStreamReader sin = new InputStreamReader(System.in);
    		BufferedReader bin = new BufferedReader(sin);
    		FileWriter out = new FileWriter("myfile.txt");
    		BufferedWriter bout = new BufferedWriter(out);
    		String s;
    		while ((s = bin.readLine()).length() > 0) {
    			bout.write(s, 0, s.length());
    		}
    
    	}
    }

    程序说明:
    从键盘读入字符,并写入到文件中BufferedReader类的方法:String readLine()
    作用:读一行字符串,以回车符为结束。
    BufferedWriter类的方法:bout.write(String s,offset,len)
    作用:从缓冲区将字符串s从offset开始,len长度的字符串写到某处。

     

    8. 字符流Writer/Reader


            Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

    1. Reader抽象类

        用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。

           

            1) FileReader :与FileInputStream对应  
               主要用来读取字符文件,使用缺省的字符编码,有三种构造函数: 
          (1)将文件名作为字符串 :FileReader f=new FileReader(“c:/temp.txt”); 
          (2)构造函数将File对象作为其参数。 
                  File f=new file(“c:/temp.txt”); 
                  FileReader f1=new FileReader(f); 
         (3)  构造函数将FileDescriptor对象作为参数 
                FileDescriptor() fd=new FileDescriptor() 
                FileReader f2=new FileReader(fd); 
                   (1) 用指定字符数组作为参数:CharArrayReader(char[]) 
                   (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 
              读取字符串,构造函数如下: public StringReader(String s); 
            2) CharArrayReader:与ByteArrayInputStream对应  
      3) StringReader : 与StringBufferInputStream对应 
      4) InputStreamReader 
            从输入流读取字节,在将它们转换成字符:Public inputstreamReader(inputstream is); 
      5) FilterReader: 允许过滤字符流 
            protected filterReader(Reader r); 
      6) BufferReader :接受Reader对象作为参数,并对其添加字符缓冲器,使用readline()方法可以读取一行。 
         Public BufferReader(Reader r); 

          主要方法:

          (1)  public int read() throws IOException; //读取一个字符,返回值为读取的字符 

      (2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中,返回值为实际读取的字符的数量*/ 
      (3)  public abstract int read(char cbuf[],int off,int len) throws IOException; 
      /*读取len个字符,从数组cbuf[]的下标off处开始存放,返回值为实际读取的字符数量,该方法必须由子类实现*/ 

    2. Writer抽象类

         写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。 其子类如下:

        

          1) FileWrite: 与FileOutputStream对应  
      将字符类型数据写入文件,使用缺省字符编码和缓冲器大小。 
      Public FileWrite(file f); 
      
    2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。 
          Public CharArrayWrite(); 
      3) PrintWrite:生成格式化输出 
          public PrintWriter(outputstream os); 
      4) filterWriter:用于写入过滤字符流 
          protected FilterWriter(Writer w); 
      5) PipedWriter:与PipedOutputStream对应   

          6) StringWriter:无与之对应的以字节为导向的stream  

          主要方法:

      (1)  public void write(int c) throws IOException; //将整型值c的低16位写入输出流 
      (2)  public void write(char cbuf[]) throws IOException; //将字符数组cbuf[]写入输出流 
      (3)  public abstract void write(char cbuf[],int off,int len) throws IOException; //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流 
      (4)  public void write(String str) throws IOException; //将字符串str中的字符写入输出流 
      (5)  public void write(String str,int off,int len) throws IOException; //将字符串str 中从索引off开始处的len个字符写入输出流 
      (6)  flush( ) //刷空输出流,并输出所有被缓存的字节。 
      (7)close()    关闭流 public abstract void close() throws IOException

     

     

    3 .InputStream与Reader差别 OutputStream与Writer差别

     

    InputStream和OutputStream类处理的是字节流,数据流中的最小单位是字节(8个bit)
    Reader与Writer处理的是字符流,在处理字符流时涉及了字符编码的转换问题

     

    import java.io.*;
    public class EncodeTest {
        private static void readBuff(byte [] buff) throws IOException {
           ByteArrayInputStream in =new ByteArrayInputStream(buff);
            int data;
            while((data=in.read())!=-1)   System.out.print(data+"  ");
            System.out.println();     in.close();     }
    
       public static void main(String args[]) throws IOException {
           System.out.println("内存中采用unicode字符编码:" );
           char   c='好';
           int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;
           System.out.println(""+lowBit+"   "+highBit);
           String s="好";
           System.out.println("本地操作系统默认字符编码:");
           readBuff(s.getBytes());
           System.out.println("采用GBK字符编码:");
           readBuff(s.getBytes("GBK"));
           System.out.println("采用UTF-8字符编码:");      
           readBuff(s.getBytes("UTF-8"));      }
    }
    


    Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符,然后在内存中为其分配内存

     

    Writer类能够将内存中的Unicode字符转换为其他编码类型的字符,再写到输出流中。

     

    9. FileWriter类(字符输出流类)


    构造方法:FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话,并创建。

                   如: FileWriter fw = new FileWriter("C:\\1.txt");

                     FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。

                   如:FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时,会在该文件的结尾续写,并不会覆盖掉。

    主要方法: 

            void write(String str)   //写入字符串。当执行完此方法后,字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。

            viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

            viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后,再写入或者刷新的话,会抛IOException异常。

    10. 如何选择IO流


        1)确定是数据源和数据目的(输入还是输出

                  源:输入流 InputStream Reader
                  目的:输出流 OutputStream Writer

        2)明确操作的数据对象是否是纯文本

                 是:字符流Reader,Writer
                 否:字节流InputStream,OutputStream

        3)明确具体的设备。

                 是硬盘文件:File++:

                 读取:FileInputStream,, FileReader, 

                  写入:FileOutputStream,FileWriter
                 
    是内存用数组

                      byte[]:ByteArrayInputStream, ByteArrayOutputStream
                     
    是char[]:CharArrayReader, CharArrayWriter
                 
    是String:StringBufferInputStream(已过时,因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter
                 
    是网络用Socket流

                 是键盘:用System.in(是一个InputStream对象)读取,用System.out(是一个OutoutStream对象)打印

        3)是否需要转换流

                是,就使用转换流,从Stream转化为Reader,Writer:InputStreamReader,OutputStreamWriter 

        4)是否需要缓冲提高效率

           是就加上Buffered:BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter
        5)是否需要格式化输出

     

    例:将一个文本文件中数据存储到另一个文件中。
         1)数据源和数据目的:读取流,InputStream Reader  输出:OutputStream Writer
         2)是否纯文本:是!这时就可以选择Reader Writer。
         3)设备:是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。

                FileReader fr = new FileReader("a.txt");  

                 FileWriter fw = new FileWriter("b.txt");  
         
    4)是否需要提高效率:是,加Buffer
                 BufferedReader bfr = new BufferedReader(new FileReader("a.txt");  );  
                 BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt");  );

    11. IOException异常类的子类


    1.public class  EOFException :
       非正常到达文件尾或输入流尾时,抛出这种类型的异常。
    2.public class FileNotFoundException:
       当文件找不到时,抛出的异常。
    3.public class InterruptedIOException:
       当I/O操作被中断时,抛出这种类型的异常。




     

    感谢您的支持,我会继续努力的! 扫码打赏,你说多少就多少

             

     

     

     

    展开全文
  • 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基础知识和常用算法合集: ... 目录 1.主类的命名必须是Main ...2.输入输出: 2.1输入: (1)使用Scanner类进行输入 (2) hasNext()方法 2.2输出 3快速输入输出 3.1使用StreamTokenizer 和 PrintW...

    JAVA基础知识和常用算法合集:

    https://blog.csdn.net/GD_ONE/article/details/104061907

    目录

    1. 主类的命名必须是Main

    2.输入输出:

      2.1输入:

    (1)使用Scanner类进行输入

    (2) hasNext()方法  

    2.2 输出

    3 快速输入输出

     3.1使用StreamTokenizer 和 PrintWriter

     3.2 使用BufferedReader和BufferedWriter实现快速输入输出

    BufferedReader

    BufferedWriter

    实例


    摘要

    本文主要介绍快速输入输出, 文中提到了几个IO类,这里推荐使用BufferedReader输入,BufferedWriter输出,当输入输出的数据量大于一百万左右就必须使用快速IO不能直接使用Scanner和System.out.print

    1. 主类的命名必须是Main

    形如:

    public class Main{

    }

    2.输入输出:

      2.1输入:

    (1)使用Scanner类进行输入

        首先需要定义一个可以在控制台从键盘接收数据的Scanner对象: (Scanner类的包名是 java.util.Scanner)

    Scanner in = new Scanner(System.in); // 用于控制台从键盘读入数据

    然后使用这个in对象配合in.nextXXX()方法接收数据:

    不同类型的数据使用不同的in.nextXXX()方法。

    如:

    字符串需要用

             或者

          

    需要注意的是:                                                                                                                                                                        

    in.next() 从缓冲区接收字符遇到空格后停止。 相当于 cin 和 scanf

    in.nextLine() 从缓冲区接收字符,并且接收空格,遇到换行才停止,并且会自动舍弃换行。 相当于 gets()

    import java.util.Scanner;
    
    public class Main{
    	public static void main(String[] args){
    		Scanner in = new Scanner(System.in);
    		String s1 = in.next();  // -》 C++中 cin/scanf
    		String s2 = in.nextLine(); // -> C++中  gets()
    		System.out.println("s1:"+s1);
    		System.out.println("s2:"+s2);
    		in.close();
    	}
    }
    

    上述代码定义了两个字符串类:s1 和 s2。  分别用 in.next()  和 in.nextLine() 输入。

    结果如下:

     in.next()将从缓冲区内接收了abc赋值给了s1 , 遇到空格后停止,缓冲区内还剩下了一个空格和qwe ,in.nextLine()将缓冲区剩下的字符赋值给 s2。

    类比scanf和gets。

     

    (2) hasNext()方法  

    in.hasNext用法:

    in.hasNext()的返回值是bool值,作用是当在缓冲区内扫描到字符时,会返回true, 否则会发生阻塞,等待数据输入。

    所以in.hasNext()是不会返回false的

    所以遇到多组输入时,可以使用 while + in.hasNext() 相当于 while(scanf())

    如:每次输入三个整数,输出三数之和。

    import java.util.Scanner;
    
    public class Main1 {
    	public static void main(String[] args){
    		Scanner in = new Scanner(System.in);	
    		int a, b, c; 
    		while(in.hasNext()){	
    		    a = in.nextInt();
    		    b = in.nextInt();
    		    c = in.nextInt();
    		    System.out.printf("%d\n",a+b+c);
    		}
    	}
    }
    

    和in.nextXXX()方法类似,in.hasNextXXX()也有针对不同类型变量的方法。

    如:

    in.hasNext() // 判断缓存区中还有没有数据,有返回true, 否则等待输入。
    in.hasNextInt() // 判断输入的是不是int型的数据,是的话返回true 否则继续扫描缓冲区,或者等待输入。
    in.hasNextDouble() // 判断输入的是不是double型的数据,是的话返回true 否则继续扫描缓冲区,或者等待输入。

     

     


    2.2 输出

            java中往控制台输出的几种常用函数

    System.out.printf(); //和C/C++中的printf一样。 可使用格式控制符进行格式化输出。
    // 例如: 输出一个int类型变量  System.out.printf("%d",a);
    System.out.print() //不能使用格式控制符进行格式化输出,仅输出变量
    System.out.println() //不能使用格式控制符进行格式化输出,仅输出变量,但会自动输出一个换行。

     

    3 快速输入输出

       (不想看函数介绍的,可以直接看最下面的程序实例)

      3.1使用StreamTokenizer 和 PrintWriter实现快速输入输出 (非推荐)

    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    

       这种方式只能读取数字和字母字符串, 不能读取空格和其他字符。

    实例1:

    import java.io.*;
     
    public class Main {
        public static void main(String[] args) throws IOException {
            //快速输入  
            StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
            //快速输出
            PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
            while(in.nextToken() != StreamTokenizer.TT_EOF){
                int a = (int)in.nval; // 获取一个整型数据
                in.nextToken();  //从流中获取下一个数据, 相当于scanf()读入一个数据然后存在缓存区
                String s=in.sval; //  获取一个字符串  
                in.nextToken();
                double n=in.nval;
                out.println(n);
                out.flush();//将输出缓冲区清空。
            }  
        }
    }

      PrintWriter类中 包含 print()  printf()  writer() 方法    printf()可用于格式化输出  但速度是最慢的  write()的速度是最快的

      注意要在最后刷新输出缓冲区, 就是记得加上  out.flush()  否则会什么也不输出

     3.2 使用BufferedReader和BufferedWriter实现快速输入输出(推荐)

    BufferedReader 和 BufferedWriter 都在 java.io.*包内。

    BufferedReader

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

    成员方法
    方法                                                   描述
    int read()                                            读取单个字符。
    int read(char[] cbuf, int off, int len)     将字符读入数组的某一部分。
    String readLine()                                读取一个文本行。
    long skip(long n)                                 跳过字符。
    boolean ready()                                  判断此流是否已准备好被读取。
    void close()                                         关闭该流并释放与之关联的所有资源。
    void mark(int readAheadLimit)           标记流中的当前位置。
    boolean markSupported()                   判断此流是否支持 mark() 操作(它一定支持)。
    void reset()                                          将流重置到最新的标记。

    主要使用read() 和 readLine()

    String s = in.read() // 读入一个字符 可读入空格回车 但不抛弃回车
    String s1 = in.readLine(); // 读入一行 可读入空格可读入回车 但会将回车抛弃
    string s2[] = in.readLine().Split(" "); // 使用Split通过空格分割读入的一行字符串,存在s2中

    需要注意的是 在windows中按一下回车键 一共有两个字符 "\n\r"  而read()只能读取一个字符所以如要要用read来达到吸收回车的目的,需要用两个read();  如果用readLine()的话会将"\n\r"全部吸收 , 所以只需要一个readLine()来吸收回车。

    详见下面实例2.


     

    BufferedWriter

    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

    主要使用 BufferedWriter类中的 write() 类进行输出。 当数据量大的时候一定要使用这个类进行输出,谨记!

      需要注意的是 write() 不能直接输出int类型, 因为write(int a)  会输出其对应的ASCii码的字符 ,比如输出 65 会显示 A 详见代码:

    int a = 65;
    char b = '2';
    String c = "3";
    
    out.write(a);
    out.write("\n");
    out.write(b);
    out.write("\n");
    out.write(c);
    out.write("\n");
    out.flush();
    
    输出:
    A
    2
    3
    

     

    所以当需要输出一个int类型的变量时, 可以用Integer.toString(int a)方法 将其变为字符串形式输出。

    或者使用 + 拼接一个字符串,这样 参数整体就是一个字符串了,比如加一个换行符。详见代码:

    int a = 65;
    
    out.write(a + "\n");
    out.write(Integer.toString(a));
    out.flush();
    
    输出:
    65
    65

     

    实例2:

    import java.io.*;
    import java.util.*;
    
    
    public class Main{
        static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        public static void main(String[] args) throws IOException{
            //测试writr 不能直接输出int类型
        	int a = 65;
            out.write(a);
            out.write("\n");
        	out.write(a + "\n");  // 使用 + 号拼接个字符串 使参数整体为一个字符串 
            out.write(Integer.toString(a)); // 输出a的字符串形式
            out.write("\n");
           
            //测试 read() 和  readLine();
            int b = in.read();   // read()只读取一个字符
            int c = in.read();   // 吸收 \n
            int x = in.read();   // 吸收 \r
           // String e = in.readLine();
            String d = in.readLine();
            out.write("\n");
            out.write(b + "\n");
            out.write(c + "\n");
            out.write(x + "\n");
            out.write(d + "\n");
            //out.write(e);
            out.flush();
        }
    }

     输出:

    一共输入了:

    1  (按回车键)

    ABC  DEF 

    然后下面输出了

    49(1的ASCii码)

    13(回车键的ACSii码)

    10 (换行键的ASCII码) 

    ABC  DEF

    展开全文
  • Java输入输出

    万次阅读 多人点赞 2018-05-12 15:27:45
    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!! 1.输入格式,输出格式控制 1.1输入处理 java的...

    源代码见:点击打开链接

    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!!

    1.输入格式,输出格式控制

    1.1输入处理

        java的输入,我们用到Scanner类,可以用它创建一个对象

        Scanner reader=new Scanner(System.in);

        然后reader对象调用nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()方法来从输入流中获取数据。这些方法在执行时都会阻塞,程序等待用户在输入流中输入enter键(\n)时继续执行。这里的nextInt,hasNextInt()这些方法的调用,会判断当前字节流里面是否有东西,没有就阻塞等待输入直到用户按enter键(\n)结束输入,在Scanner类中有一个变量needInput,当需要读取数据时,needInput=true(也就是调用nextInt,hasNextInt()这些函数的时候)。有一个readInput方法,当字节流中有东西可读时,让needInput=false(表示不需要阻塞等待输入);下面是Scanner.class源码:

     // Tries to read more input. May block.
        private void readInput() {
            if (buf.limit() == buf.capacity())
                makeSpace();
    
            // Prepare to receive data
            int p = buf.position();
            buf.position(buf.limit());
            buf.limit(buf.capacity());
    
            int n = 0;
            try {
                n = source.read(buf);//这儿
            } catch (IOException ioe) {
                lastException = ioe;
                n = -1;//这儿
            }
    
            if (n == -1) {
                sourceClosed = true;
                needInput = false;//这儿
            }
    
            if (n > 0)
                needInput = false;/这儿
    
            // Restore current position and limit for reading
            buf.limit(buf.position());
            buf.position(p);
        }
    

        总之,在调用next(),hasNext()方法时,字节流里面有东西,就不用等待,没有东西就阻塞等待。例如:

    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner s=new Scanner(System.in);
    		int a,b;
    		a=s.nextInt();
    		System.out.println(a);
    		b=s.nextInt();
    		System.out.println(b);
    		/*a=s.nextInt();
    		b=s.nextInt();
    		System.out.println(a+"  "+b);*/
    	}

        当在命令行时输入时,我可以这样输入(在一行就输入两个数据再按enter),当运行到b=s.nextInt()时,发现字节流里面有东西,就没有阻塞等待输入了。

        当然我们也可以这样输入(第一行输入2后,按enter键,然后在输入3,再按enter键)。运行过程是这样的,首先,当运行到a=s.nextInput()时发现,字节流里面没东西,等待输入,于是我们在命令行的第一行输入了2,按回车确认,这时程序继续执行。当运行到b=s.nextInt()时,发现字节流里面没东西,则阻塞等待输入,于是我们在命令行第三行输入3,按enter键确认,程序继续执行。

        Scanner 使用分隔符模式将其输入分解为标记,默认情况下该分隔符模式与空白匹配(当然可以自定义分隔符)。

         在下面1.3中我们举一个输入控制实例来熟练输入控制的使用。

     

    1.2 hasNext源码解析

    首先我们分输入源是System.in(也就是控制台),和从文件中读取(FileInputStream)。

    (1)对于System.in,不管如何都是要返回true的。我们看源码:

            /*这是测试代码*/
            Scanner scanner=new Scanner(System.in);
    
    
            while (scanner.hasNext()){
                System.out.println(scanner.next());
            }

     我们进入hasNext()函数

    
    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*对于从控制台中读入数据,这两句代码是永远不会被执行的。相当于从控制台读入数据永远不会结束,sourceClosed永远为false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

    (2) 从文件中读取(FileInputStream)

     Scanner scanner1=new Scanner(new FileInputStream("/home/fengli/a.txt"));
    
     while (scanner1.hasNext()){
           System.out.println(scanner1.next());
     }

     在进入hasNext()方法:

    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*用文件中读取,sourceClosed就可能为ture。所以这个方法就可以返回false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

     

    1.3 输出处理

        可用System.out.println()或System.out.print()来向屏幕进行输出。jdk1.5新增了和C语言中printf函数类似的数据输出方法,

    System.out.printf(“格式控制部分”,表达式1,表达式2,……,表达式n)

        格式控制部分由格式控制符号:%d,%c,%f,%s和普通字符组成,普通字符原样输出。格式控制符用来输出表达式的值。

        %d:输出int类型数据值

        %c:输出char类型数据

        %f:输出浮点型数据,小数点部分最多保留6位

        %s:输出字符串数据

        %md:输出int型数据占m列

        %m.nf:输出的浮点型数据占m列,小数点保留n位

    格式字符串语法:

        每个格式控制以%开始,以空格或标点符号结尾。

        

     

    1.3输入输出实例--读入指定形状,输出指定形状

        实例为输出九九乘法表,源码如下:

    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		for(int i=1;i<=9;i++)
    		{
    			for(int j=1;j<=i;j++)
    			{
    				System.out.printf("%2d X%2d=%3d ",j,i,i*j);
    			}
    			System.out.println();
    		}
    	}
    }

        运行结果:

    2.从文件输入,输出

    2.1实现方法

        可通过重定向标准输入输出流的方法来实现从文件中输入输出数据。具体使用到的方法如下:

        

    static void setIn(InputStream in)//重定向标准输入
    static void setOut(PrintStream out) //重定向标准输出

       

    2.2从文件输入输出实例--拷贝

        通过重定向的方法,实现从一个文件拷贝东西到另外一个文件。

        代码如下:

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    import java.util.Scanner;
    
    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		/*
    		 * FileInputStream里面的路径可以写绝对路径又可以写相对路径,为了程序的移植性,推荐使用相对路径,相对路径
    		 * 的根路径是Copy
    		 */
    		FileInputStream fis = null;
    		PrintStream fos=null;
    		try {
    			fis = new FileInputStream("src/source");
    			fos=new PrintStream("src/dest");
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.setIn(fis);//重定向标准输入
    		
    		//接下来就和从标准输入流读入数据一样了
    		Scanner sc = new Scanner(System.in);
    		String s=sc.nextLine();
    		System.out.println(s);
    		
    		//重定向输出流
    		System.setOut(fos);
    		
    		//接下来就和从标准输出流读入数据一样了
    		System.out.println(s);
    	}
    
    }
    

     

     

     

     

     

     

     

     

     

    展开全文
  • Java IO流学习总结一:输入输出

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

    万次阅读 多人点赞 2017-09-09 20:43:12
    输入输出的重要性: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;输入和输出功能是Java对程序处理数据能力的提高,Java以流的形式处理数据。流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。...
  • C语言输入输出语句

    万次阅读 2018-04-27 13:54:03
    一:控制台输入输出 (1)字符数据的输入/输出 字符输出 putchar(ch); 字符输入 getchar(ch); (2)格式化输入/输出 格式输出 printf(“格式控制字符串”,输出列表); 格式输入 scanf(“格式控制字符...
  • 在C语言中怎样定义一个字符串并输入输出

    万次阅读 多人点赞 2018-02-28 16:57:29
    在C语言中没有字符串类型,用字符数组处理字符串 ...输入输出方法:逐个字符输入输出:%c 整个字符串输入输出:%s 一 :用scanf输入字符串,printf输出字符串  逐个字符处理: #include int main()
  • C++输入输出

    万次阅读 多人点赞 2019-06-11 20:46:05
    在C++的标准库中,将用于进行数据输入输出的类统称为”流类“。cin是流类istream的对象,cout是流类ostream的对象。要使用流类,需要在程序中包含iostream头文件。 C++中常用的几个流类及其2相互关系: 图1中的...
  • 本文介绍终端里的输入输出重定向.
  • 输入输出重定向

    万次阅读 2018-06-10 09:59:00
    输入输出重定向 当我们求解acm题目时,通常在设计好算法和程序后,要在调试环境(例如VC等)中运行程序,输入测试数据,当能得到正确运行结果后,才将程序提交到oj中。但由于调试往往不能一次成功,...
  • 请问OJ测试代码时是如何输入输出的?C语言如何实现多组数据的输出?比如这道题 “水仙花数”是指一个三位数,它的各位数字的立方和等于其本身,比如:153=1^3+5^3+3^3。 现在要求输出所有在m和n范围内的水仙花数。 ...
  • Java常用的输入输出语句

    万次阅读 多人点赞 2018-07-06 13:29:34
    对于经常上机刷题的来说,首先得解决输入输出方法,Java的输入输出流在Java学习过程的后面部分才会接触,但是我们可以掌握一些简单的,常用的输入输出方法首先输出大家最熟悉的莫过于输出方法,直接用System.out....
  • C语言 基本输入输出函数

    千次阅读 多人点赞 2018-06-01 14:44:11
    1 几组常见的输入输出函数在stdio.h头文件中内置了几种输入输出函数,如下列出:printf 与 scanfgetchar 与 putchargets 与 puts相比之下 printf 与 scanf的功能最为强大,但操作稍显复杂,后两种则功能简单,但针对...
  • Python输入输出详解

    万次阅读 2014-04-19 22:54:46
    Python基本输入输出教程 python内置输入函数 python2输入 raw_input() python3输入 先在交互式解释器中查看input函数 input(...) input([prompt]) -> string Read a s...
  • python 标准输入输出

    千次阅读 2019-03-27 11:51:39
    标准输入输出 能够使用 input 函数通过键盘输入数据到程序中 能够使用print函数完成字符串信息的动态输出打印 能够完成输入输出版计算圆面积的案例 输入 1.1 概念 用户通过控制台将数据传递给程序的过程 1.2 语法...
  • c语言输入输出格式

    万次阅读 多人点赞 2018-06-11 20:39:58
    //最近被某题的输入输出卡了。。。转一波随时看。。。菜哭&lt;span style="font-family:KaiTi_GB2312;font-size:18px;"&gt;本小节介绍的是向标准输出设备显示器输出数据的语句。在C语言中,所有...
  • 输入输出外挂总结

    万次阅读 多人点赞 2016-05-22 05:06:28
    明明在C语言中有scanf()、printf(),C++中有cin、cout,为什么我们还要用输入输出外挂呢? 这个问题很明显,一定是因为这些输入输出函数功能过于强大而导致效率低,(很多时候,功能越强大的东西越臃肿),而我们...
  • 11. Shell 输入输出重定向

    万次阅读 2019-08-27 16:14:03
    Shell 默认的输入为键盘输入, 默认输出则是终端的Shell 窗口....Linux 下一切皆文件, 输入输出也不例外.虽然标准输入时键盘输入, 标准输出为终端显示器,但是在linux 中标准输入输出也对应着响应的文件...
  • C/C++标准输入输出与文件输入输出

    万次阅读 2013-09-29 17:41:55
    C语言输入输出函数有很多,标准I/O函数中包含了如下几个常用的函数: 标准输入输出: 1. scanf, printf int scanf(const char *format, arg_list) scanf主要从标准输入流中获取参数值,format为指定的参数...
  • Scala:输入输出

    千次阅读 2016-10-23 16:37:51
    http://blog.csdn.net/pipisorry/article/details/52902694Scala基本输入输出从屏幕上读取用户输入有时候我们需要接收用户在屏幕输入的指令来处理程序。实例如下:object Test { def main(args: Array[String]) { ...
  • C语言如何输入输出一个字符串

    万次阅读 多人点赞 2019-03-28 22:41:50
    C语言习题中,经常遇到字符串的输入输出,我们在这里简单总结一下字符串的输入输出方式。 C语言中用一般用数组来处理字符串,这里暂时讨论一维数组的输入输出,二维之后再加上。 定义:char 数组名[常量] 输入输出:...
  • c语言文件输入输出

    万次阅读 2017-09-30 11:28:41
    重定向的方法写起来简单、自然,但是不能同时读写文件和标准输入输出;fopen的写法稍有繁琐,但是灵活性比较大(例如可以重复打开并读写文件)。如果想把fopen版的程序改成读写标准输入输出,只需要赋值“fin=stdin;...
  • 字符数组的输入输出

    万次阅读 多人点赞 2018-09-15 19:03:31
    字符数组的输入输出 1. scanf 输入,printf 输出 scanf 对字符类型有 %c 和 %s 两种格式(printf 同理,下同),其中 %c 用来输入单个字符,%s 用来输入一个字符串并存在字符数组里。%c 格式能识别 空格 跟 换行...
  • Java输入输出流详解

    万次阅读 多人点赞 2017-06-17 21:15:21
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出...
  • 输入输出
  • 【题目】keras中Flatten层的用法及输入输出shape(附查看网络结构输入输出的查看技巧)   一、Flatten层 Flatten层的实现在Keras.layers.core.Flatten()类中。 功能: Flatten层用来将输入“压平”,即把多维的...
  • C语言中输入输出所有格式控制符

    千次阅读 2020-01-16 19:34:54
    title: C语言中输入输出所有格式控制符 date: 2020-01-16 17:02:06 description: C语言输入输出的所有格式控制详解 C语言中输入输出所有格式控制符  最近在重温C语言,发现C语言的输入输出函数scanf和printf函数在...
  • ACM 输入输出

    千次阅读 2011-05-09 17:02:00
    关于ACM的输入输出(一) 写给第一次参加现场赛的同学们 一般来说ACM的现场赛会规定输入输出 或者是文件输入标准输出 也可能是文件输入文件输出 如果没有规定的话那么一般就是标准的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 815,530
精华内容 326,212
关键字:

输入输出