有关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);
}
}
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.要有异常处理：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终止
}
}
输出
小数输出
保留几位小数输出，两种，两种都可以四舍五入
- 用DecimalFormat类输出
DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(r));
- 仿C输出，我常用的
System.out.printf("%.2f",2.00);
// System.out.println("%.2lf",2.000);是不合法的,记住了
// System.out.printf("%.0f",d); 四舍五入保留整数
正常输出：
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();
输出流
说来就来，昨天输入流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));
}
}
- 数据：(输出次数多少)
| bw | ps | pw | so | |
|---|---|---|---|---|
| 10^4 | 2917300 | 10372400 | 8201400 | 24582200 |
| 10^5 | 12636700 | 42724600 | 14679200 | 176504500 |
结论：
优先选择BufferedWrite，然后是PrintWrite，数据量越多，则System.out越拉胯
- 数据：(输出长度)
| bw | ps | pw | so | |
|---|---|---|---|---|
| 10^3 | 128500 | 68300 | 57800 | 51200 |
| 10^4 | 666200 | 606500 | 619100 | 515000 |
| 10^5 |
结论：其实坚定的选择System.out就好，大概在3*10^6左右，ps，pw，so三者数据差不多，好像ps超了so，感觉上应该System.out应该可
（￣︶￣）↗
其他
EOF结束
C语言的多组数据输入都熟悉
while (scanf("%d",&m)!=EOF)
{ ...
}
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);
}
}
}
基本数据结构
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());
}
结果是按循序输出各个单词
enum(枚举类)：
声明在main函数外，定义格式：
可访问行 enum名字 enum类型{
enum1,enum2,enum3
}
各个枚举名称不能相同，不声明类型，则类型为int型
ヾ(≧▽≦*)o
Vector(动态数组)
和ArrayList相似，但是他支持同步，所以访问起来比ArrayList慢，并且并不是一种集合框架
| 函数 | 函数作用 |
|---|---|
| add(index，element) | 指定索引加入某值 |
| add(element) | 末尾加入某值 |
| get(index) | 得到某值 |
| capacity() | Vector的容量 |
| size() | 大小 |
然后容量扩展差不多是以十为单位的，至少idea上是这样
ψ(｀∇´)ψ
Stack(栈)
单进单出，先进后出的
| 函数名称 | 函数作用 |
|---|---|
| push(elment) | 入栈 |
| peek() | 访问栈顶，不出栈 |
| pop() | 访问栈顶，出栈 |
| search(element) | 离栈顶的距离,以1开始 |
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起始的
}
}
结果：
Queue(队列)
先进先出，前出后进，
| 函数名称 | 函数作用 |
|---|---|
| peek() | 访问队头，不出队 |
| poll() | 访问队头，出队 |
| add() | 队尾添加元素 |
| offer() | 队尾添加元素 |
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();
}
}
结果：
( •̀ ω •́ )✧
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
}
}
改为输出值为最大值，加一个比较器就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
}
}
抱歉抱歉，先更这么多好了，后面继续刷题出现问题，俺马上继续更新，勿喷或者轻点喷。
3035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
