博客 / 詳情

返回

Java算法題常用函數

Java算法題常用函數

String 字符串

  1. charAt(int index)方法用於返回指定索引處的字符。索引範圍為從 0 到 length() - 1。

  2. length() 方法用於返回字符串的長度。空字符串的長度返回 0。

  3. 將String字符串轉化成char數組

    char[] chars = string.toCharArray();

  4. char數組轉String

    new String (charArray); // charArray => char[] charArray

  5. 返回一個新字符串，它是此字符串的一個子字符串

    String sub = str.substring(int start, int end)

  6. 指定字符在此字符串中第一次出現處的索引

    str.indexOf(int ch)

  7. 刪除字符串前後的空白符

    str.trim()

StringBuffer/StringBuilder

  • 在使用 StringBuffer 類時，每次都會對 StringBuffer 對象本身進行操作，而不是生成新的對象，所以如果需要對字符串進行修改推薦使用 StringBuffer。

  • StringBuilder 類在 Java 5 中被提出，兩者最大不同在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。

  • 由於 StringBuilder 相較於 StringBuffer 有速度優勢，所以多數情況下建議使用 StringBuilder 類。

  1. 初始化

    StringBuilder sb = new StringBuilder(length)

  2. 返回長度（字符數）

    sb.length()

  3. 將指定的字符串追加到此字符序列

    sb.append(String s)

  4. 將此字符序列用其反轉形式取代

    sb.reverse()

  5. 返回一個新的 String，它包含此序列當前所包含的字符子序列

    sb.substring(int start, int end)

  6. 轉換成String

    String str = sb.toString();

Stack 棧

  1. 初始化

    Stack<?> stack = new Stack();

  2. 判斷堆棧是否為空

    stack.isEmpty()

  3. 查看堆棧頂部的對象，但不從堆棧中移除它

    stack.peek()

  4. 移除堆棧頂部的對象，並作為此函數的值返回該對象

    stack.pop()

  5. 元素壓入堆棧頂部

    stack.push()

  6. 返回對象在堆棧中的位置，以 1 為基數

    int pos = stack.search()

Array 數組

  1. 初始化長度為size的數組

    int[] array = new int[size]

  2. 數組長度

    array.length

  3. 數組的排序

    Arrays.sort(array)

  4. 二維int類型數組的排序按首個數字升序排序 (lambda表達式寫法)

    Arrays.sort(array, (v1, v2) -> v1[0] - v2[0])

    ps: 匿名內部類寫法

    Arrays.sort(array, new Comparator<int[]>() {
    @Override
    public int compare(int[] v1, int[] v2) {
        // 與 Lambda 表達式邏輯完全一致
        return v1[0] - v2[0];
    }
});

  5. 當區間左端點相同的時候，按照右端點降序排序

    Arrays.sort(intervals, (o1, o2) -> {
    if(o1[0] == o2[0]){
        return o1[1] - o2[1];
    }
    return o2[0] - o1[0];
});

  6. 用於一維數組的初始化或者填充

    Arrays.fill(array, 1);

  7. 複製新數組,並指定長度 (例: 將數組array複製一個新數組, 並指定長度為length)

    int[] copy = Arrays.copyOf(array, length)

List 列表

  • 以下情況使用 ArrayList :

    • 頻繁訪問列表中的某一個元素（隨機訪問）。

    • 只需要在列表末尾進行添加和刪除元素操作。

  • 以下情況使用 LinkedList :

    • 你需要通過循環迭代來訪問列表中的某些元素。
    • 需要頻繁的在列表開頭、中間、末尾等位置進行添加和刪除元素操作。

  1. 初始化

    List<T> list = new LinkedList<>();
List<T> list = new ArrayList<>();

  2. 列表的尾部插入指定元素

    list.add(Object o);

  3. 列表的尾部移除元素(一般用於dfs算法 進行回溯)

    list.remove(list.size() - 1); //刪除最後一個元素

  4. 判斷集合中是否存在這個元素

    list.contains(Object o); // 返回true 或 false

  5. 將數組轉為List

    List<String> names = Arrays.asList(new String[]{"zhangsan","li"});

    • List轉為數組

      T[] array = list.toArray();

  6. 集合排序

    Collections.sort(list); // 返回值為void

Queue 隊列

  1. 初始化

    Queue<Integer> queue = new LinkedList()

  2. 添加元素

    queue.offer(Object o);

  3. 刪除隊列中的第一個元素

    queue.poll(Object o); // 返回隊列的第一個元素

  4. 判斷是否為空

    queue.isEmpty();

  5. 獲取隊列的大小

    queue.size();

PriorityQueue 優先隊列

  • 優先級隊列並不是隊列中所有的元素都是按照優先級排放的，只能保證出隊順序是按照優先級進行的

  1. 初始化

    Queue<Integer> queue = new PriorityQueue<>((a, b) -> b - a);

Map/HashMap

  • Map是接口，HashMap是具體實現

  • HashMap 實現了 Map 接口，根據鍵的 HashCode 值存儲數據，具有很快的訪問速度，最多允許一條記錄的鍵為 null，不支持線程同步。

  1. 初始化

    Map<T, T> map = new HashMap();

  2. 獲取指定鍵的值

    map.get(Object o);

  3. 添加一個映射

    map.put(K key, V value)

  4. 是否包含指定的key

    containsKey(Object key) \\如果此映射包含指定鍵的映射關係，則返回 true

  5. 是否包含指定的value

    containsValue(Object value) \\如果此映射將一個或多個鍵映射到指定值，則返回 true

  6. Map遍歷

    Map<String, Integer> map = new HashMap();
map.put("zhangsan",1);
map.put("li",2);
map.put("wangwu",2);
for (Map.Entry<String, Integer> m: map.entrySet()) {
    System.out.println("姓名: "+m.getKey()+" 編號: "+m.getValue());
}

HashSet 集合

  • HashSet 基於 HashMap 來實現的，是一個不允許有重複元素的集合。

  • HashSet 允許有 null 值。

  1. 初始化

    HashSet<T> set = new HashSet<>();

  2. 添加元素

    set.add(Object o);

  3. 判斷元素是否存在

    set.contains(Object o);

  4. 刪除元素

    set.remove(Object o);\

  5. 計算元素數量

    set.size()

  6. 迭代

    public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Runoob");     // 重複的元素不會被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}
後端
user avatar
0 位用戶收藏了這個故事！

發佈 評論

Some HTML is okay.