Java常用STL及常用库函数

Java常用STL及常用库函数

参考自AcWing的 语法基础课

/**
 * String
 * ArrayList
 * Queue
 * stk
 * Deque  双端队列
 * Set
 * Map
 * BitSet
 * Pair
 * 位运算
 * 常用库函数：
 * 		翻转、去重、随机打乱、sort
 * 		lower_bound/upper_bound、nth_element
 */

String

// String
@Test
public void test16() throws Exception {

    String s1 = "HelloWorld";
    // 输出字符串长度
    System.out.println(s1.length());  // 10
    // 获取字符串中某个字符
    System.out.println(s1.charAt(0));  // H
    // 判断字符串是否为空
    System.out.println(s1.isEmpty());  // False
    // 将字符串转化为全小写/全大写 后返回
    System.out.println(s1.toLowerCase());  // helloworld
    System.out.println(s1.toUpperCase());  // HELLOWORLD
    System.out.println(s1);  // HelloWorld
    // 去除字符串前后的空格
    System.out.println("--" + "  he llo  world   ".trim() + "--");  // --he llo  world--
    // 比较字符串
    String s2 = "helloWorld";
    System.out.println(s1.equals(s2));  // false  直接比较字符串内容
    System.out.println(s1.equalsIgnoreCase(s2));  // true  忽略大小写比较字符串内容
    // 字符串连接
    System.out.println(s1.concat("You"));  // HelloWorldYou  等价于+
    // 比较字符串的大小
    System.out.println("abc".compareTo("abcd"));  // -1  负数意味着左边小，正数左边大，0相等
    // 截取字符串 substring(int beginIndex, int endIndex) 左闭右开
    String s3 = "我爱你中国";
    System.out.println(s3.substring(3));  // 中国
    System.out.println(s3.substring(0, 3));  // 我爱你


    System.out.println("-------------------------------------");
    System.out.println(s1);  // HelloWorld
    // 测试此字符串是否以指定的后缀结束
    System.out.println(s1.endsWith("world"));  // false
    // 测试此字符串是否以指定的前缀开始
    System.out.println(s1.startsWith("He"));  // true
    // 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
    System.out.println(s1.startsWith("ll", 2));  // true


    System.out.println("-------------------------------------");
    System.out.println(s1);  // HelloWorld
    // 测试当前字符串是否包含指定的char值序列
    System.out.println(s1.contains("ll"));  // true

    // 返回指定子字符串在此字符串中第一次出现处的索引，没有返回-1
    System.out.println(s1.indexOf("ll"));  // 2
    // 返回指定子字符串在此字符串中第一次出现处的索引，从指定索引开始
    System.out.println(s1.indexOf("ll", 5));  // -1

    // 返回指定子字符串在此字符串最右边出现的索引
    System.out.println(s1.lastIndexOf("o"));  // 6
    // 返回指定子字符串在此字符串最右边出现的索引，从指定索引开始反向搜索
    System.out.println(s1.lastIndexOf("o", 5));  // 4


    System.out.println("-------------------------------------");
    String s4 = "北京欢迎您! 北京欢迎您!";
    // String replace(char a, char b)
    // 返回一个新的字符串，它是通过b替此字符串中出现的所有a得到的
    System.out.println(s4.replace('北', '南'));  // 南京欢迎您! 南京欢迎您!
    // String replace(CharSequence a, CharSequence b)
    // 返回一个新的字符串，它是通过b替此字符串中出现的所有a得到的
    System.out.println(s4.replace("北京", "上海"));  // 上海欢迎您! 上海欢迎您!

    // String replaceAll(String regex, String b)
    // 返回一个字符串，它是通过b替换此字符串所有匹配的正则表达式得到的
    String s5 = "12hello34world5java7891mysql456";
    // hello,world,java,mysql
    System.out.println(s5.replaceAll("\\d+", ",").replaceAll("^,|,$", ""));
    // String replaceFirst(String regex, String b)
    // 返回一个字符串，它是通过b替换此字符串第一个匹配的正则表达式得到的
    // hello,world,java,mysql,
    System.out.println(s5.replaceAll("\\d+", ",").replaceFirst("^,|,$", ""));

    // boolean matches(String regrex)
    // 告知此字符串是否匹配给定的正则表达式
    System.out.println("12345".matches("\\d+"));  // true
    System.out.println("0571-4534289".matches("0571-\\d{7,8}"));  // true

    // String[] split(String regrex)
    // 根据给定正则表达式拆分此字符串
    String s6 = "  good    good study, day day up   ";
    // 去掉前后空格后用空格将字符串分开, \\s+ 会将多个空格看做一个
    String[] strs1 = s6.trim().split("\\s+");
    System.out.println(strs1.length);  // 6
    // String[] split(String regrex, int limit)
    // 根据给定正则表达式拆分此字符串, 最多不超过limit个, 如果超过了, 剩下的放到最后一个元素中
    String[] strs2 = s6.trim().split("\\s+", 3);
    System.out.println(strs2.length);  // 3


    System.out.println("-------------------------------------");
    System.out.println(Integer.parseInt("123"));  // String -> 基本数据类型/包装类
    System.out.println(Double.parseDouble("1.2e9"));  // String -> 基本数据类型/包装类
    System.out.println(String.valueOf(123));  // 基本数据类型/包装类 -> String
    System.out.println(123.1 + "");  // 基本数据类型/包装类 -> String
    // String -> char[]
    String s7 = "123abc";
    char[] chs = s7.toCharArray();
    System.out.println(Arrays.toString(chs));  // [1, 2, 3, a, b, c]
    // char[] -> String
    System.out.println(new String(chs));  // 123abc
    // String -> byte[]
    byte[] bs1 = s7.getBytes();  // 使用默认的字符集进行转化
    System.out.println(Arrays.toString(bs1));  // [49, 50, 51, 97, 98, 99]
    String s8 = "123abc中国";
    byte[] bs2 = s8.getBytes("gbk");  // 使用gbk进行编码
    System.out.println(Arrays.toString(bs2));  // [49, 50, 51, 97, 98, 99, -42, -48, -71, -6]
    // byte[] -> String
    System.out.println(new String(bs1));  // 123abc
    System.out.println(new String(bs2, "gbk"));  // 123abc中国
}

