用java刷题需知，一篇足矣(初学)_使用java刷题时需要注意什么

输入

最好的话，一题只采用一种输入方式。

scanner类

我，一java菜鸡，昨天刷题，发现一直MLE，以为可能是java本来的弊端，比其他的内存要的多，起初以为是long数组太大，改为int仍不行，后来才了解到是输入的问题。
拿来主义，直接拿来用好吗。根据数据多少，快慢选择。
由慢到快。

• scanner：java5之后才有:速度慢

import java.util.Scanner;

public class Tian {
   public static void main(String[]args){
       Scanner scan = new Scanner(System.in);

       String c1 = scan.next();//读取一段字符串
       System.out.println(c1);
      // while (scan.hasNext())
       String c = scan.nextLine();//存入换行号
       String c2 = scan.nextLine();//读取一行，包括空格。
       System.out.println(c2);
     //  while (scan.hasNextLine())
       int c3 = scan.nextInt();//读取整型,其余类型以此类推
       System.out.println(c3);
       }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

next和nextLine同时用要注意next的结束符(换行)是可以存入nextLine里的，所以像C++，getchar一样，加一个nextline来存入不需要的换行。
next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。换行也可作为结束符。
next() 不能得到带有空格的字符串。

nextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白,同样输入是换行，同样可以存入。

BufferedReader类

• BufferedReader：把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流：速度中

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Tian {
    public static void main(String[]args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        char c = (char) br.read();//读入一个字符
        String c1 = br.readLine();//读取不需要的换行符
        String mid = br.readLine();//读入一个字符串
//        while ((mid = br.readLine()) != null)//终至EOF
        System.out.println(c);
        System.out.println(mid);
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

两个注意点
1.要有异常处理：throw IOException
2.read和readLine同时使用和上文next和nextLine注意点一样。
3.read()读的是一个字符强转的int型，比如说1，读出的int就是ascall码49，所以，最好直接用readLine，然后处理字符串。

StreamTokenized类

• StreamTokenized：不多介绍，因为我也只会用：速度：快
  详细解说： link.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;


public class Tian {
   public static void main(String[]args) throws IOException {
   StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
       st.nextToken();//每次输入前都要加
       int n = (int) st.nval;//st.nval类型是double,记得强转
       st.nextToken();
       String c = st.sval;//等同next

       System.out.println(n);
       System.out.println(c);
//        while (st.nextToken() != StreamTokenizer.TT_EOF)//EOF终止
//            while (st.nextToken() != StreamTokenizer.TT_EOL)//\n终止
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出

小数输出

保留几位小数输出，两种，两种都可以四舍五入

• 用DecimalFormat类输出

       DecimalFormat df = new DecimalFormat("0.00");
    	System.out.println(df.format(r));
1
2

• 仿C输出，我常用的

  System.out.printf("%.2f",2.00);
//    System.out.println("%.2lf",2.000);是不合法的,记住了
//     System.out.printf("%.0f",d); 四舍五入保留整数
1
2
3

正常输出：

   int a[] = {1,2,3};
        for(int e:a){
            e += 1;//是可以做运算的
            System.out.print(e + " ");
        }
        System.out.println();
        for(int i = 0;i < 3;i++){
            System.out.print(a[i] + " ");
        }
        System.out.println();
1
2
3
4
5
6
7
8
9
10

输出流

说来就来，昨天输入流MLE，今天输出流MLE外加TLE，卡死的题目：link.(用java写出来，call me，谢谢)
俺查了老半天就查到四种输出。

• BufferedWrite
• PrintStream
• PrintWrite
• System.out
  各种褒贬不一，干脆，直接测一测
  测量时间：long star1 = System.nanoTime();

import java.io.*;
import java.util.Scanner;


public class Main {
    public static void main(String[]args) throws IOException {
        String c = "abcdef";
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        PrintStream out1 = new PrintStream(new BufferedOutputStream(System.out));
        PrintWriter out2 = new PrintWriter(new OutputStreamWriter(System.out));
        long star1 = System.nanoTime();
        for(int i = 0;i < 100000;i++)
        out.write(c);
        out.flush();
      //  out.close();

        long star2 = System.nanoTime();
        for(int i = 0;i < 100000;i++)
        out1.println(c);
        out1.flush();
        //out1.close();

        long star3 = System.nanoTime();
        for(int i = 0;i < 100000;i++)
        out2.write(c);
        out2.flush();
        //out2.close();

        long star4 = System.nanoTime();
        for(int i = 0;i < 100000;i++)
        System.out.println(c);
        long end = System.nanoTime();
        System.out.println("BufferedWrite:        " + (star2 - star1));
        System.out.println("PrintStream:          " + (star3 - star2));
        System.out.println("PrintWrite:           " + (star4 - star3));
        System.out.println("System.out:           " + (end - star4));
    }
}

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
29
30
31
32
33
34
35
36
37
38
39

• 数据：(输出次数多少)

结论：
优先选择BufferedWrite，然后是PrintWrite，数据量越多，则System.out越拉胯

• 数据：(输出长度)

结论：其实坚定的选择System.out就好，大概在3*10^6左右，ps，pw，so三者数据差不多，好像ps超了so，感觉上应该System.out应该可
（￣︶￣）↗

其他

EOF结束

C语言的多组数据输入都熟悉

while (scanf("%d",&m)!=EOF)  
{ ...
}

1
2
3
4

java的多项数据输入

import java.util.*;
public class Main {
    public static void main(String[] args) {
        while (scanner.hasNext()){
          int a = scanner.nextInt();
          int b = scanner.nextInt();
            System.out.println(a + b);
        }

    }
}

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

基本数据结构

Enumeration(枚举)

• hasMoreElements( ) ：测试此枚举是否包含更多的元素。
• nextElement( )：如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
  很少用

 Enumeration<String>days;
      Vector<String> dayNames = new Vector<String>();
      dayNames.add("Sunday");
      dayNames.add("Monday");
        dayNames.add("Tuesday");
        dayNames.add("Wednesday");
        dayNames.add("Thursday");
        dayNames.add("Friday");
        dayNames.add("Saturday");
        days = dayNames.elements();
        while (days.hasMoreElements()){
            System.out.println(days.nextElement());
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

结果是按循序输出各个单词
enum(枚举类)：
声明在main函数外，定义格式：
可访问行 enum名字 enum类型{
enum1,enum2,enum3
}
各个枚举名称不能相同，不声明类型，则类型为int型
ヾ(≧▽≦*)o

Vector(动态数组)

和ArrayList相似，但是他支持同步，所以访问起来比ArrayList慢，并且并不是一种集合框架

然后容量扩展差不多是以十为单位的，至少idea上是这样
ψ(｀∇´)ψ

Stack(栈)

单进单出，先进后出的

import java.util.Stack;

public class Helloworld {
    public static void main(String[]args){
       Stack<Integer> mid = new Stack<>();
       mid.push(1);mid.push(2);mid.push(3);
       System.out.println(mid.peek());//查看栈顶元素，不出栈
       System.out.println(mid.pop());//出栈，并返回栈顶元素
        System.out.println(mid.search(2));//查看元素1的位置，是以1起始的
    }
}

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

结果：

Queue(队列)

先进先出，前出后进，

import java.util.ArrayDeque;
import java.util.Queue;


public class Helloworld {
    public static void main(String[]args){
        Queue<Integer>mid = new ArrayDeque<>();
        mid.offer(1);//插入元素
        mid.add(1);mid.add(2);mid.add(3);
        System.out.println(mid.peek());//访问队头，不出队
        System.out.println(mid.poll());//访问队头，出队
        System.out.println();
    }
}

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

结果：

( •̀ ω •́ )✧

PriorityQueue(优先队列：堆)

刷题嘛，就不讲其底层实现原理了，直接拿来主义好吗
队尾添加元素，队头永远是最大值，或者最小值，并不代表堆类元素是有序的
一般来说是最小值：

import java.util.ArrayDeque;
import java.util.PriorityQueue;
import java.util.Queue;


public class Helloworld {
    public static void main(String[]args){
        PriorityQueue<Integer>mid = new PriorityQueue<>();
        mid.add(8);mid.add(7);mid.add(9);
        System.out.println(mid.poll());//输出最小值7
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

改为输出值为最大值，加一个比较器就ok

import java.util.ArrayDeque;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;


public class Helloworld {
    public static void main(String[]args){
        PriorityQueue<Integer>mid = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        mid.add(8);mid.add(7);mid.add(9);
        System.out.println(mid.poll());//输出为最大值9
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

抱歉抱歉，先更这么多好了，后面继续刷题出现问题，俺马上继续更新，勿喷或者轻点喷。