刷题时常用的函数（持续补充ing）

刷题时常用的函数（Java版本）

字符串

字符串的翻转

有两种方式

1. 将字符串转换为字符数组

//将字符串转换为字符数组
char[] arr = str.toCharArray();
//调用翻转函数(自定义的)
public void reverseStr(char[] arr, int start, int end){
	for(int i=start, j=end;i<j;i++,j--){
		char temp =arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
}
这里实际是将字符数据进行了翻转，翻转之后
char[] arr1 = reverseStr(arr,0,arr.length-1);
再将字符数组转换为字符串
return new String(arr1);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 采用StringBuilder的setCharAt()函数，最后将StringBuilder转换为字符串的形式

StringBuilder sb = new StringBuilder();
sb.append(str); //把要翻转的字符串先转换为StringBuilder
然后
public void reverseStr(StringBuilder sb, int start, int end){
	for(int i=start, j= end;i<j;i++,j--){
		char temp=sb.charAt(i);
		sb.setCharAt(i,sb.charAt(j));
		sb.setCharAt(j,temp);
	}
}
String s = sb.toString();
再将StringBuilder转换为字符串


也可以直接通过库函数
sb.reverse()进行转换。
注意转换后是StringBuilder的形式，所以还要再转换为String，所以sb.reverse().toString();这样就可以进行翻转。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

字符串与数组之间的转换

1. 字符串转数组

String s;
char[] arr =s.toCharArray();
1
2

2. 数组转字符串

char[] arr= new char[count];
string s = new String(arr);
1
2

StringBuilder

StringBuilder，StringBuffer的对象可以被修改，但是String的对象不能被修改
这也是为什么在字符串翻转的时候要将字符串转换为StringBuilder处理。

StringBuilder 的常用操作参考：
https://www.runoob.com/java/java-stringbuffer.html

        StringBuilder sb1 = new StringBuilder();
        sb1.append("hello java");
        sb1.insert(5,"HERE");//helloHERE java
        System.out.println(sb1.toString());
        sb1.append("!!");//helloHERE java!!
        System.out.println(sb1.toString());
        sb1.delete(5,8);//helloE java!!
        System.out.println(sb1.toString());
1
2
3
4
5
6
7
8

insert也是从0开始数，在第i处放置插入的元素
这里的delete就是从头开始按0开始数，把第6个元素到8个元素删除，8其实就是删除到8前。

List 和数组相互转换

1. list转数组

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
int[] arr = new int[list.size()];
for(int i=0;i<list.size();i++){
	arr[i]=list.get(i);
}
1
2
3
4
5
6
7

2. 数组转list

        Integer[] arrs1 = new Integer[2];
        List<Integer> list2 = new ArrayList<Integer>(Arrays.asList(arrs1));
        
        String[] arrs = new String[3];
        List list1 = new ArrayList<String>(Arrays.asList(arrs));
1
2
3
4
5

3.List排序
ArrayList.sort(Comparator.naturlOrder());

        List<Integer> s2=new ArrayList<>();
        s2.add(-1);
        s2.add(-2);
        s2.add(0);
        s2.add(-4);
        s2.add(1);
        System.out.println(s2);
        s2.sort(Comparator.naturalOrder());
        System.out.println(s2);
结果
[-1, -2, 0, -4, 1]
[-4, -2, -1, 0, 1]
1
2
3
4
5
6
7
8
9
10
11
12

HashSet去重

		Set<Integer> set1 = new HashSet<>();
        set1.add(1);
        set1.add(1);
        set1.add(2);
        int[] aa = set1.stream().mapToInt(x -> x).toArray();
        for (int i = 0; i < aa.length; i++) {
            System.out.println(aa[i]);//1 2
        }
1
2
3
4
5
6
7
8

HashMap

HashMap是无序的不会记录插入的顺序

import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        // 输出 key 和 value
        for (Integer i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
        // 返回所有 value 值
        for(String value: Sites.values()) {
          // 输出每一个value
          System.out.print(value + ", ");
        }
    }
}
//输出
key: 1 value: Google
key: 2 value: Runoob
key: 3 value: Taobao
key: 4 value: Zhihu
Google, Runoob, Taobao, Zhihu,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

使用entrySet遍历HashMap

        Map<Integer,String> maps=new HashMap<>();
        maps.put(1,"he");
        maps.put(2,"fd");
        maps.put(3,"dsa");
        for(Map.Entry<Integer,String> entry: maps.entrySet()){
            System.out.println("key "+entry.getKey()+" value "+entry.getValue());
        }
        //输出
        key 1 value he
		key 2 value fd
		key 3 value dsa
1
2
3
4
5
6
7
8
9
10
11

栈与队列

栈

Stack<Integer> stacks = new Stack<>();
stack.push(1);
stack.pop();//弹出栈顶元素
stack.peek();//获取栈顶元素但是不弹出
1
2
3
4

队列

Queue<Integer> queue = new LinkedList<Integer>();
queue.offer(1);
queue.poll();//弹出
queue.peek();//获取队列头元素，不出队
queue.element();//获取队列头元素，不出队
1
2
3
4
5