精华内容
下载资源
问答
  • Java输入输出

    万次阅读 多人点赞 2018-05-12 15:27:45
    特此写下这篇博客,一是为了总结输入输出,二是为了大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!! 1.输入格式,输出格式控制 1.1输入处理 java的输入,我们用到Scanner类,可以用它创建一个对象 ...

    源代码见:点击打开链接

    引言:在平时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的常用输入输出语句

    万次阅读 多人点赞 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中数组的输入输出

    万次阅读 多人点赞 2019-08-15 15:28:59
    数组的输入 首先声明一个int型数组 int[] a 或者 int a[] 给数组分配空间 a=new int[10]; 声明连起来就是int[] a=new int[10]; 或者是 int a[]=new int[10]; 给数组赋值 a[0]=1;//0代表的是数组的第1个...

    数组的输入

    首先声明一个int型数组

    int[] a 或者 int a[]

    给数组分配空间

    a=new int[10];
    和声明连起来就是int[] a=new int[10]; 或者是 int a[]=new int[10];

    给数组赋值

    a[0]=1;//0代表的是数组的第1个元素 ,元素下标为0
    a[1]=1;//1代表的是数组的第2个元素 ,元素下标为0

    访问数组数据 ,使用数组下标访问       c=a[4];

    数组声明缩写

    int[ ] a={12,3,4,8,5,6,6,7,8,8,9,8};
    int [ ]  a1=new int[ ]{12,3,4,8,5,6,6,4};

    new int[ ]的[ ]一定不能放内存大小

    使用循环给数组赋值

    示例为

     int[ ]  arr=new int[5];
         for (int i = 0; i < arr.length; i++) {
                System.out.println("数组第"+(i+1)+"个值为"+i);
             }

    使用循环输入数组

    int a[]=new int[110];
    for(int i=1;i<=n;i++)
    {
    a[i]=in.nextInt();
    }

    数组的输出

    定义一个数组

    int[] array = {1,2,3,4,5};

    (1)传统的for循环方式

    for(int i=0;i<array.length;i++)  
    {  
          System.out.println(a[i]);  
    }  

    (2)for each循环

    for(int a:array)  
        System.out.println(a);  

    (3)利用Array类中的toString方法

    调用Array.toString(a),返回一个包含数组元素的字符串,这些元素被放置在括号内,并用逗号分开

    int[] array = {1,2,3,4,5};  
    System.out.println(Arrays.toString(array));  

    输出:[1, 2, 3, 4, 5]

    说明:System.out.println(array);这样是不行的,这样打印是的是数组的首地址。

    二维数组:

    对于二维数组也对应这三种方法,定义一个二维数组:

    int[][]magicSquare =  
         {  
             {16,3,2,13},  
             {5,10,11,8},  
             {9,6,7,3}  
         };  

    Java实际没有多维数组,只有一维数组,多维数组被解读为"数组的数组",例如二维数组magicSquare是包含{magicSquare[0],

    magicSquare[1],magicSquare[2]}三个元素的一维数组,magicSqure[0]是包含{16,3,2,13}四个元素的一维数组,同理

    magicSquare[1],magicSquare[2]也一样。

    (1)传统的for循环方式

    for(int i=0;i<magicSquare.length;i++)  
         {  
             for(int j=0;j<magicSquare[i].length;j++)  
             {  
                 System.out.print(magicSquare[i][j]+" ");  
             }  
             System.out.println();  //换行  
         }  

    (2)for each循环

    for(int[] a:magicSquare)  
         {  
             for(int b:a)  
             {  
                 System.out.print(b+" ");  
             }  
             System.out.println();//换行  
         }  

    (3)利用Array类中的toString方法

    for(int i=0;i<magicSquare.length;i++)  
        System.out.println(Arrays.toString(magicSquare[i]));  

     

    展开全文
  • 详解Java输入输出

    万次阅读 多人点赞 2018-07-02 10:05:11
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,...

    通过数据流、序列化和文件系统提供系统输入和输出。

    Java把这些不同来源和目标的数据都统一抽象为数据流。Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。

    在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流。

    1.1、Java流的分类

    按流向分:

    输入流: 程序可以从中读取数据的流。
    输出流: 程序能向其中写入数据的流。

    按数据传输单位分:

    字节流: 以字节为单位传输数据的流
    字符流: 以字符为单位传输数据的流

    按功能分:

    节点流: 用于直接操作目标设备的流
    过滤流: 是对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能。

    1.2、java.io常用类

    JDK所提供的所有流类位于java.io包中,都分别继承自以下四种抽象流类:

    InputStream:继承自InputStream的流都是用于向程序中输入数据的,且数据单位都是字节(8位)。
    OutputSteam:继承自OutputStream的流都是程序用于向外输出数据的,且数据单位都是字节(8位)。
    Reader:继承自Reader的流都是用于向程序中输入数据的,且数据单位都是字符(16位)。
    Writer:继承自Writer的流都是程序用于向外输出数据的,且数据单位都是字符(16位)。

     

    java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流....本文的目的是为大家做一个简要的介绍。

     

      流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样,如下图:

                                

                                    

     Java中的流分为两种,一种是字节流,另一种是字符流,分别由四个抽象类来表示(每种流包括输入和输出两种所以一共四个):InputStream,OutputStream,Reader,Writer。Java中其他多种多样变化的流均是由它们派生出来的:

    stream代表的是任何有能力产出数据的数据源,或是任何有能力接收数据的接收源。在Java的IO中,所有的stream(包括Inputstream和Out stream)都包括两种类型:

      (1)字节流

      表示以字节为单位从stream中读取或往stream中写入信息,即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据,如图象和声音。

      (2)字符流

      以Unicode字符为导向的stream,表示以Unicode字符为单位从stream中读取或往stream中写入信息。

      区别:

      Reader和Writer要解决的,最主要的问题就是国际化。原先的I/O类库只支持8位的字节流,因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode字符),这样加了Reader和Writer之后,所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。

      但是,Read和Write并不是取代InputStream和OutputStream,有时,你还必须同时使用"基于byte的类"和"基于字符的类"。为此,它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader,而OutputStreamWriter则将OutputStream转化成Writer。

      一.流的层次结构

      定义:

      (1)       java将读取数据对象成为输入流,能向其写入的对象叫输出流。结构图如下:

                                                    输入流

     

                                                     输出流

     

     二.InputStream类

      inputstream类和outputstream类都为抽象类,不能创建对象,可以通过子类来实例化。

      InputStream是输入字节数据用的类,所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法:

      (1)       public abstract int read( ):读取一个byte的数据,返回值是高位补0的int类型值。

      (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( ) :我们在使用完后,必须对我们打开的流进行关闭.

      三.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. 上述各方法都有可能引起异常。

      2. InputStream和OutputStream都是抽象类,不能创建这种类型的对象。

      四.FileInputStream类

      FileInputStream类是InputStream类的子类,用来处理以文件作为数据输入源的数据流。使用方法:

      方式1:

      File fin=new File("d:/abc.txt");

      FileInputStream in=new FileInputStream(fin);

      方式2:

      FileInputStream in=new

      FileInputStream("d: /abc.txt");

      方式3:

      构造函数将 FileDescriptor()对象作为其参数。

      FileDescriptor() fd=new FileDescriptor();

      FileInputStream f2=new FileInputStream(fd);

      五.FileOutputStream类

      FileOutputStream类用来处理以文件作为数据输出目的数据流;一个表示文件名的字符串,也可以是File或FileDescriptor对象。

      创建一个文件流对象有两种方法:

      方式1:

      File f=new File("d:/abc.txt");

      FileOutputStream out=new FileOutputStream (f);

      方式2:

      FileOutputStream out=new

      FileOutputStream("d:/abc.txt");

      方式3:构造函数将 FileDescriptor()对象作为其参数。

      FileDescriptor() fd=new FileDescriptor();

      FileOutputStream f2=new FileOutputStream(fd);

    方式4:构造函数将文件名作为其第一参数,将布尔值作为第二参数。

      FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

      注意:

      (1)文件中写数据时,若文件已经存在,则覆盖存在的文件;(2)的读/写操作结束时,应调用close方法关闭流。

      举例:2-1

      六.File类

      File类与InputStream / OutputStream类同属于一个包,它不允许访问文件内容。

      File类主要用于命名文件、查询文件属性和处理文件目录。

      举例:2-2

      七.从一个流构造另一个流

      java的流类提供了结构化方法,如,底层流和高层过滤流。

      而高层流不是从输入设备读取,而是从其他流读取。同样高层输出流也不是写入输出设备,而是写入其他流。

      使用"分层对象(layered objects)",为单个对象动态地,透明地添加功能的做法,被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象,都必须具有与之完全相同的接口。这使得decorator的用法变得非常的透明--无论对象是否被decorate过,传给它的消息总是相同的。这也是Java I/O类库要有"filter(过滤器)"类的原因:抽象的"filter"类是所有decorator的基类。Decorator模式常用于如下的情形:如果用继承来解决各种需求的话,类的数量会多到不切实际的地步。Java的I/O类库需要提供很多功能的组合,于是decorator模式就有了用武之地。

      为InputStream和OutputStream定义decorator类接口的类,分别是FilterInputStream和FilterOutputStream。

     

    FilterInputStream的种类

     

     

     

     

     

    功能

     

     

    构造函数的参数

     

     

     

     

    用法

     

     

     

     

    DataInputStream

     

     

    与DataOutputStream配合使用,这样你就能以一种"可携带的方式(portable fashion)"从流里读取primitives了(int,char,long等)

     

     

    InputStream

     

     

     

     

    包含了一整套读取primitive数据的接口。

     

     

     

     

    BufferedInputStream

     

     

    用这个类来解决"每次要用数据的时候都要进行物理读取"的问题。你的意思是"用缓冲区。"

     

     

    InputStream,以及可选的缓冲区的容量

     

     

     

     

    它本身并不提供接口,只是提供一个缓冲区。需要连到一个"有接口的对象(interface object)"。

     

     

     

     

    LineNumberInputStream

     

     

    跟踪输入流的行号;有getLineNumber( )和setLineNumber(int)方法

     

     

    InputStream

     

     

     

     

    只是加一个行号,所以还得连一个"有接口的对象"。

     

     

     

     

    PushbackInputStream

     

     

    有一个"弹压单字节"的缓冲区(has a one byte push-back buffer),这样你就能把最后读到的那个字节再压回去了。

     

     

    InputStream

     

     

     

     

    主要用于编译器的扫描程序。可能是为支持Java的编译器而设计的。用的机会不多。

     

    FilterOutputStream的种类

     

     

     

     

     

    功能

     

     

    构造函数的参数

     

     

     

     

    用法

     

     

     

     

    DataOutputStream

     

     

    与DataInputStream配合使用,这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)

     

     

    OutputStream

     

     

     

     

    包括写入primitive数据的全套接口。

     

     

     

     

    PrintStream

     

     

    负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储,而PrintStream负责数据的显示。

     

     

    一个OutputStream以及一个可选的boolean值。这个boolean值表示,要不要清空换行符后面的缓冲区。

     

     

     

     

    应该是OutputStream对象的最终包覆层。用的机会很多。

     

     

     

     

    BufferedOutputStream

     

     

    用 这个类解决"每次往流里写数据,都要进行物理操作"的问题。也就是说"用缓冲区"。用flush( )清空缓冲区。

     

     

    OutputStream, 以及一个可选的缓冲区大小

     

     

     

     

    本身并不提供接口,只是加了一个缓冲区。需要链接一个有接口的对象。

      DataInputStream类对象可以读取各种类型的数据。

      DataOutputStream类对象可以写各种类型的数据;

      创建这两类对象时,必须使新建立的对象指向构造函数中的参数对象。例如:

      FileInputStream in=new FileInputStream("d:/abc.txt");

      DataInputStream din=new DataInputStream(in);

      7.2BufferInputStream和bufferOutputStream

      允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。

      BufferInputstream定义了两种构造函数

      (1)       BufferInputStream b= new BufferInputstream(in);

      (2)       BufferInputStream b=new BufferInputStream(in,size)

      第二个参数表示指定缓冲器的大小。

      同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。

      7.3printstream

      用于写入文本或基本类型

      两种构造函数方法:

      PrintStream ps=new PrintStream(out);

      PrintStream ps=new PrintStream(out, autoflush)

      第二个参数为布尔值,控制每次输出换行符时java是否刷新输出流。

      八.字符流的读取和写入

      java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入16位字符,也就是 Unicode 编码的字符;而 InputStream 用于读入 ASCII 字符和二进制数据。

     

                                        Reader 体系结构

    (1)       FileReader

      FileReader主要用来读取字符文件,使用缺省的字符编码,有三种构造函数:

      --将文件名作为字符串

      FileReader f=new FileReader(“c:/temp.txt”);

      --构造函数将File对象作为其参数。

      File f=new file(“c:/temp.txt”);

      FileReader f1=new FileReader(f);

      --构造函数将FileDescriptor对象作为参数

      FileDescriptor() fd=new FileDescriptor()

      FileReader f2=new FileReader(fd);

      (2)    charArrayReader

      将字符数组作为输入流,构造函数为:

      public CharArrayReader(char[] ch);

      (3)    StringReader

      读取字符串,构造函数如下:

      public StringReader(String s);

      (4)    InputStreamReader

      从输入流读取字节,在将它们转换成字符。

      Public inputstreamReader(inputstream is);

      (5)    FilterReader

      允许过滤字符流

      protected filterReader(Reader r);

    (6)    BufferReader

      接受Reader对象作为参数,并对其添加字符缓冲器,使用readline()方法可以读取一行。

      Public BufferReader(Reader r);

                                          Writer类体系结构

        (1)     FileWrite

      将字符类型数据写入文件,使用缺省字符编码和缓冲器大小。

      Public FileWrite(file f);

      (2)chararrayWrite()

      将字符缓冲器用作输出。

      Public CharArrayWrite();

      (3)    PrintWrite

      生成格式化输出

      public PrintWriter(outputstream os);

      (4)    filterWriter

      用于写入过滤字符流

      protected FilterWriter(Writer w);

    展开全文
  • Java输入输出流详解

    万次阅读 多人点赞 2017-06-17 21:15:21
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出...
  • Java 数组的输入输出

    万次阅读 多人点赞 2017-03-02 12:01:01
    Java中要对控制台进行输入操作的话要调用Scanner类,定义一个扫描的对象,例://要导入java.util.Scanner; Scanner scanner = new Scanner(System.in);这样便打开了输入流,接下来定义数组:int[] n = new int[4];//...
  • java输入数字输出菱形

    千次阅读 2019-07-20 15:49:10
    java输入数字输出菱形 1、要求 用两个for循环输出一个菱形。 2、代码 import java.util.Scanner; /** * java输入数字输出菱形 * @author com * */ public class Test { static Scanner sc = new Sca.....
  • java数据的输入输出

    千次阅读 2018-10-01 18:24:55
    1.读取输入 要想通过控制台进行数据的输入,首先要构建一个Scanner对象,并与“标准输入流”System.in关联。 Scanner scan=new Scanner(System.in); 构建好后就可以用Scanner类中的各种方法实现输入操作了。 例如...
  • Java输入/输出

    万次阅读 2018-05-06 14:29:58
    文本(Text)输入/输出 输出用PrintWriter类 try-with-resources来自动关闭资源 用Scanner来读取文本 流式处理 二进制(Binary)输入/输出 二进制输入/输出到文件 FilterInputStream/FilterOutputStream ...
  • java输入输出流实例代码

    万次阅读 2016-12-22 14:25:26
    1.编写一个程序,读取源代码文件的内容并在控制台输出。如果源文件不存在,则显示相应的错误信息。 package src; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import...
  • java输入输出流的简单入门

    万次阅读 多人点赞 2019-03-30 19:17:24
    程序在运行期间可能需要从外部的存储媒介或其他程序中读取所需要的数据,这就需要使用输入流,输入流的指向称为它的源;另一方面,程序在处理数据后,可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用...
  • Java 输入输出流】

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

    千次阅读 2020-07-05 19:42:52
    java输入输出 目录 一、控制台输入输出 二、文件读写 一、控制台输入输出  java控制台的输入输出主要依赖于scanner类,使用Scanner scanner=new Scanner(System.in)获取了控制台输入的字段,其中system.in就表示这...
  • java基础之java输入输出语句

    千次阅读 2020-12-10 17:36:14
    Java基础学习:java输入输出语句 比如: Java基础学习:java输入输出语句 2、使用BufferedReader 用前需要引入importjava.io.Reader; Java基础学习:java输入输出语句 比如: Java基础学习:java输入输出语句 ...
  • JAVA基础知识常用算法合集: https://blog.csdn.net/GD_ONE/article/details/104061907 目录 1.主类的命名必须是Main 2.输入输出: 2.1输入: (1)使用Scanner类进行输入 (2) hasNext()方法 2.2输出 3快速...
  • JAVA笔试——输入输出集锦

    千次阅读 2019-06-17 20:09:53
    1.输入 Scanner reader = new Scanner(System.in) ; 读一个整数 int n = sc.nextInt(); 读一个字符串 String s = sc.next(); 读一个浮点数 double t = sc.nextDouble(); 读一整行 String s = sc....
  • Java输入/输出——File类详解

    千次阅读 2019-02-28 00:39:41
    本文主要讲述了Java输入和输出(IO)方面的内容,IO是所有程序都必须的部分,使用输入机制,允许程序读取外部数据(包括来自磁盘、光盘等存储设备的数据)用户输入数据;使用输出机制,允许程序记录运行状态,将...
  • java常见输入输出类型

    千次阅读 2019-04-15 11:00:36
    数组的输入输出 例题1 输入: 一行无序数组 输出:满足条件的最大乘积 inport java.util.Arrays; inport java.util.Scanner; public class Test1 { public static void main(String[] args) { Scanner ...
  • Java - 文件输入和输出 简单方法

    万次阅读 多人点赞 2018-07-10 21:08:39
    java.io.PrintWriter类可用来创建一个文件并向文本文件写入数据。 首先创建一个PrintWriter对象,如下所示: PrintWriter output = newPrintWriter(filename); //若不存在则创建一个新文件 然后,可以调用 ...
  • Java中的输入和输出重定向

    万次阅读 多人点赞 2017-07-28 14:17:31
    可以将这些数据用空格隔开,保存在一个名为input.txt的文本文件中,然后使用Java输入和输出重定向。例如需要循环求和计算,新建一个input.txt的文本文件(数据以0结尾,因为下面的求和运算程序是以0作为程序终止求和...
  • JAVA算法竞赛输入输出专题

    千次阅读 多人点赞 2018-12-23 01:27:00
    小编由于报名了蓝桥杯Java组,所以日常做题从使用C/C++转变成使用Java。在转变的过程中,肯定会遇到很多大大小小的输入输出问题。小编打算总结下来,当做自己学习的材料,也分享给感兴趣的朋友。
  • 摘要:   十二生肖的排序:鼠、牛、虎、兔、龙、蛇、马、羊、猴、鸡、狗、猪 ... 表达式的值 值1匹配上了,需要执行的代码; break; case 值2: 表达式的值 值2匹配上了,需要执行的代码; break; case...
  • 在子类KY4_4中重写了父类的方法print(),在该方法中不仅输出学生的姓名学号,而且还输出学生的学院系。另外,在子类KY4_4中还定义了一个主方法main。首先,在主方法中创建一个父类 KY4_3的对象...
  • java输入语句

    万次阅读 多人点赞 2019-10-02 17:09:54
    java输入语句 import java.util.Scanner;//导入 java.util 包下的 Scanner 类,用来构建Scanner对象 public class TestScanner{ public static void main(String[] args) { Scanner scanner = new Scanner...
  • Java如何实现从键盘输入和输出

    千次阅读 2020-01-20 23:27:01
    1.输入 1.import java.util.Scanner; //首先导入java.util包下的Scanner类 2.Scanner cin =newScanner(System.in); cin为对象名 new开辟空间存储cin进来的东西 Scanner扫描输入文本的类名 ...
  • Java快速输入输出

    千次阅读 2019-01-21 13:26:51
    Java输出和输出真实太慢了!!! 如果需要输入105数量级的数据并输出同样数量级的数据,使用Scanner和System.out耗时将很可能超过1s。为了避免这种输入输出过慢的情况,这里引入Java中比较快的一种输入输出方式。 ...
  • Java输入输出

    千次阅读 2017-11-02 11:54:07
    Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。   ...
  • 【小技巧】【牛客网】【JAVA】在线输入输出练习

    千次阅读 多人点赞 2020-08-08 13:35:12
    1. 一直输入模板 import java.util.*; public class Main{ public static void main(String[] args) { Scanner sc = new Scanner(System.in); while (sc.hasNext()) { //操作 } } } 2. 有组数或者输入个数 ...
  • java 输入数字 输出对应周几

    千次阅读 2017-04-24 09:32:12
    import java.util.Scanner; public class Test { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入一个数字:"); int today=sc.nex

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 977,692
精华内容 391,076
关键字:

java输入和输出

java 订阅