// StringBuilder/StringBuffer
@Test
public void test17() {

    // StringBuilder/StringBuffer和String相同的方法这里不演示了

    StringBuilder sb = new StringBuilder("abc");

    sb.append(1);
    sb.append('2');
    sb.append("345");
    System.out.println(sb);  // abc12345

    sb.delete(2, 4);
    System.out.println(sb);  // ab2345

    sb.replace(2, sb.length(), "hello");
    System.out.println(sb);  // abhello

    sb.insert(2, false);
    System.out.println(sb);  // abfalsehello

    sb.reverse();
    System.out.println(sb);  // olleheslafba

    String s = sb.substring(1, 3);
    System.out.println(s);  // ll
    System.out.println(sb);  // olleheslafba

    sb.setCharAt(0, 'a');
    System.out.println(sb);  // alleheslafba

    /**
     * 总结：
     * (1) 增：append(xxx)
     * (2) 删: delete(int start, int end)
     * (3) 改: setCharAt(int index, char ch) / replace
     * (4) 查: charAt(int index)
     * (5) 长度: length()
     * (6) 遍历: for (char c : sb.toString().toCharArray()) ...
     */
}

ArrayList

@Test
public void test01() {
    // 定义 ArrayList
    // 定义一个空 ArrayList
    List<Integer> a = new ArrayList<>();
    // 定义一个空 ArrayList，初始容量为3
    List<Integer> b = new ArrayList<>(3);
    // 定义一个包含元素1,2,3 的 ArrayList
    ArrayList<Integer> c = new ArrayList<>(Arrays.asList(1, 2, 3));

    // 遍历 ArrayList
    for (int i = 0; i < c.size(); i++) System.out.print(c.get(i) + " ");
    System.out.println();
    for (int x : c) System.out.print(x + " ");
    System.out.println();

    // 获取 ArrayList 第一个和最后一个元素
    System.out.println(c.get(0));  // 第一个元素：c[0]常用
    System.out.println(c.get(c.size() - 1));  // 最后一个元素

    // 在 ArrayList 尾部添加、删除元素
    c.add(4);
    c.remove(c.size() - 1);
    c.remove(c.size() - 1);
    System.out.println(c.size());  // 2

    // 清空 ArrayList
    c.clear();
    System.out.println(c.size());  // 0

    // ArrayList 之间的比较需要自己实现
}

