N1H111SM's Miniverse

Grammar of Java

Code
字数统计: 1.5k阅读时长: 7 min
2020/02/23 Share

Grammar

BufferedReader (比较快)

1
2
3
4
5
6
7
8
9
10
import java.io.*;
public class Solution {
    
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

	public static void main(String[] args) throws IOException{
		String[] line = reader.nextLine().split();
        int num = Integer.parseInt(line[0]);
	}
}

Scanner 输入字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.*;

public class Solution {
    
    private static Scanner scanner = new Scanner(System.in);

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        System.out.print("Fuck you.");
        String input = scanner.nextLine();
        System.out.println("input = " + input);
        System.out.printf("%d", 1);
	}
}

Input Integer

1
2
3
4
5
String input = scanner.nextLine();
int num = Integer.parseInt(input);

int num = Scanner.nextInt(); // very slow
int num = Integer.parseInt(Scanner.next())

Convert Integer to String

1
2
3
4
5
6
7
str = Integer.toString(num);

str = Integer.toBinaryString(num);
str = Integer.toHexString(num);
str = Integer.toOctalString(num);

str = Integer.toString(num, radix=10);

Convert Double to String

1
2
3
4
5
6
7
str = Double.toString(num);

str = Double.toBinaryString(num);
str = Double.toHexString(num);
str = Double.toOctalString(num);

str = Double.toString(num, radix=10);

String Methods

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
char[] charArray = {'0', 'f', 'u'};
String str = new String(charArray);

// length of the string
length = str.length();

// index
char a = str.charAt(0);

// substring
str.substring(0, str.length()-1);

// reverse a string
str = new StringBuilder(str).reverse().toString();

// 格式化输出 double, int 等
String.format("%d", num);
String.format("%.1f", num);

// string的分开，和python差不多
String[] splited = str.split(" ");

// string的头尾去掉空格
String trimed = str.trim();

// replace: 非正则表达式，返回一个新的字符串，只能够替换char
str.replace(char oldChar, char newChar);

// replaceAll
str.repalceAll("^\+", ""); // replace all the starting "

str = "fuck";
// compareTo, compareToIgnoreCase
str.compareTo("fuck");
str.compareToIgnoreCase("FUCk");

// endsWith, returns boolean
str.endsWith("ck");
// startsWith, returns boolean
str.startsWith("wh");

// equals, equalsIgnoreCase
str.equalsIgnoreCase("Fuck");

// 找到第一个出现的位置
indexOf(char chr);
indexOf(char chr, int fromIndex);
indexOf(String str, int fromIndex);

// 找到最后一个出现的位置
lastIndexOf(char chr);

// regionMatches, 测试两个字符串区域是否相等
str.regionMatches(int offset, String otherString, int offset_hat, int length);

// concat, 在仅仅只有两个string的时候是最快的
str.concat("you")

Arrays and ArrayList

Java中的array是在heap中创建的，每个array的元素都会被自动初始化，该值根据不同的类型而定。

  • int - 初始化为0
  • boolean - 初始化为false
  • double - 初始化为0.0
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
40
41
42
43
44
45
46
47
// array
int[] nums = {1, 3, 3, 2, 5};
int[] nums = new nums[6];
int[] nums = new nums[]{1, 3, 4, 5};

// iterate
for (int i = 0; i < nums.length; i++)
    System.out.println(nums[i]);

for (int i: nums)
    System.out.println(i);

// size
len = nums.length;

// array的填充(常作为初始化的方法)
int[] nums = new int[5];
Arrays.fill(nums, Integer.MAX_VALUE);

// 二维数组的填充
int[][] nums = new int[5][5];
for (int[] row : nums)
    Arrays.fill(row, Integer.MAX_VALUE);

// ArrayList
import java.util.ArrayList;

// creation, 不能用正常数据类型(int, double, char),只能用Integer, Double, 
ArrayList<Integer> arr = new ArrayList<Integer>();
// Arrays.asList() to initialize a list：
List<String> tmp = Arrays.asList("1", "2", "4");

// 添加对象进入list
// 在index i处添加对象，i之后的对象自动往后移
arr.add(i, obj);

// 在list末尾添加对象
arr.add(obj);

// 移去index i处的元素
arr.remove((int)i);

// 移去对象
arr.remove(obj);

// List转换为array
arr.toArray();

Map的使用

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
// Map 创建
Map<Character, Integer> map = new HashMap<>();

// size
map.size()

// clear
map.clear();

// 含有key/value
map.containsKey();
map.containsValue();

// get, put, remove
map.get(k);
map.put(k, v);
map.remove(k);

// 是否空
map.isEmpty();

// 键值集合
map.keySet();

// 快速加入或者自增
map.put(key, map.getOrDefault(key, 0)+1);

Queue的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//声明
Queue<Integer> queue = new LinkedList<>();

//添加弹出元素
queue.offer(5); // if full return false
queue.poll();	// if empty return null
queue.peek();	// if empty return null

//vevtor中继承的方法
queue.size();
queue.isEmpty();

// PriorityQueue
Queue<Integer> queue = new PriorityQueue<>((a,b) -> b-a); // maxHeap

Stack

1
2
3
4
5
6
7
// 初始化
Stack<Integer> st = new Stack<>();

st.peek();
st.push();
st.pop();
st.isEmpty();

array用Arrays.sort()，如果是普通的基本数据类型，则没有lambda表达式。

List 数组

