1、基本數據結構：

?數組（特別是二維數組，剛開始搞不清楚如何獲取行和列，以及初始化）：

//靜態初始化 int[] intArr = new int[]{1,2,3,4,5,6}; //簡化版 int[] intArr = {1,2,3,4,5,6};//動態初始化 int[] intArr = new int[6];//初始化二維數組 int[][] intMatrix = {{1,2},{3,4},{5,6}}; int[][] intMatrix = new int[3][2];//獲取數組長度 int rowLength = intMatrix.length;//行數 int colLength = intMatrix[0].length;//第0行列數

判斷最大值最小值

//Float Double Byte Character Short Integer Long Imax = Integer.MAX_VALUE; Imin = Integer.MIN_VALUE; java.lang.Math.max(參數1，參數2)是一個靜態的工具方法

Character

判斷一個字符是否是數字字符 Character.isDigit(char c) 是則返回true，不是則返回false；判斷一個字符時候是字母 Character.isLowerCase(char c)　|| Character.isUpperCase(char c) LowerCase是小寫，UpperCase是大寫；判斷一個字符是字母或數字 Character.isLetterOrDigit(char c)將字母轉換為大寫 Character.toUpperCase(char c);將字母轉換為小寫 Character.toLowerCase(char c);

String

String s = "asdefgasdefg"; for(int i = 0; i < s.length(); i++>){char c = s.charAt(i); } s.indexOf('s') //retrun 1 s.indexof('s',2) //return 7 s.lastIndexOf('s') //return 7 s.lastIndexOf('s',6)//return 1 string[] ss = s.split("regex"); //參數：beginIndex - 開始處的索引（包括）// endindex 結尾處索引（不包括）。 String s = s.substring((int)start,(int)end)//[start,end) char[] cs = s.toCharArray(); String s = s.toLowerCase(); String s = s.toUpperCase(); String s = s.trim(); String s = String.valueOf(object);

StringBuilder & StringBuffer
?

StringBuilder sb = new StringBuilder("String"); sb.append(""); sb.reverse(); sb.delete((int)start,(int)end); //[start,end) sb.deleteCharAt(int index); sb.insert((int)offset,"String"); sb.toString(); sb.setCharAt((int)index,(char)c);

數組排序

Arrays.sort()是經過調優排序算法，性能能達到n*log(n)Arrays.sort()重載了四類方法 sort(T[] a)：對指定T型數組按數字升序排序。 sort(T[] a,int formIndex, int toIndex)：對指定T型數組的指定范圍按數字升序排序。 sort(T[] a, Comparator<? supre T> c): 根據指定比較器產生的順序對指定對象數組進行排序。 sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c): 根據指定比較器產生的順序對指定對象數組的指定對象數組進行排序。

?字典序：

字典排序是一種對于隨機變量形成序列的排序方法，其方法是按照字母排列順序，或數字順序由小到大形成的的序列。

//簡單給字符數組排序/*** 給字符串進行字典序排序* @param str* @return*/public static String dictSort(String str){char[] chars = str.toCharArray();Arrays.sort(chars); //可以轉化成字符數組return new String(chars);}/*** 給字符串數組進行字典序排序* @param strArr* @return*/public static List<String> dictSort(String[] strArr){List<String> list = Arrays.asList(strArr);//或者是利用list的sort方法Collections.sort(list);return list;}//如果是給不同的字符串呢 import java.io.UnsupportedEncodingException; import java.util.ArrayList; import java.util.*;public class 字典排序1 {public static void sort(){ArrayList<String> arr = new ArrayList<>();arr.add("red");arr.add("8");arr.add("pink");arr.add("5");arr.add("black");arr.add("晨");arr.add("write");arr.add("張");arr.add("7");arr.add("purple");arr.add("嘩嘩");Collections.sort(arr, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {try {String str1 = new String(o1.toString().getBytes("GB2312"),"ISO-8859-1");String str2 = new String(o2.toString().getBytes("GB2312"),"ISO-8859-1");return str1.compareTo(str2);} catch (UnsupportedEncodingException e) {e.printStackTrace();}return 0;}});for(int i = 0;i < arr.size();i++){System.out.println(arr.get(i));}}public static void main(String[] args) {sort();} }