Queue

@Test
public void test02() {
    // 定义 queue
    Queue<Integer> q = new LinkedList<>();
    // 入队、出队
    q.add(4);  // 4
    q.add(3);  // 4,3
    q.add(7);  // 4,3,7
    q.remove();  // 3,7
    // 获取 queue 队首和队尾元素(无法获取队尾元素)
    System.out.println(q.peek());  // 返回队首元素: 3
    // 清空 queue
    q.clear();
    System.out.println(q.size());  // 0
    System.out.println(q.isEmpty());  // true


    // 定义PriorityQueue
    System.out.println("=======================");
    Queue<Integer> a = new PriorityQueue<>();  // 小根堆
    Queue<Integer> b = new PriorityQueue<>(((o1, o2) -> o2 - o1));  // 大根堆
    class Rec implements Comparable<Rec> {
        int x, y;
        Rec(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public int compareTo(Rec o) { return this.x - o.x; }
        @Override
        public String toString() { return "Rec{" + "x=" + x + ", y=" + y + '}'; }
    }
    Queue<Rec> c = new PriorityQueue<>();  // 此时为小根堆
    // PriorityQueue 中插入元素，删除元素
    c.add(new Rec(1, 2));
    c.add(new Rec(6, 7));
    c.add(new Rec(5, 4));
    c.add(new Rec(3, 9));
    c.remove();
    // 返回堆顶元素
    System.out.println(c.peek());  // Rec{x=3, y=9}
}

stk

@Test
public void test03() {
    // 定义 stk
    Deque<Integer> stk = new ArrayDeque<>();
    // 入栈，出栈
    stk.push(20); stk.push(10); stk.push(30);
    stk.pop();  // 弹出30
    // 返回栈顶元素
    System.out.println(stk.peek());  // 10
    // 清空 stk
    stk.clear();
    System.out.println(stk.size());  // 0
    System.out.println(stk.isEmpty());  // true
}

Deque

@Test
public void test04() {
    // 定义 deque
    Deque<Integer> d = new ArrayDeque<>();
    // 双端队列中插入、删除元素
    d.addLast(20); d.addLast(10);    // 尾部插入数据: 20,10
    d.removeLast();  // 弹出一个尾部数据10: 20
    d.addFirst(40); d.addFirst(30);  // 头部插入数据: 30,40,20
    d.removeFirst();  // 弹出一个头部数据30: 40,20
    // 遍历 deuqe，不能使用fori进行遍历
    for (int x : d) System.out.print(x + " ");
    System.out.println();
    // 返回头部和尾部元素
    System.out.println(d.getFirst());  // 40
    System.out.println(d.getLast());  // 20
    // 清空 deque
    d.clear();
    System.out.println(d.size());  // 0
    System.out.println(d.isEmpty());  // true
}

Set

@Test
public void test05() {
    /*
     * 有序的set: TreeSet
     */
    // 定义 set，元素不能重复，TreeSet内部实现是红黑树，可以保持有序
    TreeSet<Integer> a = new TreeSet<>();
    class Rec implements Comparable<Rec> {
        int x, y;
        Rec(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public int compareTo(Rec o) { return this.x - o.x; }
    }
    TreeSet<Rec> b = new TreeSet<>();
    // set 中插入、删除元素
    a.add(20); a.add(3); a.add(1);
    a.remove(3);
    // 返回第一个和最后一个元素
    System.out.println(a.first());  // 1
    System.out.println(a.last());  // 20
    // 遍历 set，不能使用fori进行遍历
    for (int x : a) System.out.print(x + " ");
    System.out.println();
    // set 中判断某元素是否存在
    System.out.println(a.contains(20));
    // ceiling/higher
    a.add(4); a.add(12);  // a: 1, 4, 12, 20
    System.out.println(a.ceiling(4));  // 返回大于等于4的最小元素: 4
    System.out.println(a.higher(4));  // 返回大于4的最小元素: 12
    // 补充：floor/lower
    System.out.println(a.floor(4));  // 返回小于等于4的最大元素: 4
    System.out.println(a.lower(4));  // 返回小于4的最大元素: 1
    // 清空 set
    a.clear();
    System.out.println(a.size());  // 0
    System.out.println(a.isEmpty());  // true

    // Java中没有类似于multiset的集合，可以使用TreeMap实现multiset的各项功能


    /*
     * 无序的set: HashSet
     */
    System.out.println("=======================");
    // 定义 set，元素不能重复，HashSet内部实现是哈希表，不可以保持有序
    HashSet<Integer> hash = new HashSet<>();
    // set 中插入、删除元素
    hash.add(1); hash.add(2); hash.add(3); hash.add(4);
    hash.remove(2);
    // 遍历 set，不能使用fori进行遍历
    for (int x : hash) System.out.print(x + " ");
    System.out.println();
    // 随机返回HashSet中的一个数据
    System.out.println(hash.iterator().next());
    // set 中判断某元素是否存在
    System.out.println(hash.contains(3));  // true
    // 清空 set
    hash.clear();
    System.out.println(hash.size());  // 0
    System.out.println(hash.isEmpty());  // true
}

Map

@Test
public void test06() {
    /*
     * 有序的map: TreeMap
     */
    // 定义 map，元素不能重复，内部实现是红黑树，可以保持有序
    TreeMap<String, Integer> a = new TreeMap<>();
    // map 中插入、删除元素
    a.put("wxx", 21); a.put("hh", 18); a.put("other", 20);
    a.remove("other");
    // 返回第一个和最后一个元素
    System.out.println(a.firstEntry());  // hh=18
    System.out.println(a.lastEntry());  // wxx=21
    System.out.println(a.firstKey());  // 没有 firstValue() !
    System.out.println(a.firstEntry().getKey());
    System.out.println(a.firstEntry().getValue());
    // 遍历 map
    for (Map.Entry<String, Integer> p : a.entrySet()) System.out.print(p + "\t");
    System.out.println();
    for (String k : a.keySet()) System.out.print(k + ":" + a.get(k) + "\t");
    System.out.println();
    Iterator<Map.Entry<String, Integer>> it = a.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, Integer> e = it.next();
        System.out.print(e.getKey() + "~" + e.getValue() + "\t");
    }
    System.out.println();
	for (int v : a.values()) System.out.print(v + "\t");  // 只遍历值
	System.out.println();
    // 随机返回Map中的一个键
    System.out.println(a.keySet().iterator().next());
    // 随机返回Map中的一个值
    System.out.println(a.values().iterator().next());
    // map 中判断某元素是否存在
    System.out.println(a.containsKey("wxx"));  // true
    // ceilingKey/higherKey
    a.put("c1", 2); a.put("c2", 4);  // a: {c1=2, c2=4, hh=18, wxx=21}
    System.out.println(a.ceilingKey("c1"));  // 返回大于等于"c1"的最小元素: c1
    System.out.println(a.higherKey("c1"));  // 返回大于"c1"的最小元素: c2
    // 补充：floorKey/lowerKey
    System.out.println(a.floorKey("c1"));  // 返回小于等于"c1"的最大元素: c1
    System.out.println(a.lowerKey("c1"));  // 返回小于"c1"的最大元素: null
    // 清空 map
    a.clear();
    System.out.println(a.size());  // 0
    System.out.println(a.isEmpty());  // true

    // Java中没有类似于multimap的集合


    /*
     * 无序的map: HashMap
     */
    System.out.println("=======================");
    // 定义 map，元素不能重复，HashSet内部实现是哈希表，不可以保持有序
    HashMap<String, Integer> hash = new HashMap<>();
    // map 中插入、删除元素
    hash.put("wxx", 21); hash.put("hh", 18); hash.put("other", 20);
    hash.remove("other");
    // 遍历 map，不能使用fori进行遍历
    for (Map.Entry<String, Integer> p : hash.entrySet()) System.out.print(p + "\t");
    System.out.println();
    for (String k : hash.keySet()) System.out.print(k + ":" + hash.get(k) + "\t");
    System.out.println();
	for (int v : hash.values()) System.out.print(v + "\t");  // 只遍历值
	System.out.println();
    // map 中判断某元素是否存在
    System.out.println(hash.containsKey("wxx"));  // true
    // 清空 map
    hash.clear();
    System.out.println(hash.size());  // 0
    System.out.println(hash.isEmpty());  // true
}

BitSet

// https://www.runoob.com/java/java-bitset-class.html
@Test
public void test07() {
    // 定义BitSet
    BitSet a = new BitSet(1000), b = new BitSet(1000);
    // 赋值
    a.set(0, true);  // a[0] = true
    a.set(2, 8, true);  // 将b[2~8)全部设为true
    b.flip(1, 9);  // b[1~9)全部翻转
    // 获取某一位的值
    System.out.println(a.get(3));  // true
    // 位运算
    a.and(b);  // & 与
    a.or(b);  // | 或
    a.xor(b);  // ^ 异或
    // 返回此 BitSet 表示位值时实际使用空间的位数。
    System.out.println(a.size());
}

Pair

@Test
public void test08() {
    // 系统库中的Pair(javafx.util.Pair)
    Pair<Integer, Integer> pair = new Pair<>(1, 1);
    pair.getKey();
    pair.getValue();

    // 有些jdk中不包含Pair，比如zulu(https://www.azul.com/)家的jdk，因此推荐自己写一个
    class MyPair implements Comparable<MyPair> {
        int x, y;

        public MyPair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(MyPair o) {
            if (x != o.x) return x - o.x;
            else return y - o.y;
        }
    }
    MyPair a = new MyPair(1, 2), b = new MyPair(3, 1);
    System.out.println(a.compareTo(b));  // -2
    // 输出MyPair
    System.out.println("(" + a.x + ", " + a.y + ")");
}

位运算

/*
    & 与
    | 或
    ~ 非
    ^ 异或
    >> 右移
    << 左移

    常用操作：
        (1)	求x的第k位数字  x >> k & 1
        (2)	lowbit(x) = x & -x，返回x的最后一位1
*/

常用库函数

翻转

@Test
public void test09() {

    // 翻转 ArrayList
    ArrayList<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3));
    Collections.reverse(a);
    System.out.println(a);

    // 翻转 String
    String s = "abcd";
    s = new StringBuilder(s).reverse().toString();
    System.out.println(s);

    // 翻转数组：不存在库函数
    int[] b = {1, 2, 3, 4, 5};
    for (int l = 0, r = b.length - 1; l < r; l++, r--) {
        int t = b[l]; b[l] = b[r]; b[r] = t;
    }
    System.out.println(Arrays.toString(b));
}

