总结算法题中一些常用的Java方法

一、String

charAt()
charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。

string.charAt(i); // i为索引, 索引范围为 0 到 length() - 1
1

length()
length() 方法用于返回字符串的长度。空字符串的长度返回 0。

string.length();
1

将String字符串转化成char数组

char[] chars = string.toCharArray();
1

char数组转String

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

String 多个空格转一个空格

String str = "abc    def   ghi     jkl";

str = str.replaceAll("\\s+", " ");
1
2
3

删除某个位置的字节

String str = "abc";

str.deleteCharAt(index);
1
2
3

栈相关

1.初始化

Stack<?> stack = new Stack();
1

2.测试堆栈是否为空

boolean isEmpty()
1

3.查看堆栈顶部的对象，但不从堆栈中移除它

Object peek()
1

4.移除堆栈顶部的对象，并作为此函数的值返回该对象

Object pop()
1

5.项压入堆栈顶部

Object push(Object element)
1

6.返回对象在堆栈中的位置，以 1 为基数

int search(Object element)
1

数组相关

1. 数组的长度

array.length 
1

2. 数组的排序

Arrays.sort(array);
1

3. 二维int类型数组的排序按首个数字升序排序

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

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

Arrays.sort(intervals, (o1, o2) -> {
            if (o1[0] == o2[0]) {
                return o2[1] - o1[1];
            }
            return o1[0] - o2[0];
        });
1
2
3
4
5
6
7
8

4. 用于一维数组、二维数组的初始化或者填充 (例: 将数组array的数据填充为1)

Arrays.fill(array, 1);
1

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

Arrays.copyOf(array,  11);
1

List相关

列表的尾部插入指定元素

list.add(Object o);
1

列表的尾部移除元素(一般用于dfs算法 进行回溯)

list.remove(list.size() - 1);
1

判断集合中是否存在这个元素

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

集合的拷贝

使用List实现类的构造方法

List<Integer> destList = new ArrayList<Intger>(srcList);  
1

数组转list

List<String> list = Arrays.asList("张三","李四")
1

集合排序

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

注意: 一般dfs类型的算法, 集合类的用的比较多

// 一般常见的算法题中,需要对List list进行排序,在判断是否存在于List> res中
// 所以一般做法是:

// 如果满足条件
if(// 条件成立) {
　　List<Intger> tmp = new ArrayList(list); 

　　Collections.sort(tmp);

　　if(!res.contains(tmp)) { // 判断结果集是否重复
　　　　res.add(tmp);
　　}else {
　　　　return;
}

}

// 筛选候选节点
list.add(o);
dfs(...);
list.remove(list.size() - 1);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

集合遍历

//使用com.google.guava包创建集合
    List<String> list =Lists.newArrayList("a","b","c","d");
 
    //1、正常遍历
    list.forEach(item->System.out.println(item));
    //2、根据条件遍历
    list.forEach(item->{
        if("b".equals(item)){
            System.out.println(item);
        }
1
2
3
4
5
6
7
8
9
10

queue相关

这类主要是BFS算法使用较多:

初始化

Queue<Integer> queue = new LinkedList();
1

添加元素

queue.offer(Object o);
1

删除队列中的第一个元素

queue.poll(Object o); // 返回队列的第一个元素
1

判断是否为空

queue.isEmpty();
1

获取队列的大小

queue.size();
1

Map相关

获取指定键的值

map.get(Object o);
1

添加一个映射

put(K key, V value)  
1

Map是否包含指定的key使用containsKey方法

containsKey(Object key)   如果此映射包含指定键的映射关系，则返回 true
1

Map判断是否包含指定的value使用containsValue方法

containsValue(Object value)  如果此映射将一个或多个键映射到指定值，则返回 true
1

Map是否包含集合数据

isEmpty()  如果此映射未包含键-值映射关系，则返回 true
1

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());
}
1
2
3
4
5
6
7

目前LeetCode算法题中,常用的一些JAVA的方法先总结到这! 后续不断更新!

​