Java零碎语法知识整合(记忆 must must must)

1.字符串反转

String s = “abcdefg”;
String reverse = new StringBuffer(s).reverse().toString(); //字符串倒置
StringBuilder也有这个方法

2.二维动态数组添加元素

List<ArrayList<Integer>> list = new ArrayList<>();
list.add(new ArrayList<>(Arrays.asList(1,2,3)));
list.add(new ArrayList(Arrays.asList(4,5,6)));
System.out.println(list);   //[[1, 2, 3], [4, 5, 6]]

3.数组的初始化

        //静态初始化：给出初始化值，又系统决定长度
        int[] a = {1,2,3,4,5};    //a是b的简化形式
        int[] b = new int[]{1,2,3,4,5};
        System.out.println(a);
        System.out.println(b);
        System.out.println(a == b);          //false
        System.out.println(a.equals(b));     //false

        //动态初始化：只指定长度，由系统给出初始化值
        int[] c = new int[5];
        for(int i = 0; i < c.length; i++){
            c[i] = i+1;
        }

4.自定义比较器

pirorityQueue默认小顶堆(升序)(父节点的值<=左右子节点的值)，添加comparator参数使其变成大顶堆

Queue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2-o1);  
//降序    大顶堆

Comparable 和 Comparator 都是接口，均为比较器
Comparable相当于“内比较器”，而Comparator相当于“外比较器”
实现Comparable的类，该类就具有自身比较的功能；Comparator的实现，是一个外部比较工具器

注意Comparable 和 Comparator 同时实现时，则以Comparator为主

import java.util.*;

public class SortTest {
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>(Arrays.asList(9, 7, 3, 8, 4, 1, 6, 2, 5, 0));
        System.out.println("原数组：" + list);

        Collections.reverse(list);
        System.out.println("反转后：" + list);

        Collections.sort(list);
        System.out.println("排序后：" + list);

        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 返回值为int类型，大于0表示正序，小于0表示逆序
                //return o2-o1;
                return o2.compareTo(o1);   //这两种写法都可以
            }
        });
        System.out.println("(自定义降序)排序后：" + list);
    }
}

2020.09.26(六)

5.进制转换

参考链接

        //十进制转n进制
        int n = 10;
        System.out.println(Integer.toBinaryString(n));
        System.out.println(Integer.toOctalString(n));
        System.out.println(Integer.toHexString(n));
        System.out.println("(********)");
        System.out.println(Integer.toString(n, 2));
        System.out.println(Integer.toString(n, 8));
        System.out.println(Integer.toString(n, 16));
        System.out.println(Integer.toString(n, 3));
        System.out.println("==================================");
        //n进制转十进制
        String s = "10101";
        System.out.println(Integer.parseInt(s, 2));
        System.out.println(Integer.parseInt(s, 8));
        System.out.println(Integer.parseInt(s, 16));

/*
1010
12
a
(********)
1010
12
a
101
==================================
21
4161
65793
*/

6.StringBuilder在字符串前面加字符

StringBuilder sb = new StringBuilder();
sb.append( "B" ); // 追加一个字符：B
sb.insert( 0 , "A" ); // 在最前面插入一个：A
那么sb的结果就是：AB

2020.10.05

7.二维数组(List<List< Integer>>)去重

import java.util.*;
/*
输入：
[[-4, -2, 6], [-4, -2, 6], [-4, 0, 4],
[-4, 1, 3], [-4, 2, 2], [-2, -2, 4], [-2, -2, 4],
[-2, 0, 2], [-2, -2, 4], [-2, 0, 2], [-2, 0, 2]]
 */
public class Main {
    public static void main(String[] args) {
        List<List<Integer>> res = new ArrayList<>();
        res.add(Arrays.asList(-4,-2,6));
        res.add(Arrays.asList(-4,-2,6));
        res.add(Arrays.asList(-4,0,4));
        res.add(Arrays.asList(-4,1,3));
        res.add(Arrays.asList(-4,2,2));
        res.add(Arrays.asList(-2,-2,4));
        res.add(Arrays.asList(-2,-2,4));
        res.add(Arrays.asList(-2,0,2));
        res.add(Arrays.asList(-2,-2,4));
        res.add(Arrays.asList(-2,0,2));
        res.add(Arrays.asList(-2,0,2));

        System.out.println("去重前：res:"+res);

        Map<List<Integer>, Integer> map = new HashMap<>();
        for(int i = 0; i < res.size();){
            if(map.containsKey(res.get(i))){
                System.out.println("重复："+ res.get(i));
                res.remove(i);
            }else{
                map.put(res.get(i), 1);
                i++;
            }
        }

        System.out.println("去重后：res:"+res);
    }
}
/*
去重前：res:[[-4, -2, 6], [-4, -2, 6], [-4, 0, 4], [-4, 1, 3], [-4, 2, 2], [-2, -2, 4],
[-2, -2, 4], [-2, 0, 2], [-2, -2, 4], [-2, 0, 2], [-2, 0, 2]]
重复：[-4, -2, 6]
重复：[-2, -2, 4]
重复：[-2, -2, 4]
重复：[-2, 0, 2]
重复：[-2, 0, 2]
去重后：res:[[-4, -2, 6], [-4, 0, 4], [-4, 1, 3], [-4, 2, 2], [-2, -2, 4], [-2, 0, 2]]
 */

2020.10.14

new ArrayList<>(Arrays.asList()) Arrays.asList()

参考