去重

@Test
public void test10() {

    // 数组去重
    int[] a = {1, 1, 2, 2, 3, 3, 4};
    int m = 0;
    for (int i = 0; i < a.length; i++) {
        if (i == 0 || a[i] != a[i - 1])
            a[m++] = a[i];
    }
    for (int i = 0; i < m; i++) System.out.print(a[i] + " ");
    System.out.println();

    // ArrayList 去重
    ArrayList<Integer> b = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4));
    ArrayList<Integer> res = new ArrayList<>();
    for (int i = 0; i < b.size(); i++) {
        if (i == 0 || !b.get(i).equals(b.get(i - 1)))
            res.add(b.get(i));
    }
    System.out.println(res);
}

随机打乱

@Test
public void test11() {

    // 打乱数组: 实现比较麻烦，思路是先将数组转为List，然后打乱，然后再转为数组
    int[] a = {1, 2 , 3, 4, 5};
    /*
     * int[] 转 List<Integer>
     * 1.使用 Arrays.stream 将 int[] 转换成 IntStream。
     * 2.使用 IntStream中 的 boxed() 装箱。将 IntStream 转换成 Stream<Integer>。
     * 3.使用 Stream 的 collect()，将 Stream<T> 转换成 List<T>，因此正是 List<Integer>。
     */
    List<Integer> list = Arrays.stream(a).boxed().collect(Collectors.toList());
    Collections.shuffle(list);
    /*
     * List<Integer> 转 int[]
     * 1.想要转换成 int[] 类型，就得先转成 IntStream。
     *   这里就通过 mapToInt() 把 Stream<Integer> 调用 Integer::valueOf 来转成 IntStream
     * 2.而 IntStream 中默认 toArray() 转成 int[]。
     */
    a = list.stream().mapToInt(Integer::valueOf).toArray();
    System.out.println(Arrays.toString(a));


    // 打乱 ArrayList
    ArrayList<Integer> b = new ArrayList<>(Arrays.asList(1, 2 , 3, 4, 5));
    Collections.shuffle(b);
    System.out.println(b);
}

