# Java版OJ多组输入和输出

参照牛客竞赛：OJ在线编程常见输入输出练习场 (opens new window)
参考自LeetCode获得工程认知 (opens new window)
- 这个作者是2020-08-26写的

不知道有没有人想吐槽Java8里的map的初始化方式...

虽然现在都Java14了，但是绝大多数互联网工程项目还是停留在Java8，甚至有些还是Java7。
像题目中的map是很典型的可以做成不可变域的（初始化之后不再改变，通常用static final）。
但是Java8里面的类似的语法糖实在匮乏，甚至连工厂方法都没有，导致写起来如鲠在喉。
当然是有许多开源项目都有实现，但这么基础的东西，实在不应该由外部实现。
顺便补充一个冷知识——Leetcode支持Java9。
下面这个是Java9里标准库的初始化工厂，写起来省纸。

-  其实LeetCode至少支持Java10，比如var在LeetCode里就能用
- 那是因为JDK8之后不再免费。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 目录

[TOC]

# ⭐️Java的ACM模板

牛客网对Java多组输入和输出的理解

Q：为什么Java代码在我本机运行正常，提交到牛客网报编译错误
A：因为Java文件名和类名需要保持一致。
- 1、如果编程题已经提供了类和要编写代码的方法，请不要擅自给方法加上static，也不要擅自修改类的名字。也不要给代码增加任何package信息。
- 2、对于没有提供任何辅助代码的编程题，请确认类的名字是Main
util是utiliy的缩写，是一个多功能、基于工具的包。
- java.util是包含集合框架、遗留的collection 类、事件模型、日期和时间设施、国际化和各种实用工具类
JAVA，注意类名必须为Main, 不要有任何package xxx信息

注意hasNext和hasNextLine的区别，

OJ的java输入hasNext和hasNextLine区别 (opens new window)

类的首字母要大写
函数名，首字母小写
class和function的话，后面任何一个单词都要首字母大写
在Java2中一切都已经改变了，包的整个名称全都变成了『小写』
- 参考自：《Java编程思想》，第4版，P112

区别：System.out.print(XXX)和System.out.println(XXX )前面不换行，后面换行

java.lang	该包提供了Java编程的基础类，例如 Object、Math、String、StringBuffer、System、Thread等，不使用该包就很难编写Java代码了。
java.util	该包提供了包含集合框架、遗留的集合类、事件模型、日期和时间实施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。
java.io	该包通过文件系统、数据流和序列化提供系统的输入与输出。
java.net	该包提供实现网络应用与开发的类。
java.sql	该包提供了使用Java语言访问并处理存储在数据源（通常是一个关系型数据库）中的数据API。
java.awt	这两个包提供了GUI设计与开发的类。java.awt包提供了创建界面和绘制图形图像的所有类，而javax.swing包提供了一组“轻量级”的组件，尽量让这些组件在所有平台上的工作方式相同。
javax.swing
java.text	提供了与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。

参考自：CSDN3.了解java .lang 包,java.util包等常用包 (opens new window)

java8官方文档 (opens new window)
java8官方文档的中文版 (opens new window)

import java.util.*;//啥都有头文件『whoway，认为，这个是错误的！』
import java.util.Scanner;//相当于输入输出头文件
import java.math.BigInteger;//大数类
import java.math.BigDecimal;//大浮点数
import java.math.*;//关于数学的头文件

人所皆知BigInteger,BigDecimal，
记得曾经跟cxlove和芒果打浙江省赛的时候Java用的不熟，只能用Java打表用C++提交。。。尴尬
综上，用好Java直接走天下。没必要一定去学C++
    
    Java在做ACM算法题时，会碰到一些麻烦，如：
    1.输入用Scanner运行效率低，用BufferedReader开发效率低，最好自己准备工具类
    2.标准类库对算法支持非常少，比如没有nextPermutation方法
    3.泛型不支持原生类型如int，而一个Integer消耗的内存是int的5倍，这意味着标准类库很多方法不实用，例如HashMap
    4.Java的语法糖在算法题中基本用不到，算法题更多需要的指针、引用型参数，Java不支持

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我自己配置的notepad++的java环境的，快捷键是F6就可以调用插件NppExec
Java在很多OJ
1）只能使用 Main 作为主类名 2）代码中必须存在一个public class Main。不允许出现其他的public class。

# 1.A+B (opens new window)（1）

# 2.A+B (opens new window)（2）

# 3.A+B (opens new window)（3）

# 4.A+B (opens new window)（4）

# 5.A+B（5）

05.A+B (opens new window)（5）

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNextInt() )
		{
			int loop=temp.nextInt();
			for(int i=0; i<loop; ++i)
			{
				int inner_loop=temp.nextInt();
				int sum=0;
				for(int j=0; j<inner_loop; ++j)
				{
					int inner_temp=temp.nextInt();
					sum+=inner_temp;
				}

				System.out.println(sum);
			}
		}
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 6.A+B（6）和4重复

# 7.A+B（7）『重要』⭐️

A+B（7）『重要』 (opens new window)
parse
- v.对（句子）作句法分析；对（字符串；文本）作句法分析
- n.句法分析；句法分析结果

