数据类型

• boolean(1个字节)
• byte (1个字节) -128~127
• char (2个字节)
• short (2个字节)
• int (4个字节) -2^31 ~ 2^31-1
• long (8个字节)
• float (8个字节)
• double (8个字节)

注意：

1. 一个字节8位
2. 取值范围: -2^(8N-1) ~ 2^(8N-1) - 1  N位字节个数
3. 补码：取反加1
4. 浮点数：不能随意进行比较，存在精度
5. 定点数：BigDecimal
6. 封装类：Boolean、Byte、Char、Short、Integer、Long、Float、Double

二分法查找

/**
 * 二分法查找
 * 
 * @param arr是有序的数组(从小到大)
 * @param k是数组中的元素
 * @return 下角标的位置
 */
public int binarySearch(int[] arr, int k) {
    int a = 0;
    int b = arr.length;
    // k 在 [a,b) 区间
    while (a < b) {
        int m = a+( b - a ) / 2;//防止角标越界
        if (k < arr[m]) {
            b = m;
        } else if (k > arr[m]) {
            a = m + 1;
        } else {
            return m;
        }
    }
    return -1;
}

单例模式（Singleton）

优点：确保全局至多只有一个对象，需要统一管理资料。
缺点：全局性状态，线程安全性。

懒汉式
饿汉式
双重校验锁
静态内部类
枚举

HashMap排序

/**
 * 根据User中的age排序
 * 
 * @param hashMap需要排序的数据源
 * @return 返回排序之后的数据
 */
private HashMap<Integer, User> sortHashMap(HashMap<Integer, User> hashMap) {
    // 有序的HashMap数据结构
    LinkedHashMap<Integer, User> data = new LinkedHashMap<>();
    // 将Map转成Set集合
    Set<Entry<Integer, User>> set = hashMap.entrySet();
    // 将Set集合转成List集合
    ArrayList<Entry<Integer, User>> list = new ArrayList<>(set);
    // 对List排序
    Collections.sort(list, new Comparator<Entry<Integer, User>>() {
        @Override
        public int compare(Entry<Integer, User> o1, Entry<Integer, User> o2) {
            return o2.getValue().getAge() - o1.getValue().getAge();
        }
    });
    // 将List集合转成LinkedHashMap
    for (int i = 0; i < list.size(); i++) {
        Entry<Integer, User> entry = list.get(i);
        data.put(entry.getKey(), entry.getValue());
    }
    return data;
}   
 
public class User {
        private String name;
        private int age;
        public User(String name, int age) {
            this.name = name;
    this.age = age;
    }
 }

引用类型

1. 软引用SoftReference
2. 弱引用WeakReference
3. 强引用