sort

@Test
public void test12() {

    // 对数组进行排序
    int[] a = {3, 1, 4, 5, 2};
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));  // [1, 2, 3, 4, 5]
    Integer[] arr = new Integer[a.length];  // 对数组自定义比较运算需要先转为包装类
    for (int i = 0; i < a.length; i++) arr[i] = a[i];
//        Arrays.sort(arr, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o2 - o1;
//            }
//        });
    Arrays.sort(arr, (o1, o2) -> o2 - o1);
    System.out.println(Arrays.toString(arr));  // [5, 4, 3, 2, 1]

    // 对 ArrayList 排序
    System.out.println("=======================");
    ArrayList<Integer> t = new ArrayList<>(Arrays.asList(3, 1, 4, 5, 2));
    Collections.sort(t);
    System.out.println(t);  // [1, 2, 3, 4, 5]
    
    // 对String进行排序
    String s = "dcab43210";
    char[] cs = s.toCharArray();
    Arrays.sort(cs);
    String res = new String(cs);
    System.out.println(res);  // 01234abcd

    // 对自定义的类排序
    // 两种方式：(1) 传入比较函数; (2) 继承Comparable接口，重写compareTo方法
    System.out.println("=======================");
    class Rec implements Comparable<Rec> {
        int x, y;
        public Rec(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public int compareTo(Rec o) { return this.x - o.x; }  // this在前：升序
        @Override
        public String toString() { return "Rec{" + "x=" + x + ", y=" + y + '}'; }
    }
    ArrayList<Rec> r = new ArrayList<>();
    for (int i = 0; i < 4; i++) r.add(new Rec(-i, i));
    // 方式(1)
    Collections.sort(r, (o1, o2) -> o1.x - o2.x);  // o1在前：升序
    System.out.println(r);  // [Rec{x=-3, y=3}, Rec{x=-2, y=2}, Rec{x=-1, y=1}, Rec{x=0, y=0}]
    // 方式(2)
    Collections.sort(r);
    System.out.println(r);  // [Rec{x=-3, y=3}, Rec{x=-2, y=2}, Rec{x=-1, y=1}, Rec{x=0, y=0}]
}