JDK1.8集合框架

Collection接口

Collection接口是Set,List,Queue接口的父接口

//Collection add(Object o); addAll(Collection c); clear(); contains(Object o); remove(Object o); size(); toArray(); Collections.sort(Collection c); Collections.reverse(Collection c); //List 有序集合，具有和索引有關的操作 List<Object> list = new ArrayList<>(); list.add((int)index,Object o); list.addAll(list); list.get((int)index); list.remove((int)index); list.indexOf(Object o); list.subList(int start,int end); [start,end); //Stack(LIFO) Stack<Object> s = new Stack<>(); s.pop(); s.peek(); s.push(Object o); //Queue(FIFO) Queue<Object> q = new LinkedList<>(); q.offer(Object o); q.peek(); q.poll(); //Set 不允許重復 HashSet<Object> set = new HashSet<>(); set.add(Object o); set.contains(Object o); set.remove(Object o);

Map 接口

HashTable，此類實現一個哈希表，該哈希表將鍵映射到相應的值。任何非 null 對象都可以用作鍵或值。
HashMap,基于哈希表的 Map 接口的實現。此實現提供所有可選的映射操作，并允許使用 null 值和 null 鍵。（除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）
LinkedHashMap，Map 接口的哈希表和鏈接列表實現，具有可預知的迭代順序，為插入順序。
TreeMap，基于紅黑樹，該映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決于使用的構造方法。

//HashMap Map<String,String> map = new HashMap<>(); map.put("key","value"); map.getOrDefault("key","default");//if(map.containsKey("key")) return "value" else return "default" map.get("key"); //return "value"; map.containsKey("key"); 方法1：使用For-Each迭代entries 這是最常見的方法，并在大多數情況下更可取的。當你在循環中需要使用Map的鍵和值時，就可以使用這個方法 for(Map.Entry<String,String> entry : map.entrySet()){entry.getKey();entry.getValue(); }2、map的遍歷：如果你只需要用到map的keys或values時，你可以遍歷KeySet或者values代替entrySet Map<Integer, Integer> map = new HashMap<Integer, Integer>();//iterating over keys only for (Integer key : map.keySet()) {System.out.println("Key = " + key); }//iterating over values only for (Integer value : map.values()) {System.out.println("Value = " + value); }

棧、雙端隊列

?Deque是一個線性表接口，可以兩端進行元素的插入和刪除。Deque是“Double ended Queue”的縮寫，Deque讀音[d?k] 。使用Deque接口提供的方法就可以完成隊列“先進先出”和堆棧“后進先出”的功能：

Deque有三種用途：

• 普通隊列(一端進另一端出):
  Queue queue = new LinkedList()或Deque deque = new LinkedList()
• 雙端隊列(兩端都可進出)
  Deque deque = new LinkedList()
• 堆棧
  Deque deque = new LinkedList()

注意：Java堆棧Stack類已經過時，Java官方推薦使用Deque替代Stack使用。Deque堆棧操作方法：push()、pop()、peek()。

Deque是個接口，其實現類有：

• ArrayDeque，使用“數組”存儲數據
• LinkedList，使用“鏈表”存儲數據
• ConcurrentLinkedDeque，線程安全的LinkedList

下表總結了其12 種方法：

	第一個元素 (頭部)		最后一個元素 (尾部)
	拋出異常	特殊值	拋出異常	特殊值
插入	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
刪除（返回并刪除）	removeFirst()	pollFirst()	removeLast()	pollLast()
檢查（值返回不刪除）	getFirst()	peekFirst()	getLast()	peekLast()

add（）：Inserts the specified element at the tail of this queue. As the queue is unbounded, this method will never throw?IllegalStateException?or return?false.

offer（）：Inserts the specified element at the tail of this queue. As the queue is unbounded, this method will never return?false.

區別：兩者都是往隊列尾部插入元素，不同的時候，當超出隊列界限的時候，add（）方法是拋出異常讓你處理，而offer（）方法是直接返回false

