刷题——处理输入输出 Java

1. 输入：

• Scanner 这个类最慢，但是最好用，因为这个类没有缓存处理，所以io方面大量输入读取特别慢。

格式1：Scanner sc = new Scanner (new BufferedInputStream(System.in));

格式2：Scanner sc = new Scanner (System.in);

在读入数据量大的情况下，格式1的速度会快些。

读一个整数： int n = sc.nextInt(); 相当于 scanf("%d", &n); 或 cin >> n;

读一个字符串：String s = sc.next(); 相当于 scanf("%s", s); 或 cin >> s;

读一个浮点数：double t = sc.nextDouble(); 相当于 scanf("%lf", &t); 或 cin >> t;

读一整行： String s = sc.nextLine(); 相当于 gets(s); 或 cin.getline(…);

判断是否有下一个输入可以用sc.hasNext()或sc.hasNextInt()或sc.hasNextDouble()或sc.hasNextLine()

• bufferedreader这个类最不方便，但是可以满足大部分输入速度的需求，输入缺点就是只能按行读取数据，必要时需要字符串分割，转成int以及其他类型还需要转换。

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

• StreamTokenizer这个类最快，相对第二种也好用很多，他的底层是用字符分割用，但是这样处理有很大局限性。输入string类型除了纯字母。否则混合输入会出错，特殊符号在字符串中输入也不行。

StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
in.nextToken();int n=(int)in.nval;
in.nextToken();long p=(long)in.nval;
in.nextToken();double q=in.nval;
out.print(n);
out.flush();

读整数

Input 输入数据有多组，每组占一行，由一个整数组成。
Sample Input
56
67
100
123
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in);
		while(sc.hasNext()){ //判断是否结束
			int score = sc.nextInt();//读入整数
			.....
		}
	}
}

读入实数
输入数据有多组，每组占2行，第一行为一个整数N，指示第二行包含N个实数。

Sample Input
4
56.9 67.7 90.5 12.8
5
56.9 67.7 90.5 12.8
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in);
		while(sc.hasNext()){
			int n = sc.nextInt();
			for(int i=0;i<n;i++){
				double a = sc.nextDouble();
				......
			}
		}
	}
}

读入字符串

Sample Input
2
asdfasdf123123asdfasdf
asdf111111111asdfasdfasdf
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for(int i=0;i<n;i++){
			String str = sc.next();
			......
		}
	}
}
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = Integer.parseInt(sc.nextLine());
		for(int i=0;i<n;i++){
			String str = sc.nextLine();
			......
		}
	}
}

给定一个日期，输出这个日期是该年的第几天。
Input 输入数据有多组，每组占一行，数据格式为YYYY/MM/DD组成
1985/1/20
2006/3/12
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] dd = {0,31,28,31,30,31,30,31,31,30,31,30,31};
		while(sc.hasNext()){
			int days = 0;
			String str = sc.nextLine();
			String[] date = str.split("/");
			int y = Integer.parseInt(date[0]);
			int m = Integer.parseInt(date[1]);
			int d = Integer.parseInt(date[2]);
			if((y%400 == 0 || (y%4 == 0 && y%100 !=0)) && m>2) 	days ++;
			days += d;
			for(int i=0;i<m;i++){
				days += dd[i];
			}
			System.out.println(days);
		}
	}
}

多行数据输入

static Scanner in = new Scanner(System.in);  
while(in.hasNextInt())
或者while(in.hasNext())  

返回最准确的可用系统计时器的当前值，以毫微秒为单位。

long startTime = System.nanoTime();  
// ... the code being measured ...  
long estimatedTime = System.nanoTime() - startTime;  

输出

System.out.print(); 

System.out.println(); 

System.out.format();

System.out.printf();  

Sample Input

4

+ 1 2

- 1 2

* 1 2

/ 1 2

Sample Output

3

-1

2

0.50

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in);
		int n = sc.nextInt();
		for(int i=0;i<n;i++){
			String op = sc.next();
			int a = sc.nextInt();
			int b = sc.nextInt();
			if(op.charAt(0)=='+'){
				System.out.println(a+b);
			}else if(op.charAt(0)=='-'){
				System.out.println(a-b);
			}else if(op.charAt(0)=='*'){
				System.out.println(a*b);
			}else if(op.charAt(0)=='/'){
				if(a % b == 0) System.out.println(a / b);
				else System.out.format("%.2f", (a / (1.0*b))). Println();
			}
		}
	}
}