# 8. 字符串排序(1)『重要』⭐️

字符串排序(1) (opens new window)

# 8.1.方法1

Arrays.sort(str);

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNextInt() )
        {
            int garbage=temp.nextInt();
            temp.nextLine();
            String[] str=temp.nextLine().split(" ");
            Arrays.sort(str);
            for( String s : str )
            {
                //注意，不换行
                System.out.print(s+" ");
            }
            /*	其实这样写才更好
                 for (int i = 0; i < garbage - 1; i++) {
                    System.out.print(arr[i] + " ");
                }
                System.out.print(arr[garbage - 1]);
            */
        }
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 8.2.泛型

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] str = new String[n];
        int i = 0;
        while(n > 0){
            str[i++] = sc.next();
            n--;
        }
        Arrays.sort(str);
        StringBuilder sb = new StringBuilder();
        sb.append(str[0]);
        for(int j=1; j<str.length; j++){
            sb.append(" ");
            sb.append(str[j]);
        }
        System.out.println(sb.toString());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 9. 字符串排序(2)『学习』

字符串排序(2) (opens new window)

好的写法如下

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNextLine() )
        {
            String[] str=temp.nextLine().split(" ");
            Arrays.sort(str);
            int Len=str.length;
            for( int i=0; i<Len; ++i)
            {
                if( i!=(Len-1) )
                {
                    System.out.print(str[i]+" ");
                }
                else
                {
                    System.out.println( str[i] );
                }
                
            }
        }
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

不够Nice的写法，但是过了

import java.util.*;

public class Main{
	public static void main( String[] args ){
		Scanner temp=new Scanner( System.in );
		while( temp.hasNextLine() ){
            String[] str=temp.nextLine().split(" ");
            Arrays.sort(str);
            for( String s : str ){
                //注意，不换行
                System.out.print(s+" ");
            }
            System.out.println();
        }
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 10.字符串排序(3)

『split函数牛皮』
10.字符串排序(3) (opens new window)

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNextLine() )
        {
            String[] str=temp.nextLine().split(",");
            Arrays.sort(str);
            int Len=str.length;
            for( int i=0; i<Len; ++i)
            {
                if( i!=(Len-1) )
                {
                    System.out.print(str[i]+",");
                }
                else
                {
                    System.out.println( str[i] );
                }
                
            }
        }
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 11.自测本地通过提交为0

自测本地通过提交为0 (opens new window)

# 11.为什么50%

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNextInt() )	//或许是因为hasNextInt而不是hasNextLong
		{
            long a=temp.nextLong();
            long b=temp.nextLong();
			System.out.println(a+b);
		}
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 11.2.AC的

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNext() )	//修改的地方
		{
            long a=temp.nextLong();
            long b=temp.nextLong();
			System.out.println(a+b);
		}
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 11.3.用Int报错

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
		while( temp.hasNext() )	//修改的地方
		{
            int a=temp.nextInt();
            int b=temp.nextInt();
			System.out.println(a+b);
		}
		temp.close();
	}
}
/*
请检查是否存在数组越界等非法访问情况
Exception in thread "main" java.util.InputMismatchException: For input string: "12141483647"
at java.util.Scanner.nextInt(Scanner.java:2123)
at java.util.Scanner.nextInt(Scanner.java:2076)
at Main.main(Main.java:10)

用例通过率为 50%
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 11.4.最好的AC『溢出解决方案』

import java.util.*;

public class Main
{
	public static void main( String[] args )
	{
		Scanner temp=new Scanner( System.in );
        
        //总结，曾hasNextInt也可能溢出，所以需要hasNextLong
		while( temp.hasNextLong() )	//或许是因为hasNextInt而不是hasNextLong
		{
            long a=temp.nextLong();
            long b=temp.nextLong();
            
            //如果是int+int可能溢出，所以用long
			System.out.println(a+b);
		}
		temp.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 其他总结

int temp=in.nextInt();
long long =in.nextLong();

hasNext() //返回true或false，看有无下一个标记（字符串类型）。
比如对于a b c，现在处理到a，那么下一个标记就是b。
next() //返回类型为String(字符串)，返回下一个标记。不会读取回车换行。
hasNextInt() //返回true或false，看有无下一个整型字符串标记。
nextInt() //返回类型int，将下一个整型字符串标记转化为int型返回。
nextBoolean() //返回类型为boolean，可以处理字符串true或者false，
nextDouble() //返回类型为double，可以处理字符串如1 2.3 -1.3等。

  
nextLine() //返回类型为String(字符串对象)，返回⭐️一整行。会读取回车换行符。

1
2
3
4
5
6
7
8
9
10
11
12
13

参考资料：附上OJ中提交Java程序的一些套路 (opens new window)

# 附录-多组代码的语法

<CodeGroup>

  <CodeBlock title="Java的nextLine">

```java
import java.util.*;
public class Main
{
	public static void main( String[] args )
}
```

  </CodeBlock>

  <CodeBlock title="Java的nextLine和valueOf">

```java
import java.util.*;

```

  </CodeBlock>

</CodeGroup>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25