java刷题前常用的数据结构及方法_java刷题常用方法

int到string数据类型转换

public class HelloWorld {
    public static void main(String[] args) {
        // 引号带上数据
        int num=100;
        String a=""+num;
        System.out.println(a);

        // 直接类型转换
        Integer num2=100;
        String b=Integer.toString(num2);
        System.out.println(b);
        
        // Integer的构造方法
        Integer o =new Integer(num);
        String h=o.toString();
        System.out.println(h);

        // 字符串定义
        String c=String.valueOf(num2);
        System.out.println(c);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

String转换为int类型

		// Integer的方法intValue
        String s="100";
        Integer i=new Integer(s);
        int d=i.intValue();
        System.out.println(d);

        // parseInt
        // 加上static的方法，方法属于类，需要使用类名进行调用，没有加上static的，方法属于对象，可以new一个对象再调用
        int e=Integer.parseInt(s);
        System.out.println(e);
1
2
3
4
5
6
7
8
9
10

ArrayList动态数组转换为数组

ArrayList中有以下方法，可以用来转换数组
<T> T[] toArray​(T[] a)// 以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

import java.util.ArrayList;
import java.util.List;

public class HelloWorld {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("Kerun");
        list.add("AAA");
        list.add("BBB");

        int size=list.size();
        String [] array=list.toArray(new String[size]);
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

除此之外，ArrayList还有以下的常用的方法：

• void add​(int index, E element) 将指定元素插入此列表中的指定位置。
• boolean add​(E e)将指定的元素追加到此列表的末尾。
• boolean contains​(Object o)如果此列表包含指定的元素，则返回 true 。
• E get​(int index) 返回此列表中指定位置的元素。
• int indexOf​(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
• boolean isEmpty() 如果此列表不包含任何元素，则返回 true 。
• int lastIndexOf​(Object o)返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
• E remove​(int index) 删除此列表中指定位置的元素。
• boolean remove​(Object o)从该列表中删除指定元素的第一个匹配项（如果存在）
• E set​(int index, E element) 用指定的元素替换此列表中指定位置的元素。
• int size() 返回此列表中的元素数。

数组转换为动态数组ArrayList类型

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class HelloWorld {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("Kerun");
        list.add("AAA");
        list.add("BBB");

        int size=list.size();
        String [] array=list.toArray(new String[size]);
        for (int i = 0; i < size; i++) {
            System.out.println(array[i]);
        }

        List<String> list2= Arrays.asList(array);
        for (int j = 0; j < list2.size(); j++) {
            System.out.println(list2.get(j));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• Arrays是一个很常用的数组类，碎玉数组的各种操作，包括赋值、排序、搜索都可以使用Arrays类调用方法来使用，Arrays类大多数的方法都是静态方法，并且都是针对与不同的数据类型有相同的方法，常见的包括：
  toString、sort（默认升序排序）、fill、equals、copyof、compare、binarySearch等。
• Collections常用来对list和set进行操纵，常用的包括static void reverse​(List<?> list) 反转指定列表中元素的顺序。

import java.util.*;

public class HelloWorld {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("Hello");
        list.add(" ");
        list.add("world");

        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[Hello,  , world]
[world,  , Hello]
1
2

String类

字符串类，拥有各种构造方法以及各种方法的类，可以把各种数据类型通过字符串的构造方法，转换为字符串类型。常用的方法包括：

• char charAt​(int index) 返回指定索引处的 char值。
• int indexOf​(int ch) 返回指定字符第一次出现的字符串中的索引。
  - boolean isEmpty() ，当且仅当， length()是 0 返回 true
• int lastIndexOf​(int ch) 返回指定字符最后一次出现的字符串中的索引。
• int length() 返回此字符串的长度。
• String replace​(CharSequence target, CharSequence replacement) 将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。
• String replaceAll​(String regex, String replacement) 将给定替换的给定 regular expression匹配的此字符串的每个子字符串替换。
• String[] split​(String regex) 将此字符串拆分为给定 regular expression的匹配 项 。
• boolean startsWith​(String prefix) 测试此字符串是否以指定的前缀开头。
• String substring​(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。
• char[] toCharArray() 将此字符串转换为新的字符数组。
• String toLowerCase() 使用默认语言环境的规则将此 String所有字符转换为小写。
• String toUpperCase() 使用默认语言环境的规则将此 String所有字符转换为大写。

字符类Character

字符类在对象中包装基本类型char的值，当类型为Character的对象包含单个字段的时候，其类型为char类型。此外这个类提供了几种方法来确定字符的类别（字母还是数字还是其他的）以及将字符从大写转换为小写。该类大多数的方法都是静态方法。常用的方法包括：

• static int compare​(char x, char y) 以数字方式比较两个 char值。
• boolean equals​(Object obj) 将此对象与指定的对象进行比较。
• static boolean isDigit​(char ch) 确定指定的字符是否为数字。
• static boolean isLetter​(char ch) 确定指定的字符是否为字母。
• static boolean isLowerCase​(char ch) 确定指定的字符是否为小写字符。
• static boolean isUpperCase​(char ch) 确定指定的字符是否为大写字符。
• static String toString​(char c) 返回表示指定的 char的 String对象。
• static Character valueOf​(char c) 返回表示指定的 char值的 Character实例。

字符串构造器StringBuilder

StringBuilder是一个可变的字符序列，可以提供与StringBuffer兼容的API但是不保证呢个同步，这个类是StringBuffer的替代品。这个类主要的操作是append和insert方法，这些方法被重载以便接受任何类型的数据，每个偶读有效地将给定的数据转换为字符串。append方法始终在构造器的末尾添加字符；insert方法在指定点添加字符，主要语法如下：

• StringBuilder append​(DataType b) 将b追加到字符串序列的末尾
• StringBuilder insert​(int offset, DataType d)表示在offset位置后面插入数据d

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class HelloWorld {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb);

        sb.append(1).append('2').append("3").append(true).append("hello world".toCharArray(),1,3);// 按照下标
        System.out.println(sb);
        sb.insert(7,' ');// 按照个数
        System.out.println(sb);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

123trueell
123true ell
1
2
3

双链表LinkList

双链表实现了List和Deque接口，实现所有可选列表操作，使用双链表，所有操作都可以预期，索引到列表中的操作可以从开头或者结尾遍历列表，这个要以比较接近指定索引为准。常用的方法包括：

• boolean isEmpty()
• int size()
• boolean contains(Object o) // 判断链表中是否存在元素o 复杂度O(N)
• void addFirst(E e)
• E removeFirst() //删除，返回的是删除的元素
• E getFirst/Last()
• int indexOf( E e)
• Collections.reverse(link); // 翻转链表

哈希表Hashmap

基于哈希表的map接口的实现，这个实现提供了所有可选的映射操作，并且允许null值和null键。常用方法包括（K：键的类型，V：值的类型）

• boolean containsKey(Object key)如果这个映射包含指定键映射，则返回true
• boolean containsValue​(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true 。
• V get​(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
• V put​(K key, V value) 将指定的值与此映射中的指定键相关联。
• V remove​(Object key) 从此映射中删除指定键的映射（如果存在）。
• int size() 返回此映射中键 - 值映射的数量。
• Collection<V> values() 返回此映射中包含的值的Collection视图。
• Set<K> keySet() 返回此映射中包含的键的Set视图。
• default V getOrDefault​(Object key, V defaultValue) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 defaultValue 。这个方法继承自Map接口
• default V putIfAbsent​(K key, V value) 如果key存在则什么都不做，否则put()，并且返回当前值
• Set<Map.Entry<K,​V>> entrySet() 返回此映射中包含的映射的Set视图。

import java.util.*;

public class HelloWorld {
    public static void main(String[] args) {
        HashMap<Integer,String> hm=new HashMap<>();
        hm.put(0,"kerun");
        hm.put(10,"johnson");
        hm.put(2,"jeffer");
        hm.put(1,"sky");
        System.out.println(hm);// {0=kerun, 1=sky, 2=jeffer, 10=johnson}
        System.out.println(hm.containsKey(3));// false
        System.out.println(hm.containsValue("sky"));// true
        System.out.println(hm.get(1));// sky
        //删除
        System.out.println(hm.remove(1));// sky
        System.out.println(hm);// {0=kerun, 2=jeffer, 10=johnson}
        System.out.println(hm.getOrDefault(3,"default"));// default
        System.out.println(hm.putIfAbsent(3,"default"));// 因为3映射不存在，所以这里返回的是null，并且执行put(3,"default")
        System.out.println(hm);// {0=kerun, 2=jeffer, 3=default, 10=johnson}
        System.out.println(hm.putIfAbsent(0,"default"));// kerun

        Collection<String> value=hm.values();
        System.out.println(value);// [kerun, jeffer, default, johnson]
        Set<Integer> key=hm.keySet();
        System.out.println(key);// [0, 2, 3, 10]
        Set<Map.Entry<Integer,String>> entry=hm.entrySet();
        System.out.println(entry);// [0=kerun, 2=jeffer, 3=default, 10=johnson]
    }
}

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
29
30

哈希集合HashSet

不能保证集合迭代的顺序

• boolean add​(E e) 如果指定的元素尚不存在，则将其添加到此集合中。
• boolean remove​(Object o) 如果存在，则从该集合中移除指定的元素。
• boolean contains​(Object o) 如果此set包含指定的元素，则返回 true 。

堆栈 Stack

堆栈，后进先出

• boolean empty() 测试此堆栈是否为空。
• E peek() 查看此堆栈顶部的对象，而不将其从堆栈中删除。
• E pop() 移除此堆栈顶部的对象，并将该对象作为此函数的值返回。
• E push​(E item) 将项目推到此堆栈的顶部。
• int search​(Object o) 返回对象在此堆栈上的从1开始的位置。

import java.util.*;

public class HelloWorld {
    public static void main(String[] args) {
        Stack s=new Stack();
        System.out.println(s.empty());// true

        s.push(1);
        s.push("hhh");
        s.push(12.3);
        s.push('k');
        System.out.println(s);// [1, hhh, 12.3, k]

        System.out.println(s.peek());// k
        System.out.println(s.search("hhh"));// 3
        System.out.println(s.search('k'));// 1

        s.pop();
        System.out.println(s);// [1, hhh, 12.3]
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

队列Queue、双端队列Deque

队列，先进先出，Queue和Deque都是接口，而LinkedList类继承了这两个队列，可以是用LinkedList来实例化Queue或者Deque，可以作为单向队列或者双向队列来使用。

1. Queue q = new LinkedList<>();
   void add​(int index, E element) 将指定元素插入此列表中的指定位置。
   E element() 检索但不删除此列表的头部（第一个元素）。
   E get​(int index) 返回此列表中指定位置的元素。
   int indexOf​(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
   int lastIndexOf​(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
   boolean offer​(E e) 将指定的元素添加为此列表的尾部（最后一个元素）。
   E peek() 检索但不删除此列表的头部（第一个元素）
   E poll() 检索并删除此列表的头部（第一个元素）。
   E set​(int index, E element) 用指定的元素替换此列表中指定位置的元素。
   Collections.reverse(q) 翻转队列

2. Deque d = new LinkedList<>();
   void addFirst​(E e) 在此列表的开头插入指定的元素。
   void addLast​(E e) 将指定的元素追加到此列表的末尾。
   E getFirst() 返回此列表中的第一个元素。
   E getLast() 返回此列表中的最后一个元素。
   boolean offerFirst​(E e) 在此列表的前面插入指定的元素。
   boolean offerLast​(E e) 在此列表的末尾插入指定的元素。
   E peekFirst() 检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
   E peekLast() 检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
   E pollFirst() 检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
   E pollLast() 检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
   …

3. LinkedList可以作为堆栈使用，并且在类中实现了对应的方法
   E pop() 弹出此列表所代表的堆栈中的元素。
   void push​(E e) 将元素推送到此列表所表示的堆栈上。

优先队列PriorityQueue

基于优先级堆的无界优先级队列，优先级队列不允许null元素，优先队列可以保证每次取出的元素都是队列权值最小的，PriorityQueue通过用数组表示的小顶堆实现。常用的方法和Queue一样。