规格化的输出：

import java.text.DecimalFormat;
import java.text.NumberFormat;

public class testIO {
    public static void main(String[] args) {
        NumberFormat formatter = new DecimalFormat( "000000");
        String s = formatter.format(-1234.567); // -001235
        System.out.println(s);
        formatter = new DecimalFormat( "##");
        s = formatter.format(-1234.567); // -1235
        System.out.println(s);
        s = formatter.format(0); // 0
        System.out.println(s);
        formatter = new DecimalFormat( "##00");
        s = formatter.format(0); // 00
        System.out.println(s);
        formatter = new DecimalFormat( ".00");
        s = formatter.format(-.567); // -.57
        System.out.println(s);
        formatter = new DecimalFormat( "0.00");
        s = formatter.format(-.567); // -0.57
        System.out.println(s);
        formatter = new DecimalFormat( "#.#");
        s = formatter.format(-1234.567); // -1234.6
        System.out.println(s);
        formatter = new DecimalFormat( "#.######");
        s = formatter.format(-1234.567); // -1234.567
        System.out.println(s);
        formatter = new DecimalFormat( ".######");
        s = formatter.format(-1234.567); // -1234.567
        System.out.println(s);
        formatter = new DecimalFormat( "#.000000");
        s = formatter.format(-1234.567); // -1234.567000
        System.out.println(s);
        formatter = new DecimalFormat( "#,###,###");
        s = formatter.format(-1234.567); // -1,235
        System.out.println(s);
        s = formatter.format(-1234567.890); // -1,234,568
        System.out.println(s);
// The ; symbol is used to specify an alternate pattern for negative values
        formatter = new DecimalFormat( "#;(#) ");
        s = formatter.format(-1234.567); // (1235)
        System.out.println(s);
// The ' symbol is used to quote literal symbols
        formatter = new DecimalFormat( " '# '# ");
        s = formatter.format(-1234.567); // -#1235
        System.out.println(s);
        formatter = new DecimalFormat( " 'abc '# ");
        s = formatter.format(-1234.567); // - abc 1235
        System.out.println(s);
        formatter = new DecimalFormat( "#.##%");
        s = formatter.format(-12.5678987);
        System.out.println(s);
    }
}

字符串处理 String
String 类用来存储字符串，可以用charAt方法来取出其中某一字节，计数从0开始：

String a = "Hello"; // a.charAt(1) = 'e' 

用substring方法可得到子串，如上例

System.out.println(a.substring(0, 4)) // output "Hell" 

注意第2个参数位置上的字符不包括进来。这样做使得 s.substring(a, b) 总是有 b-a个字符。

字符串连接可以直接用 + 号，如

String a = "Hello"; 

String b = "world"; 

System.out.println(a + ", " + b + "!"); // output "Hello, world!" 

如想直接将字符串中的某字节改变，可以使用另外的StringBuffer类。

高精度
BigInteger和BigDecimal可以说是acmer选择java的首要原因。
函数：add, subtract, divide, mod, compareTo等，其中加减乘除模都要求是BigInteger(BigDecimal)和BigInteger(BigDecimal)之间的运算，所以需要把int(double)类型转换为BigInteger(BigDecimal)，用函数BigInteger.valueOf().

import java.io.BufferedInputStream;
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int a = 123, b = 456, c = 7890;
        BigInteger x, y, z, ans;
        x = BigInteger.valueOf(a);
        y = BigInteger.valueOf(b);
        z = BigInteger.valueOf(c);
        ans = x.add(y); System.out.println(ans);
        ans = z.divide(y); System.out.println(ans);
        ans = x.mod(z); System.out.println(ans);
        if (ans.compareTo(x) == 0) System.out.println("1");
    }
}

进制转换

String st = Integer.toString(num, base); // 把num当做10进制的数转成base进制的st(base <= 35).
int num = Integer.parseInt(st, base); // 把st当做base进制，转成10进制的int(parseInt有两个参数,第一个为要转的字符串,第二个为说明是什么进制).  
BigInter m = new BigInteger(st, base); // st是字符串，base是st的进制.

数组排序
函数：Arrays.sort();

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner (new BufferedInputStream(System.in));
        int n = cin.nextInt();
        int a[] = new int [n];
        for (int i = 0; i < n; i++) a[i] = cin.nextInt();
        Arrays.sort(a);
        for (int i = 0; i < n; i++) System.out.print(a[i] + " ");
    }
}