java中由util提供的常用基础数据结构

前言：本文只总结了常用的，已经提供好的接口方法。所有方法基于java.util包

例如树、图这种抽象数据结构需要自己定义class实现

 

import java.util.*;

public class EasyForDataStructure {
    public static void main(String[] args) {
        /*
            基础数据类型通过this.length获取长度，此外大部分引用数据类型方法都包含了this.length()或this.size()获取长度
            几乎每个引用数据类型都包含了isEmpty()（是否为空？）contains()（是否包含？）
        */
        //基础数据类型-数组
        arr();
        // 集合类的升序降序
        collections();
        // 引用数据类型-list，以最常用的arraylist为例
        list();
        // 引用数据类型-map，以最常用的hashmap为例
        map();
        // 引用数据类型-set，以最常用的hashset为例
        set();
        // 引用数据类型-queue、stack，这里使用deque（双端队列包含了栈与队列的特性）
        deque();
        // 引用数据类型-String常用方法
        string();
        // 额外补充，格式化输出
        format();
    }

    // 常用对数组操作的方法
    public static void arr() {
        int[] arr = new int[10];
        int length = arr.length;//获取数组长度
        Arrays.sort(arr);//对数组进行排序,升序
        Arrays.fill(arr, 1);//将数组全部填充为1，DP常用
    }

    // 集合类常用方法-升序降序排序
    public static void collections() {
        List<Integer> list = new ArrayList<>();
        Collections.sort(list);//升序排序
        Collections.reverse(list);//降序排序，这个是jdk17里的
    }

    public static void list() {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);//添加元素
        int size = arrayList.size();//获取长度
        arrayList.remove(1);//删除元素，这里是移除下标为1的数据
        arrayList.get(1);//获取元素，同上是获取下标
        arrayList.indexOf(1);//获取元素索引，这里是最低索引
        arrayList.sort((a, b) -> a - b);//lambda表达式，升序排序。输出为1 2 3 4
        arrayList.sort((a, b) -> b - a);//lambda表达式，降序排序。输出为4 3 2 1
        arrayList.sort(new Comparator<Integer>() {//不用lambda表达式的升序排序
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
    }

    public static void map() {
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        hashMap.put(1, 1);//添加元素
        hashMap.get(1);//根据K获取V
        hashMap.remove(1);//根据K移除元素
        boolean containsKey = hashMap.containsKey(1);//判断是否包含K
        boolean containsValue = hashMap.containsValue(1);//判断是否包含V
        //map的遍历-这里只写遍历键值对即可，因为他覆盖了只遍历键和只遍历值的情况
        for (Map.Entry<Integer, Integer> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

    public static void set() {
        //这里记一下set的特性：自动去重，无序
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.add(1);//添加元素
        int size = hashSet.size();
        boolean contains = hashSet.contains(1);//判断是否包含元素
        hashSet.remove(1);//移除元素
    }

    public static void deque() {
        //结合了先进先出和先进后出的特性，两头随便取的双端队列
        Deque<Integer> deque = new LinkedList<>();
        deque.offerFirst(1);//前端插入
        Integer peek = deque.peek();//前端检查第一个元素，不弹出
        deque.pollFirst();//前端弹出元素

        deque.offerLast(1);//后端插入
        peek = deque.peekLast();//后端检查第一个元素，不弹出
        deque.pollLast();//后端弹出元素
        boolean contains = deque.contains(1);//判断是否包含元素
    }

    public static void string() {
        String str = "123456789";
        for (int i = 0; i < str.length(); i++) {
            str.charAt(i);//获取指定下标的字符
        }
        str.substring(1, 3);//截取字符串，左闭右开,这里截取的是23
        str.replaceAll("1", "2");//替换字符串，这里将1替换为2
        str.toLowerCase();//小写转换
        str.toUpperCase();//大写转换
        str.trim();//去除首尾空格，如果有更多的空格去除要求，灵活使用replaceAll
        String[] split = str.split(",");//根据","分割字符串，返回一个字符串数组
        //有些字符串累加问题。string被final修饰，是不可变量，频繁创建会造成大量开销，因此引入了StringBulider
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("123");//追加字符串
        String string = stringBuilder.toString();
    }

    public static void format() {
        int num = 123;
        double value = 123.456789;
        System.out.printf("Number: %5d%n", num); // 输出: Number:   123
        System.out.printf("Value: %.3f%n", value); // 输出: Value: 123.457
    }

}