Java算法题常用函数详解

Java算法题常用函数

String 字符串

• charAt(int index)方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。
• length() 方法用于返回字符串的长度。空字符串的长度返回 0。
• 将String字符串转化成char数组
• char[] chars = string.toCharArray();
• char数组转String
• new String (charArray); // charArray => char[] charArray
• 返回一个新字符串，它是此字符串的一个子字符串
• String sub = str.substring(int start, int end)
• 指定字符在此字符串中第一次出现处的索引
• str.indexOf(int ch)
• 删除字符串前后的空白符
• str.trim()

StringBuffer/StringBuilder

• 在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
• StringBuilder 类在 Java 5 中被提出，两者最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
• 由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
• 初始化
• StringBuilder sb = new StringBuilder(length)
• 返回长度（字符数）
• sb.length()
• 将指定的字符串追加到此字符序列
• sb.append(String s)
• 将此字符序列用其反转形式取代
• sb.reverse()
• 返回一个新的 String，它包含此序列当前所包含的字符子序列
• sb.substring(int start, int end)
• 转换成String
• String str = sb.toString();

Stack 栈

• 初始化
• Stack<?> stack = new Stack();
• 判断堆栈是否为空
• stack.isEmpty()
• 查看堆栈顶部的对象，但不从堆栈中移除它
• stack.peek()
• 移除堆栈顶部的对象，并作为此函数的值返回该对象
• stack.pop()
• 元素压入堆栈顶部
• stack.push()
• 返回对象在堆栈中的位置，以 1 为基数
• int pos = stack.search()

Array 数组

• 初始化长度为size的数组
• int[] array = new int[size]
• 数组长度
• array.length
• 数组的排序
• Arrays.sort(array)
• 二维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];
    }
});

当区间左端点相同的时候，按照右端点降序排序

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

用于一维数组的初始化或者填充

Arrays.fill(array, 1);

复制新数组,并指定长度 (例: 将数组array复制一个新数组, 并指定长度为length)

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

List 列表

• 以下情况使用 ArrayList :
  • 频繁访问列表中的某一个元素（随机访问）。
  • 只需要在列表末尾进行添加和删除元素操作。
• 以下情况使用 LinkedList :
  • 你需要通过循环迭代来访问列表中的某些元素。
  • 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
• 初始化

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

• 列表的尾部插入指定元素
• list.add(Object o);
• 列表的尾部移除元素(一般用于dfs算法 进行回溯)
• list.remove(list.size() - 1); //删除最后一个元素
• 判断集合中是否存在这个元素
• list.contains(Object o); // 返回true 或 false
• 将数组转为List
• List<String> names = Arrays.asList(new String[]{"zhangsan","li"});
• List转为数组
• T[] array = list.toArray();
• 集合排序
• Collections.sort(list); // 返回值为void

Queue 队列

• 初始化
• Queue<Integer> queue = new LinkedList()
• 添加元素
• queue.offer(Object o);
• 删除队列中的第一个元素
• queue.poll(Object o); // 返回队列的第一个元素
• 判断是否为空
• queue.isEmpty();
• 获取队列的大小
• queue.size();

PriorityQueue 优先队列

• 优先级队列并不是队列中所有的元素都是按照优先级排放的，只能保证出队顺序是按照优先级进行的
• 初始化

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

Map/HashMap

• Map是接口，HashMap是具体实现
• HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。
• 初始化
• highlighter- lasso

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

• 获取指定键的值
• map.get(Object o);
• 添加一个映射
• map.put(K key, V value)
• 是否包含指定的key
• containsKey(Object key) \\如果此映射包含指定键的映射关系，则返回 true
• 是否包含指定的value
• containsValue(Object value) \\如果此映射将一个或多个键映射到指定值，则返回 true
• 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 值。
• 初始化
• HashSet<T> set = new HashSet<>();
• 添加元素
• set.add(Object o);
• 判断元素是否存在
• set.contains(Object o);
• 删除元素
• set.remove(Object o);\
• 计算元素数量
• set.size()
• 迭代

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);
        }
    }
}

到此这篇关于Java算法题常用函数 的文章就介绍到这了,更多相关java算法常用函数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！