Java刷題常用API整合-有解無憂

零：輸入、輸出

遠程在線面試的手撕代碼環節，通常需要白板上寫代碼，
如果需要在控制臺輸入、輸出，需要借助Scanner類，
示例如下：

import java.util.Scanner; 
public class Solution {
    public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		//方法1：一般用來接收陣列，以空格分界
		while(scanner.hasNext()){
			int num = scanner.nextInt();
			/*或者*/String next = scanner.next(); 
		}
		//方法2：一般用來接受字串，以換行符分界
		while (scanner.hasNextLine()) {
            String str = scanner.nextLine();
        }
    }

一：Integer 類

1.String -> int：int value = Integer.parseInt(str);
2.將str轉換成二進制的int： int binary = Integer.parseInt(str,2);
3.十進制轉二進制：String binaryN=Integer.toBinaryString(N);

二：String 類

1.Object -> String：String str = String.valueOf(o);
?char[ ] -> String：String str = String.valueOf(charArray);
? int -> String：String str = String.valueOf(N);

三：對StringObject的方法

1.String轉int、long等

public void test() {
    String sInt = "123";
    int s = Integer.parseInt(sInt);
    long ls = Long.parseLong(sInt);
    System.out.println(s + " " + ls);
}123456

2.StringBuffer

StringBuffer類和String一樣，也用來代表字串，只是由于StringBuffer的內部實作方式和String不同，所以StringBuffer在進行字串處理時，不生成新的物件，在記憶體使用上要優于String類，所以在實際使用時，如果經常需要對一個字串進行修改，例如插入、洗掉等操作，使用StringBuffer要更加適合一些，在StringBuffer類中存在很多和String類一樣的方法，這些方法在功能上和String類中的功能是完全一樣的， 但是有一個最顯著的區別在于，對于StringBuffer物件的每次修改都會改變物件自身，這點是和String類最大的區別，另外由于StringBuffer是執行緒安全的，所以在多執行緒程式中也可以很方便的進行使用，但是程式的執行效率相對來說就要稍微慢一些，

? 2.1 String 轉 StringBuffer

StringBuffer s = new StringBuffer("abc");1

? 2.2 append() 方法，將內容追加到StringBuffer末尾

StringBuffer s = new StringBuffer("abc");
s.append("efg");
System.out.println(s.toString());123

? 2.3 deleteCharAt(int index) 方法，作用是洗掉指定位置的字符，然后將剩余的內容形成新的字串，第一位為0，
? s.delete(int start,int end) 該方法的作用是洗掉指定區間以內的所有字符，包含start，不包含end索引值的區間，

StringBuffer s = new StringBuffer("abc");
s.append("efg");
s.deleteCharAt(2);
s.delete(0,2);1234

? 2.4 insert(int offset, String str) 方法，作用是在StringBuffer物件中插入內容，然后形成新的字串，例如：

StringBuffer sb = new StringBuffer("TestString");
sb.insert(4,"hello");
System.out.println(sb.toString());123

? 2.5 reverse() 方法，作用是將StringBuffer物件中的內容反轉，然后形成新的字串，例如：

StringBuffer sb = new StringBuffer("TestString");
sb.reverse();
System.out.println(sb.toString());  // ---> gnirtStseT123

2.6 setCharAt(int index, char ch) 方法，作用是修改物件中索引值為index位置的字符為新的字符ch，例如：

StringBuffer sb = new StringBuffer("bc");
sb.setCharAt(1,'D');  // ---> sb = ”aDc”12

四：對MapObject的方法