lower_bound/upper_bound

@Test
public void test13() {

    // java 中不存在这两个函数，可以自己实现
    int[] a = {1, 2, 4, 5, 6};
    System.out.println(lower_bound(a, 4));  // 4
    System.out.println(lower_bound(a, 8));  // null
    System.out.println(upper_bound(a, 4));  // 5
    System.out.println(upper_bound(a, 6));  // null
}

// 返回 a 中大于等于 x 的最小元素
public Integer lower_bound(int[] a, int x) {
    int l = 0, r = a.length;
    while (l < r) {
        int mid = l + r >> 1;
        if (a[mid] >= x) r = mid;
        else l = mid + 1;
    }
    if (r == a.length) return null;
    return a[r];
}

// 返回 a 中大于 x 的最小元素
public Integer upper_bound(int[] a, int x) {
    int l = 0, r = a.length;
    while (l < r) {
        int mid = l + r >> 1;
        if (a[mid] > x) r = mid;
        else l = mid + 1;
    }
    if (r == a.length) return null;
    return a[r];
}

nth_element

@Test
public void test14() {

    // java 中不存在nth_element，可以自己实现
    int[] a = {6, 2, 1, 4, 3, 5};
    int k = 2;  // a[1]已经被排到正确的位置上(递增序)，第二小的数
    System.out.println(quick_sort(a, 0, a.length - 1, k));  // 2
    for (int x : a) System.out.print(x + " ");
    System.out.println();
}