Deque接口擴展(繼承)了 Queue 接口。在將雙端隊列用作隊列時，將得到 FIFO（先進先出）行為。將元素添加到雙端隊列的末尾，從雙端隊列的開頭移除元素。從 Queue 接口繼承的方法完全等效于 Deque 方法，如下表所示：

Queue方法	等效Deque方法
add add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

雙端隊列也可用作 LIFO（后進先出）堆棧。應優先使用此接口而不是遺留 Stack 類。在將雙端隊列用作堆棧時，元素被推入雙端隊列的開頭并從雙端隊列開頭彈出。堆棧方法完全等效于 Deque 方法，如下表所示：

堆棧方法	等效Deque方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

小頂堆PriorityQueue

PriorityQueue類在Java1.5中引入并作為?Java?Collections?Framework?的一部分。PriorityQueue是基于優先堆的一個無界隊列，這個優先隊列中的元素可以默認自然排序或者通過提供的Comparator（比較器）在隊列實例化的時排序。

優先隊列不允許空值，而且不支持non-comparable（不可比較）的對象，比如用戶自定義的類。優先隊列要求使用Java?Comparable和Comparator接口給對象排序，并且在排序時會按照優先級處理其中的元素。

優先隊列的頭是基于自然排序或者Comparator排序的最小元素。如果有多個對象擁有同樣的排序，那么就可能隨機地取其中任意一個。當我們獲取隊列時，返回隊列的頭對象。

優先隊列的大小是不受限制的，但在創建時可以指定初始大小。當我們向優先隊列增加元素的時候，隊列大小會自動增加。

PriorityQueue是非線程安全的，所以Java提供了PriorityBlockingQueue（實現BlockingQueue接口）用于Java多線程環境。

堆是一種非線性結構，（本篇隨筆主要分析堆的數組實現）可以把堆看作一個數組，也可以被看作一個完全二叉樹，通俗來講堆其實就是利用完全二叉樹的結構來維護的一維數組

按照堆的特點可以把堆分為大頂堆和小頂堆

大頂堆：每個結點的值都大于或等于其左右孩子結點的值

小頂堆：每個結點的值都小于或等于其左右孩子結點的值

參考文獻：堆排序（大頂堆、小頂堆）----C語言 - 藍海人 - 博客園

PriorityQueue天生是小頂堆，那么如果我要大頂堆怎么辦？

// 默認實現了一個最小堆。 Queue<Integer> priorityQueue = new PriorityQueue<>(); // 實現最大堆 Queue<ListNode> priorityQueue = new PriorityQueue<ListNode>(lists.size(),new Comparator<ListNode>(){ @Override public int compare(ListNode o1, ListNode o2) { return o2.val-o1.val; } } );

一句話總結：默認最小堆，最大堆后面減前面

import java.util.PriorityQueue;public class Test9 {public static void main(String[] args) {int[] a = {45,36,18,53,72,30,48,93,15,35};//1，默認實現的是最小堆，元素按照natural ordering排序（自然排序，例如，數字的從小到大）PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();for(int i=0;i<a.length;i++) {minHeap.offer(a[i]);}while(!minHeap.isEmpty()) {System.out.print(minHeap.poll()+" ");}System.out.println();//輸出（升序）：15 18 30 35 36 45 48 53 72 93 } } import java.util.Comparator; import java.util.PriorityQueue;public class Test9 {public static void main(String[] args) {int[] a = {45,36,18,53,72,30,48,93,15,35};//2，通過比較器排序，實現最大堆PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {/**以下是對比較器升序、降序的理解.*(1) 寫成return o1.compareTo(o2) 或者 return o1-o2表示升序*(2) 寫成return o2.compareTo(o1) 或者return o2-o1表示降序*/return o2.compareTo(o1);}}) ;for(int i=0;i<a.length;i++) {maxHeap.offer(a[i]);}while(!maxHeap.isEmpty()) {System.out.print(maxHeap.poll()+" ");}System.out.println();//輸出（降序）：93 72 53 48 45 36 35 30 18 15 } }

常用ASCII碼

數字0-9 ：48~57.
26個大寫字母：65~90.
26個小寫字母：97~122.

總結

以上是生活随笔為你收集整理的力扣刷题常用数据结构和方法（java版本）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。