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

    千次阅读 2019-11-14 15:15:23
    JAVA 输入输出

    1 输入输出重定向

     

    FileInputStream inputStream = new FileInputStream("输入文件名");
    System.setIn(inputStream);
    //这个放在下面
    Scanner input = new Scanner(System.in);
    PrintStream outputStream = new PrintStream("输出文件");
    System.setOut(outputStream);
    Scanner input = new Scanner(System.in);

    2 ACM中java快速输入输出 

    P3367 【模板】并查集:https://blog.csdn.net/qq_40794973/article/details/103204372

    https://blog.csdn.net/qq_40794973/article/details/88560643

    java的Scanner 比较慢(出了名的了),如果需要输入10^{5}数量级的数据并输出同样数量级的数据,使用Scanner和System.out耗时将很可能超过1s

    2.1 使用 StreamTokenizer 和 PrintWriter

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

    2.1.1 判断是否到达文件结尾

    Java的while(scanner.hasNext()),或者C的while(scanf("%d",&n)!=EOF)

    while (in.nextToken() != StreamTokenizer.TT_EOF) {
        //
    }

    伊格内修斯和公主四世:http://acm.hdu.edu.cn/showproblem.php?pid=1029

    import java.io.*;
    import java.util.HashMap;
    public class Main {
        public static void main(String[] args) throws IOException {
            // io流包装
            StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
            PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
            //StreamTokenizer.TT_EOF这个是个参数,就是EOF
            while (in.nextToken() != StreamTokenizer.TT_EOF) {
                int n = (int) in.nval;
                // 记录出现次数
                HashMap<Integer, Integer> appears = new HashMap<>();
                int max = 0;
                for (int i = 0; i < n; i++) {
                    in.nextToken();//指向下一个
                    int num = (int) in.nval;
                    if (appears.containsKey(num)) {
                        Integer tempNum = appears.get(num);
                        appears.replace(num, tempNum + 1);
                        if (tempNum >= (n + 1) / 2) {
                            max = num;
                        }
                    }else {
                        appears.put(num, 1);
                    }
                }
                out.println(max);
                out.flush();//刷新,不然max会留在缓冲区
            }
        }
    }

     

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

    千次阅读 2016-09-03 23:29:38
    java字符终端上获取输入有三种方式 1、使用java.io.BufferedReader和java.io.InputStreamReader; 2、java.util.Scanner (JDK版本>=1.5) 3、java.io.Console(JDK版本>=1.6),特色:能不回显密码字符 无论哪种...

    读取终端输入

    在java字符终端上获取输入有三种方式
    1、使用java.io.BufferedReader和java.io.InputStreamReader;
    2、java.util.Scanner (JDK版本>=1.5)
    3、java.io.Console(JDK版本>=1.6),特色:能不回显密码字符
    方法1的示例

    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);
            }
        }
    }

    方法2的示例

    public class Sandbox4 extends Sandbox2{
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);  
            String str = null;
            while(true){
                str = scanner.nextLine(); 
                if(str.equals("END"))break;
                System.out.println(str);
            }
            scanner.close();        
        }
    }

    方法3的示例
    注意,在eclipse等IDE下不能使用这种该方法,因为JVM不是在命令行中被调用,输入输出被重定向了。

    java写标准输出也有如下形式

    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.lang.System.in来创建输入流。
    很多同学问,可不可以改变System.in输入流,比如说从文档输入而非控制台输入。其实是可以的

    import java.lang.*;
    
    public class SystemDemo {
    
       public static void main(String[] args) throws Exception {
    
         // existing file
         System.setIn(new FileInputStream("file.txt"));
    
         // read the first character in the file
         char ret = (char)System.in.read();
    
         // returns the first character
         System.out.println(ret);              
       }
    } 

    实际上,system.in就是一个inputstream类的子孙类的对象。所以,尽管可以这么做,我们也不推荐更改system.in中的默认输入流。

    java io类结构

    主要分为字符流和字节流

    展开全文
  • 深入剖析Java输入输出的那些细节

    前言

    无论是新手入门的命令行输入输出,还是说OJ的读入和输出,离不开基本的IO操作。
    但Java本身由于纯粹的面向对象,输入输出不方便,所以我们倒不妨探讨一番。

    其实输入输出真实是所有学Java的入门者一定要先去学的,但用的越多越能深入地感受到输入输出或多或少的小问题。正所谓“养兵千日,用兵一时”,想要关键时刻一针见血,就必须在平时做好准备。

    Are you ready? OK ~ 那今天我们就来聊聊,我们如何用好Java的输入输出。

    看看Python

    这叫输入:

    n=input()
    

    可以用eval()将输入类型转换成数值类型,用int()转换成整数类型……
    如下:

    n=eval(input())
    

    这叫输出:

    print(n)
    

    看看C++

    cin可以输入:

    cin>>n;
    

    输入还可以用scanf()效率更高

    cout可以输出:

    cout<<n;
    

    输出还可以用printf()效率更高

    Java输出篇

    为什么先谈输出呢?
    显然因为简单啊。

    普通输出流三种输出方式:

    第一种是不换行输出

    int n = 1;
    System.out.print(n);
    

    第二种是换行输出

    System.out.println(n);
    

    第三种是格式化输出

    System.out.printf("%d", n);
    

    还有错误输出流,与上述内容类似:

    第一种是不换行输出

    System.err.print(n);
    

    第二种是换行输出

    System.err.println(n);
    

    第三种是格式化输出

    System.err.printf("%d", n);
    

    Java输出的一些问题

    1. printf();如果格式化不正确,就会爆java.util.IllegalFormatConversionException异常。
    2. 为什么Eclipse/IDEA这样的IDE在爆异常的时候都可能红字和普通字混合?
      异常是err错误流,普通输出是out普通输出流,可能会在IDE里由于线程的问题而混合在一起。
    3. System.in/System.out/System.err是什么?
      根据下面的源码(java.lang.System),可知分别是InputStream、PrintStream对象,err流和out流是同一个类的不同对象。
       public static final InputStream in;
       public static final PrintStream out;
       public static final PrintStream err;`
      
    4. 打印输出的时候会启动IO,所以不建议直接输出,可以用StringBuilder把答案“组织好”再统一输出。
    5. 循环里每次都cout的时候能不输出最后的空格,不需要额外的调整,但System.out.println()输出的时候没有这种考虑,必须自己处理最后一次的结果。我建议可以用builder.append(i).append(" ");builder.toString().trim();,最后消去末尾的一个空格,即可完成所需要的输出。
    6. 格式化打印指定位数小数是常见操作,可用printf()完成任务目标。比如,System.out.printf("%.5f");就是保留五位小数打印浮点数。
    7. ……(留待补充)

    对于第五条,说明一下。我们先写一个测试类,打一下时间戳:

    public class PrintTest {
        public static void main(String[] args) {
            int[] array = new int[100000];
            long time1 = System.currentTimeMillis();
            for (int i = 0; i < array.length-1; i++) {
                System.out.print(array[i] + " ");
            }
            System.out.println(array[array.length-1]);
            long time2 = System.currentTimeMillis();
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < array.length; i++) {
                builder.append(array[i]).append(" ");
            }
            System.out.println(builder.toString().trim());
            long time3 = System.currentTimeMillis();
            System.out.println("策略1的输出时间:" + (time2-time1));
            System.out.println("策略2的输出时间:" + (time3-time2));
        }
    }
    

    除去上面的两行输出,会打印:
    策略1的输出时间:330
    策略2的输出时间:10

    显然,用StringBuilder而不是直接一次接一次的System.out.print(),是正解啦。

    Java输入篇

    记得在学校刚学的时候,第一节课老师就让大家写一下输入输出语句,输出还好,输入就不行了,很多同学不会写。其实我也是在学了很多语法以后才学会的输入啦,下面就来说一说吧。

    其实对初学者的一个困难就是输出可以不必import,但输入则不然,需要import java.io.*,或者import java.util.Scanner,可能不那么容易直接理解。

    一般比较“出名”的处理方式是java.util.Scanner,这倒确实。
    Scanner类可以直接读取一下类型的对象:

    • public String next() → 读取下一个字符串(默认分隔符为Space or Tab or Enter)
    • public String next​(String pattern) → 读取下一个字符串(匹配到的串符合指定的正则表达式)
    • public String next​(Pattern pattern) → 读取下一个字符串(匹配到的串符合指定的正则表达式)
    • public BigDecimal nextBigDecimal() → 读取下一个高精小数(默认十进制)
    • public BigInteger nextBigInteger() → 读取下一个高精整数(默认十进制)
    • public BigInteger nextBigInteger​(int radix) → 读取下一个高精整数(指定进制)
    • public boolean nextBoolean() → 读取下一个布尔值
    • public byte nextByte() → 读取下一个byte整型数值(超容会报错,默认十进制)
    • public byte nextByte​(int radix) → 读取下一个byte整型数值(超容会报错,指定进制)
    • public double nextDouble() → 读取下一个双精度浮点数值(默认十进制)
    • public float nextFloat() → 读取下一个单精度浮点数值(默认十进制)
    • public int nextInt() → 读取下一个int整型数值(超容会报错,默认十进制)
    • public int nextInt​(int radix) → 读取下一个int整型数值(超容会报错,指定进制)
    • public String nextLine() → 读取下一行内容以字符串类型返回(分隔符为Enter)
    • public long nextLong() → 读取下一个long整型数值(超容会报错,默认十进制)
    • public long nextLong​(int radix) → 读取下一个long整型数值(超容会报错,指定进制)
    • public short nextShort() → 读取下一个short整型数值(超容会报错,默认十进制)
    • public short nextShort​(int radix) → 读取下一个short整型数值(超容会报错,指定进制)

    看吧,确实“全能”,不过我们在看到Scanner便捷的同时也应该清醒地认识到其性能的低下。
    Scanner之所以能如此全能,依赖于Java支持的正则表达式,这点可以自行阅读文档或者源码了解,这里不加详细说明。
    我们试想,比如一行这样的数据:
    1 2 555 333333 99 243 ……
    如果说每一次都用scanner.nextInt(),就会慢太多。
    反反复复的IO操作,每次都要判断和处理,很影响效率的。

    比如说在洛谷刷算法题的时候,我一般是用Java,但很多次都被卡死性能,不管怎么优化也不行,最后发现问题就在Scanner身上,那怎么处理呢?

    答案是换BufferedReader,性能大幅提升。

    看下面的代码:

    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    int num = Integer.parseInt(reader.readLine());
    int[] record = new int[num];
    String[] nums = reader.readLine().split("\\s+");
    for (int i = 0; i < num; i++) {
        record[i] = Integer.parseInt(nums[i]);
    }
    reader.close();
    

    这样一段代码就可以先读一个数值,再读剩下一行里大量的数值。
    看似还要开一个String[],但其实都说过了,再慢也慢不过IO,希望大家心里清楚最慢的就是IO了,减少IO是提升性能之道。

    不过,在极其苛刻的情况下,Java是没办法完成的,严重TLE+MLE,哪怕你用了byte这样的也不行,所以就得换C++了。毕竟算法题没必要为Java设计性能指标,不达标也只能认了,Java比起C/C++太慢了。

    Java输入的一些问题

    1. 性能实在不达标,看不对就换BufferedReader,再不行就换C++。
    2. 切记scanner.nextInt()之后没换行,此时如果读一行scanner.nextLine()可能只读到空字符串——"",导致后续崩盘。所以遇到单行单个数值+单行多数值的情况,就直接先用Integer.parseInt(scanner.nextLine());再用String[] array = scanner.nextLine().split("\s+");,把String[]转成int[]即可(切记不可直接强转,二者毫无关系)。
    3. IO真的是最慢的,千万别多次IO。宁可处理麻烦点也别贪图省代码。
    4. 使用完输入流后记得关闭,这是一个好习惯。用scanner,就写scanner.close(); ,用reader,就写reader.close();
    5. 输入流关闭之后就不能再用了,这点要注意,在最后用完之后关闭就好。
    6. java.util.Scanner不需要处理异常,java.io.BufferedReader需要处理java.io.IOException,要么try…catch…finally,要么throws,不处理是不能通过编译的。当然啦,自动关闭资源的try语句也挺好的。
    7. ……
    展开全文
  • java输入输出

    千次阅读 2016-12-15 09:51:09
    java输入输出流一、什么是IOjava中I/O操作主要指使用java进行输入、输出操作。java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。 java.io是大多数面向数据流的输入/输出...
  • JAVA输入输出流学习心得

    千次阅读 2017-12-13 21:26:07
    JAVA输入输出流本文主要从以下几个方面总结JAVA输入输出流1.什么是流?什么是输入输出流? 2.字节流与字符流 3.Scanner什么是流?举个例子,水龙头里流出的水流就是流。从水龙头里流出,就叫输出流;从水龙头里...
  • Java快速输入输出使用详解 一、背景:   Scanner类输入时,输入效率比较慢,输入数据大于10^5左右时(你觉得数据有点多时就用快速输入即可),某些题目会超时。所以需要输入快一点的方法。   一般情况下输入数据...
  • java输入输出(快速)

    千次阅读 2014-09-28 10:17:10
    java输入输出(快速)
  • Java输入输出

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

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

    千次阅读 2018-08-05 18:10:28
    下面列出几种常用的输入输出方式。(输出统一用printwriter,系统的system.out太慢,结尾要释放缓存才能输出,不然数据放在缓存中输不出来) 1:Scanner 这个类最慢,但是最好用,因为这个类没有缓存处理,所以io...
  • JAVA输入输出(IO)之字符流

    千次阅读 2015-12-30 11:10:08
    上一篇《JAVA输入输出(IO)之字节流》介绍了JAVA字节输入输出流的一些用法,字节流一般是用于读写二进制数据的,当我们要读些字符数据的时候,如文本文件,就显得有些麻烦。所以JAVA还提供了专门用于读写字符数据的...
  • java输入输出流详解

    千次阅读 2016-07-03 22:03:57
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,...
  • Java输入输出数据流

    千次阅读 2017-12-15 08:48:51
    目录(?)[+]1什么是IO 2数据流的基本概念 1 数据流2 输入流Input Stream 3 输出流数据流...命令行参数标准输入输出数据流4javaIO层次体系结构 5 非流式文件类–File类 6 JavaIO流类库 io流的四个基本类io流的具体分类
  • java io (java输入输出流)详解

    千次阅读 2016-04-10 14:54:16
    java io 输入输出流 详解
  • Java输入输出 表格

    千次阅读 2018-05-22 19:25:34
    java.io.Serializable 。 privatestaticArrayList<白玉楼>角色 = newArrayList();// 创建表格 privatestaticArrayList<红魔馆>角色1 = newArrayList(); Add方法 对象调用.add();括号内输入参数.   Remove 对象....
  • JAVA输入输出(IO)之字节流

    千次阅读 2015-12-29 21:14:15
    言归正传,在上一篇博客《JAVA输入输出(IO)之文件》中介绍了File类的简单使用,如果我们要对文件进行读取、写入,仅有一个File是远远不够的,这一篇为大家介绍字节流的概念,通过本片博客,我们可以
  • ACM之Java输入输出

    千次阅读 2016-08-01 16:47:26
    一、Java之ACM注意点 ...3. 有些OJ上的题目会直接将OI上的题目拷贝过来,所以即便是题目中有输入和输出文件,可能也不需要,因为在OJ系统中一般是采用标准输入输出,不需要文件 4. 在有多行
  • Java 输入输出和异常

    千次阅读 2018-08-09 09:03:41
    Java的控制台输入由System.in完成。为了获得一个绑定到控制台的字符流,可以把System.in包装在一个BufferedReader 对象中来创建一个字符流。 下面是创建BufferedReader的基本语法: public class IOtest { ...
  • Java输入 输出与变量

    千次阅读 2018-02-11 22:21:43
    Java输出语句为:System.out.println("");读输入:Scanner in = new Scanner(System.in); System.out.println(in.nextLine());变量: 变量定义的一般形式就是:&lt;类型名称&gt;&lt;变量名称...
  • Java输入输出/异常处理

    千次阅读 2019-03-22 17:54:34
    处理输入输出操作时,库里的很多IO流类的方法都会抛出异常。 又称为例外,是特殊的运行错误对象。 Java中声明了很多异常类,每个异常类都代表了一种运行错误,类中包含了:该运行错误的信息;处理错误的方法。 每当...
  • Java输入输出(标准)

    千次阅读 2018-07-30 09:16:21
    Java输入就需要自己构造类了。 其中nextLine()这个方法,表示的是,一直读,读到有换行符之后就截至(不取换行符) 代码 import java.util.*; public class Test { public static void main(String [] args) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,569
精华内容 33,427
关键字:

java输入输出

java 订阅