1.map中是否包含key：boolean isContain = map.containsKey(key);
2.map的get()：Object value = map.get(key);
?map的getOrDefault()： map.getOrDefault(key,default);//沒找到就return default
3.map的put()：map.put(key,value);
4.map的遍歷：for(Object key : map.keySet()){ //... }

五：求長度的總結

1.陣列：用arr.length length 是陣列的一個屬性，
2.字串：用str.length() length() 是 StringObject 的一個方法，
3.集合：用list.size() size()是list的一個方法，

六：邊界處理

1.陣列判空：if(arr == null|| arr.length == 0) ...
?二維陣列判空：if(arr == null || arr.length == 0 || arr[0].length == 0) ...
2.字串判空：if(str == null || str.equals("")) ...

七：各種數值型別最大值和最小值

fmax = Float.MAX_VALUE;
fmin = Float.MIN_VALUE;
dmax = Double.MAX_VALUE;
dmin = Double.MIN_VALUE;
bmax = Byte.MAX_VALUE;
bmin = Byte.MIN_VALUE;
cmax = Character.MAX_VALUE;
cmin = Character.MIN_VALUE;
shmax = Short.MAX_VALUE;
shmin = Short.MIN_VALUE;
imax = Integer.MAX_VALUE;
imin = Integer.MIN_VALUE;
lmax = Long.MAX_VALUE;
lmin = Long.MIN_VALUE;1234567891011121314

八：陣列

1.排序

Array.Sort() 快排

ublic void test() {
    int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 };
    System.out.println("排序前");
    for (int i = 0; i < arrayToSort.length; i++)
        System.out.println(arrayToSort[i]);
    // 呼叫陣列的靜態排序方法sort
    Arrays.sort(arrayToSort);
    System.out.println("排序后");
    for (int i = 0; i < arrayToSort.length; i++)
        System.out.println(arrayToSort[i]);
}1234567891011

2.陣列與list轉換

? 2.1 陣列轉list，呼叫Arrays.asList()方法：

public static <T> List<T> asList(T... a) {
     return new ArrayList<>(a);
}
String[] strings = str.split(" ");
List<String> list = Arrays.asList(strings);12345

? 2.2 list轉陣列

List list = new ArrayList();
list.add("1");
list.add("2");
final int size =  list.size();
String[] arr = (String[])list.toArray(new String[size]);12345

九：數字

1.比大小

Math.max(int a, int b); Math.max(float a, float b); Math.min(int a, int b);

public void testMain() throws Exception {
        int a = 100;
        int b = 200;

        System.out.println(Math.max(a,b));
        System.out.println(Math.min(a,b));
}1234567

2.Hash

HashMap put回傳值

leetcode 中 205. Isomorphic Strings這道題，在 discuss 中，有用到 map.put(key, value)的回傳值，查看原始碼可以發現其回傳值為之前存進去key對應的value，
jdk原始碼注釋 @return the previous value associated with key, ornull if there was no mapping forkey. (A null return can also indicate that the map previously associated null with key,if the implementation supports null values.)

public void test() {
    Map<Character,Integer> m = new HashMap<>();
    System.out.println(m.put('a',2));
    System.out.println(m.put('b',3));
    System.out.println(m.put('a',1));
    System.out.println(m.put('a',5));
}

// ---> null null 2 1123456789

十：常用的現成資料結構類

1.線性表（List介面，有序的 collection（也稱為序列），此介面的用戶可以對串列中每個元素的插入位置進行精確地控制，用戶可以根據元素的整數索引（在串列中的位置）訪問元素，并搜索串列中的元素，與 set 不同，串列通常允許重復的元素，）

Stack，堆疊
Vector, 動態陣列
ArrayList, 實作了List介面的動態陣列
LinkedList, List 介面的鏈接串列實作，包含佇列、雙端佇列的API，同時實作Queue介面

Collections的reverse方法()、sort()方法

// reverse(list) 反轉
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(1);
list.add(2);
Collections.reverse(list);   // 使用Collections的reverse方法，直接將list反轉
// ---> list = {2, 1, 3}

// sort() 升序排序
Collections.sort(list);   // ---> list = {1, 2, 3}

// 升序在反轉就相當于降序123456789101112

2.映射(Map介面，將鍵映射到值的物件，一個映射不能包含重復的鍵；每個鍵最多只能映射到一個值)

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

3.集合(Set介面是一個不包含重復元素的集合)

HashSet，此類實作 Set 介面，由哈希表支持，元素存盤迭代沒有固定順序
LinkedHashSet，具有可預知迭代順序的 Set 介面的哈希表和鏈接串列實作，順序為插入順序
TreeSet，元素是內部排序的，使用元素的自然順序對元素進行排序，或者根據創建 set 時提供的 Comparator 進行排序，具體取決于使用的構造方法，

4.優先佇列

