ACM必备的快速输入输出（Java）

Posted 2021-06-26 ZSYL

ACMer

• 手写Input类
• • BufferedReader
  • StringTokenizer
• 静态Input方法
• • StreamTokenizer

手写Input类

BufferedReader

从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。
通常，由读取器做出的每个读取请求将引起对底层字符或字节流的相应读取请求。

也可以直接使用 BufferedReader代替下面方法。

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] stoken = br.readLine().split(" ");

int n = Integer.parseInt(stoken[0]);
int m = Integer.parseInt(stoken[1]);

String[] x = br.readLine().split(" ");

StringTokenizer

字符串tokenizer类允许应用程序将字符串拆分成令牌。
StreamTokenizer化方法比StreamTokenizer类使用的方法简单得多。
StringTokenizer方法不区分标识符，数字和引用的字符串，也不识别和跳过注释。
可以在创建时或每个令牌的基础上指定一组分隔符（分隔标记的字符)。

StringTokenizer一个实例以两种方式之一表现，具体取决于它是使用true或false的returnDelims标记创建的：

1. 如果标志为false ，则分隔符用于分隔标记。 令牌是不是分隔符的连续字符的最大序列。
2. 如果标志是true，则分隔符字符本身被认为是令牌。 因此，令牌是一个定界符字符，或不是分隔符的连续字符的最大序列。
   A StringTokenizer对象内部维护要标记化的字符串中的当前位置。 某些操作会将当前位置提前处理。

通过使用用于创建StringTokenizer对象的字符串的子字符串来返回令牌。

注意：
为指定的字符串构造一个字符串tokenizer。 标记器使用默认分隔符集，即" \\t\\n\\r\\f" ：空格字符，制表符，换行符，回车字符和换页符。 分隔符字符本身不会被视为令牌。

class InputReader {
    BufferedReader reader;
    StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String next() throws IOException {
        while (tokenizer==null || !tokenizer.hasMoreTokens()){
            tokenizer = new StringTokenizer(reader.readLine());
        }

        return tokenizer.nextToken();
    }

    public String nextLine() throws IOException {
        return reader.readLine();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public Long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public Double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

测试代码：

public class quickInput {
    public static void main(String[] args) {
        try {
            InputReader sc = new InputReader(System.in);
            int x = sc.nextInt();
            int y = sc.nextInt();
            long yy = sc.nextLong();
            double xx = sc.nextDouble();
            String ss = sc.nextLine();

            System.out.println(x+y);
            System.out.println(sc.nextInt());
            System.out.println(yy);
            System.out.println(xx);

            System.out.println(ss);
        } catch (Exception e){
            System.out.println(e.toString());
        }
    }
}

静态Input方法

StreamTokenizer

StreamTokenizer类接收输入流并将其解析为“令牌”，允许一次读取一个令牌。 解析过程由表和多个可以设置为各种状态的标志来控制。 流标记器可以识别标识符，数字，引用的字符串和各种注释样式。
从输入流读取的每个字节被视为’\\u0000’至’\\u00FF’ 。 字符值用于查找字符的五个可能属性： 空格 ， 字母 ， 数字 ， 字符串引号和注释字符 。 每个角色都可以有零个或多个这些属性。

另外，一个实例有四个标志。 这些标志表示：

• 线路终端器是否作为令牌返回或被视为仅分隔令牌的空白区域。
• C风格的评论是否被识别和跳过。
• C++风格的评论是否被识别和跳过。
• 标识符的字符是否转换为小写。

一个典型的应用程序首先构造一个这个类的一个实例，设置语法表，然后在循环的每个迭代中重复循环调用nextToken方法，直到它返回值为TT_EOF 。

测试代码：

import java.io.*;
import java.util.*;
  
public class Main{
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
  
    public static void main(String[] args) {
        int C = nextInt(), n = nextInt();
        long v[] = new long[n + 10], w[] = new long[n + 10],dp[][] = new long[(1<<n) + 1][2];
        int map[] = new int[(1<<n) + 10];
        for(int i = 1;i<=n;++i) 
            v[i] = nextInt();
        for(int i = 1;i<=n;++i)
            w[i] = nextInt();
        for(int i = 1;i<=n + 1;++i) map[1<<(i - 1)] = i;
        long rs = 0;
        for(int i = 1;i < (1 << n);++i) {
            int lob = map[i&-i], last = i - (i & -i);
            dp[i][0] = dp[last][0] + v[lob];
            dp[i][1] = dp[last][1] + w[lob];
            if(dp[i][0] <= C) rs = Math.max(rs, dp[i][1]);
        }
        System.out.println(rs);
        out.flush();
    }
      
    static int nextInt() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int)st.nval;  // 如果当前令牌是一个数字，则此字段包含该数字的值。 
    }
  
    static String next() {
        try {
            st.nextToken();  // 如果当前令牌是一个单词标记，则该字段包含一个字符串，给出单词令牌的字符。 
        } catch (IOException e) {
            e.printStackTrace();
        }
        return st.sval;
    }
}

感谢!