1
2
3
4
5
6
7
8
9
10
11
12
13
// 注意后面的ArrayList不带尖括号
List<Integer>[] arr = new ArrayList[10];

// 数组排序, use new Comparator statement
Arrays.sort(arr, new Comparator<List<Integer>>() {
   	@Override
    public int compare(List<Integer> a, List<Integer>) {
        return a.size() - b.size();
    }
});

// 数组每个的初始化
for (i=0;i<arr.lengh;i++) arr[i] = new ArrayList<>();

Arrays

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
int[] arr = new int[10];
for (int i = 0; i < 10; i++) arr[i] = i;
// 1. sort, 适用基本数据类型
Arrays.sort(arr); // ascending
Collections.sort(arr, Collections.reverseOrder()); // descending

// sort, 非基本数据类型：array of lists 为例 (new Comparator<class>() {@Override ...} ) 
Arrays.sort(lists, new Comparator<List<Integer>>() {
    @Override
    public int compare(List<Integer> a1, List<Integer> a2) {
        return -a1.get(0) + a2.get(0);
    }
});

// 2. binarySearch, 如果不在数组中返回(-insertIndex-1)
Arrays.binarySearch(arr, 10); // return 
Arrays.binarySearch(arr, fromIndex, toIndex, key);

// 3. copyOfRange
int[] copy = Arrays.copyOfRange(arr, 0, 3);

// 4. equals: shallow equal 用在单个元素上
Arrays.equals(arr, copy);

// 5. deepEquals: deep equal 用在元素也是数组上，递归进行比较
Arrays.deepEquals(arr, copy);

// 6. toString (deepToString)
System.out.println(Arrays.toString(arr));

Functional Programming in Java (OJ系统中不一定快)

1
2
// WRONG!!!!!!
String[] strings = Array.stream(arr).map(x->String.valueOf(x)).toArray(String[]::new);

以上代码会报错，这是由于Java实现了IntStream, LongStream, DoubleStream三个基本类型的stream，这些基本类型的stream有更好的性能，但是需要注意的是这些基本类型的stream的map函数只支持自身类型->自身类型(int->int/long->long/double->double)的映射，如果需要进行String类型的转换那么我们需要使用mapToObj()函数。

三个基本类型的Stream相互转化的函数为mapToDouble(), mapToInt(), mapToLong().

应当优先使用基本类型的stream

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
// List, Array
Stream<Integer> stream = Arrays.stream(arr);
Stream<Integer> stream = list.stream();

// map (Integer / int)
arr = Arrays.stream(arr).map(x->x*2).toArray(); // no function passed to toArray() call.
String[] strings = Array.stream(arr).mapToObj(x->String.valueOf(x)).toArray(String[]::new); 
String[] strings = Array.stream(arr).mapToObj(x->String.valueOf(x)).toArray(n->new String[n]);

// filter
arr = Arrays.stream(arr).filter(x->x>10).toArray();
String[] strings = list.stream().filter(x->x>10).toArray(String[]::new);

// reduce
int sum = Arrays.stream(arr).sum(); // 只能够用在基本类型stream上
int sum = Arrays.stream(arr).reduce(0, (a,b)->a+b);

// forEach 可以很帅地打印
Arrays.stream(arr).forEach(x->System.out.println(x));

// IntStream的很帅的用法
// 快速初始化
IntStream stream = IntStream.of(1, 2, 3);
IntStream range = IntStream.range(1, 10);
IntStream rangeClosed = IntStream.rangeClosed(1, 10); // 包含10的range
IntStream infinite = IntStream.iterate(1, operand->oprand + 2); // 生成一个无限生成奇数的generator

int[] arr = new int[]{1, 2, 4, -1};
String[] strs = new String[]{"what", "the", "fuck"};
// 求最大、最小、求和 (如果没有 .get() / .orElse() 则返回的是optional)
int max = Arrays.stream(arr).max().orElse(Integer.MIN_VALUE);
int min = Arrays.stream(arr).min().orElse(Integer.MAX_VALUE);
int sum = Arrays.stream(arr).sum().orElse(0);

String max = Arrays.stream(strs).max((a,b)->a.compareTo(b)).orElse("");
String sum = Arrays.stream(strs).reduce("", (a,b)->a.concate(b));

// 另一种有趣写法
int max = Arrays.stream(arr).reduce(Integer.MIN_VALUE, Math::max);

原文作者：Haizhou Shi

原文链接：http://www.shihaizhou.com/2020/02/23/Algorithms-and-Grammar-of-java/

发表日期：February 23rd 2020, 8:37:01 pm

更新日期：June 23rd 2020, 3:52:37 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

CATALOG
  1. 1. Grammar
    1. 1.0.1. BufferedReader (比较快)
    2. 1.0.2. Scanner 输入字符串
    3. 1.0.3. Input Integer
    4. 1.0.4. Convert Integer to String
    5. 1.0.5. Convert Double to String
    6. 1.0.6. String Methods
    7. 1.0.7. Arrays and ArrayList
    8. 1.0.8. Map的使用
    9. 1.0.9. Queue的使用
    10. 1.0.10. Stack
    11. 1.0.11. List 数组
    12. 1.0.12. Arrays
    13. 1.0.13. Functional Programming in Java (OJ系统中不一定快)
Total : 55
2020
2019
Invalid date
Code Representation Learning NLP Basics MI Contrastive GNN RL GAN Manifold Negotiation CV poker FL overview