积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

1.进制转换

1.1 十进制转其他进制

一个重要的函数：Integer.toString(k,r) ，将十进制的数k转换为r进制的数。返回一个String。

int k = 17;
System.out.println(Integer.toBinaryString(k)); //转二进制
System.out.println(Integer.toOctalString(k)); //转八进制
System.out.println(Integer.toHexString(k)); //转十六进制

int r =2;
System.out.println(Integer.toString(k,r)); //转r进制
r=8;
System.out.println(Integer.toString(k,r)); //转r进制
r=16;
System.out.println(Integer.toString(k,r)); //转r进制

1.2 其他进制转换为十进制

函数：Integer.parseInt(str,r) ，将r进制的数字字符串str转换为十进制，并返回十进制的数。

System.out.println(Integer.parseInt("10001",2));
System.out.println(Integer.parseInt("21",8));
System.out.println(Integer.parseInt("11",16));
        
//输出结果
17
17
17

2.保留小数位数

2.1 String.format()

double a = 123.456789;
double b = 123.444444;
String sa = String.format("%.2f",a);
System.out.println(sa);
String sb = String.format("%.2f",b);
System.out.println(sb);

//输出
123.46
123.44

//简写
System.out.println(String.format("%.2f",a));

2.2 DecimalFormat的format方法

double a = 123.456789;
double b = 123.444444;
DecimalFormat dfa = new DecimalFormat("0.00");
System.out.println(dfa.format(a));
DecimalFormat dfb = new DecimalFormat("0.00");
System.out.println(dfb.format(b));

//输出 
123.46
123.44

//简写
System.out.println(new DecimalFormat("0.00").format(a));

DecimalFormat 类主要靠 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。如：

double a = 123.00;
DecimalFormat dfa = new DecimalFormat("#.##");
System.out.println(dfa.format(a));
DecimalFormat dfb = new DecimalFormat("0.00");
System.out.println(dfb.format(a));

//输出
123
123.00

2.3 BigDecimal的setScale方法（了解）

double f = 111231.5585;
BigDecimal bg = new BigDecimal(f);           
double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();   //setScale已经过时        
System.out.println(f1);

2.4 NumberFormat的setMaximumFractionDigits方法（了解）

double f = 111231.5585;
NumberFormat nf = NumberFormat.getNumberInstance();           
nf.setMaximumFractionDigits(2);           
System.out.println(nf.format(f));

2021/12/10 15:30:41

3.自定义排序

Java中的sort默认是升序排序的。排序中使用到的比较器Comparable和Comparator。Comparable和Comparator都是java.包下的两个接口，从字面上看这两个接口都是用来做比较用的，但是jdk里面不可能定义两个功能相同的接口，所以他们肯定有不同的用处。

通过Comparator接口可以实现自定义排序，实现Comparator接口时，要重写compare方法。Comparable可以认为是一个类比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的。若一个类实现了Comparable接口，就意味着该类支持排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。

3.1 理解返回值

理解比较器中的返回值的含义。

这个是用来判断该升序还是降序的。理解就一句话：只看结果，不看过程。用结果判断谁小谁大，谁小谁就在前。

📢注意：这里是用结果来判断谁大谁小，而不是实际的大小。

怎么理解呢？就只看函数返回的是正数（1），是0，还是负数（-1）。返回负数，表明前面的比后面的小；返回正数，表明后面的比前面的小。（是看前一个数减去后一个数的值）如果当前比较的是A和B两个数（可以永远理解成看的是A-B的结果，即前一个减去后一个），如果返回的是-1（负数），表示A比B小，A就在前面；如果是1（正数），则表示B比A小，B就在前面。而函数是如何规定返回1还是-1还是0，那就得看你自己了。

例如：7和13

1. 7-13<0 。所以 return -1（或者return 7-13）。
2. 看结果为负数，所以说前一个数比后一个数小，小的在前面。符合，所以不用管。所以最后结果为7、13。

如果还是上面的例子，但return 1（或return 13-7）。

这时，结果为正，程序以为前面的大，后面的小，然后就会进行交换。最后结果就为 13、7。

现在换成13和7

1. 13-7>0 。所以 return 1（或者return 13-7）。
2. 看结果为正数，所以说后一个比前一个小，小的在后面，不符合，所以就要交换。所以结果为7、13。

同理，如果return -1（或者return 7-13）。

这时，结果为负。程序以为前面的小，后面的大，就不会进行交换。最后结果为 13、7。

📢注意：就只看第一个参数减去第二个参数的结果是正是负即可。

3.2 自定义比较器（Comparator）

import java.io.*;
import java.util.Arrays;
import java.util.Comparator;


/**
 * @Author DragonOne
 * @Date 2021/12/5 21:27
 * @墨水记忆 www.tothefor.com
 */
public class Main {
    public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));

    public static void main(String[] args) throws Exception {
        Integer[] a = {12, 56, 4, 56, 0, 1, 3, 2};
        Integer[] b = {12, 56, 4, 56, 0, 1, 3, 2};
        int n = a.length;
        
        Arrays.sort(a, 0, n, new cmp2()); //升序
        for (int i = 0; i < n; ++i) {
            System.out.println(a[i]);
        }
        System.out.println("========================"); 
        Arrays.sort(b, 0, n, new cmp()); //降序
        for (int i = 0; i < n; ++i) {
            System.out.println(b[i]);
        }
        closeAll();
    }

    //降序
    static class cmp implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    }
    //升序
    static class cmp2 implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 - o2;
        }
    }

    public static int nextInt() throws Exception {
        cin.nextToken();
        return (int) cin.nval;
    }

    public static long nextLong() throws Exception {
        cin.nextToken();
        return (long) cin.nval;
    }

    public static double nextDouble() throws Exception {
        cin.nextToken();
        return cin.nval;
    }

    public static String nextString() throws Exception {
        cin.nextToken();
        return cin.sval;
    }

    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }

}

3.3 自定义类排序

class Person implements Comparable<Person>{
    private int id;

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        if(this.id<o.id) return 1;
        else return -1;
    }
}

类我并没有写完整，主要是看compareTo方法就行。之后就可以直接使用Collections.sort(List list)进行排序。

即：

List<Person> list = new ArrayList<>();
Collections.sort(list);

保留有效位数

double data = 11.8151965985;
System.out.println(String.format("%g",data)); //保留6位
System.out.println(String.format("%f",data)); //保留8位
double dt = 11.2300000000;
System.out.println(String.format("%g",dt));
System.out.println(String.format("%f",dt));