PriorityQueue,一個基于優先級堆的無界優先級佇列，優先級佇列的元素按照其自然順序進行排序，或者根據構造佇列時提供的 Comparator 進行排序，元素小的優先級高，輸出時先輸出，實作Queue介面

5.其他常用的類，直接使用類中的靜態方法

類Arrays，此類包含用來操作陣列（比如排序和搜索）的各種方法，
Math類，Math 類包含用于執行基本數學運算的方法，如初等指數、對數、平方根和三角函式，
Boolean,Byte,Short,Interger,Long,Double,Floate,Charcter等八種基本型別對應的包裝類，

十一：集合的Stack、Queue、Map的遍歷

1.Map的遍歷

public class TestMap { 
        public static void main(String[] args) { 
                Map<String, String> map = new HashMap<String, String>(); 
                // put值
                map.put("1", "a"); 
                map.put("2", "b"); 
                map.put("3", "c"); 

                //最簡潔、最通用的遍歷方式 
                for (Map.Entry<String, String> entry : map.entrySet()) { 
                        System.out.println(entry.getKey() + " = " + entry.getValue()); 
                } 
                //Java5之前的比較簡潔的便利方式1 
                System.out.println("----1----"); 
                for (Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); it.hasNext();) { 
                        Map.Entry<String, String> entry = it.next(); 
                        System.out.println(entry.getKey() + " = " + entry.getValue()); 
                } 
                //Java5之前的比較簡潔的便利方式2 
                System.out.println("----2----"); 
                for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) { 
                        String key = it.next(); 
                        System.out.println(key + " = " + map.get(key)); 
                } 
        } 
}1234567891011121314151617181920212223242526

2.Queue佇列的遍歷

public class TestQueue { 
        public static void main(String[] args) { 
                Queue<Integer> q = new LinkedBlockingQueue<Integer>(); 
                //初始化佇列 
                for (int i = 0; i < 5; i++) { 
                        q.offer(i); 
                } 
                System.out.println("-------1-----"); 
                //集合方式遍歷，元素不會被移除 
                for (Integer x : q) { 
                        System.out.println(x); 
                } 
                System.out.println("-------2-----"); 
                //佇列方式遍歷，元素逐個被移除 
                while (q.peek() != null) { 
                        System.out.println(q.poll()); 
                } 
        } 
}12345678910111213141516171819

3.Stack堆疊的遍歷

public class TestStack { 
        public static void main(String[] args) { 
                Stack<Integer> s = new Stack<Integer>(); 
                for (int i = 0; i < 10; i++) { 
                        s.push(i); 
                } 
                //集合遍歷方式 
                for (Integer x : s) { 
                        System.out.println(x); 
                } 
                System.out.println("------1-----"); 
                // 堆疊彈出遍歷方式 
                // while (s.peek()!=null) {     //不健壯的判斷方式，容易拋例外，正確寫法是下面的 
                while (!s.empty()) { 
                        System.out.println(s.pop()); 
                } 
                System.out.println("------2-----"); 
                // 錯誤的遍歷方式 
                // for (Integer x : s) { 
                //        System.out.println(s.pop()); 
                // } 
        } 
}1234567891011121314151617181920212223

在遍歷集合時候，優先考慮使用foreach陳述句來做，這樣代碼更簡潔些，

十二：length,length(),size() 的使用與區別

length屬性是針對陣列說的，比如說你宣告了一個陣列，想知道這個陣列的長度則用到了length這個屬性，
length()方法是針對字串String說的，如果想看這個字串的長度則用到length()這個方法，
size()方法是針對泛型集合泛型集合(Collection)如Set、List、Map說的，如果想看這個泛型有多少個元素，就呼叫此方法來查看，陣列沒有size()方法，

public static void main(String[] args) {
        String[] list = {"hello", "baidu"};
        String a = "hellobaidu";
        List<Object> array = new ArrayList();
        array.add(a);

        System.out.println(list.length);
        System.out.println(a.length());
        System.out.println(array.size());
}

// ---> 2  10  1

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/177365.html

標籤：其他

上一篇：應屆生拿下京東小米Java崗offer，學習筆記都在這里了（年薪28w的面經）

下一篇：定時器篇：定時任務入門小案例