// 返回 q[l...r]中第k小的数据
public int quick_sort(int[] q, int l, int r, int k) {

    if (l == r) return q[l];

    int x = q[l], i = l - 1, j = r + 1;
    while (i < j) {
        while (q[++i] < x) ;
        while (q[--j] > x) ;
        if (i < j) {
            int t = q[i]; q[i] = q[j]; q[j] = t;
        }
    }

    int sl = j - l + 1;
    if (k <= sl) return quick_sort(q, l, j, k);
    return quick_sort(q, j + 1, r, k - sl);
}

补充

格式相互转换

int[] nums = {4, 2, 6, 7};
// 输出数组中元素
System.out.println(Arrays.toString(nums));
// 求数组最值、求和
int min = Arrays.stream(nums).max().getAsInt();
int max = Arrays.stream(nums).min().getAsInt();
int s = Arrays.stream(nums).sum();
// List<Integer> 转 int[]
List<Integer> a = Arrays.asList(2, 1, 5, 4);
int[] b = a.stream().mapToInt(Integer::valueOf).toArray();
// List<int[]> 转 int[][]
List<int[]> c = Arrays.asList(new int[]{1, 3}, new int[]{4, 2});
int[][] d = c.toArray(new int[0][0]);
// int[] 转 List<Integer>
int[] e = {4, 2, 1, 6};
List<Integer> f = Arrays.stream(e).boxed().collect(Collectors.toList());

生成随机数

@Test
public void test15() {
    // 设置随机种子的话可以保证每次运行程序生成的序列时一致的
    // 不同于C++, 如果不设置随机种子，每次运行得到的序列时不同的
    Random r = new Random();
    System.out.println(r.nextInt());
    System.out.println(r.nextInt());

    // 生成[0, x)范围的随机数据
    int x = 15;
    System.out.println(r.nextInt(x));

    System.out.println("-------------------------------------");
    int a = 5, b = 6;
    // 生成[a, b)范围的随机数据
    System.out.println(r.nextInt(b - a) + a);
    // 生成(a, b]范围的随机数据
    System.out.println(r.nextInt(b - a) + a + 1);
    // 生成[a, b]范围的随机数据
    System.out.println(r.nextInt(b - a + 1) + a);
    System.out.println("-------------------------------------");
    // 生成[a, b)范围的随机数据
    System.out.println((int) (Math.random() * (b - a) + a));
    // 生成(a, b]范围的随机数据
    System.out.println((int) (Math.random() * (b - a) + a + 1));
    // 生成[a, b]范围的随机数据
    System.out.println((int) (Math.random() * (b - a + 1) + a));

    System.out.println("-------------------------------------");
    // 生成[0.0, 1,0)范围的随机数据
    System.out.println(Math.random());
}