算法題python容器方法對應的Java容器方法

一、java基本數據類型

java中包含引用數據類型和八種基本類型

• 八種基本類型：

基本類型	佔用空間（bit）	說明	默認值	包裝類
byte	8	有符號的，以二進制補碼錶示的整數，範圍-128（-2 ^7）~ 127（2 ^7-1）	0	Byte
short	16	有符號短整型	0	Short
int	32	有符號整型	0	Integer
long	64	有符號長整型	0L	Long
float	32	單精度浮點	0.0f	Float
double	64	雙精度浮點	0.0d	Double
char	16	單一的 16 位 Unicode 字符		Character
boolean	8	布爾類型（true/false）	false	Boolean

• 打印包裝類的基本信息

System.out.println("基本類型：double 二進制位數：" + Double.SIZE);  
System.out.println("包裝類：java.lang.Double");  
System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE); 

• 基本數據類型都對應了其包裝類，支持自動裝箱和拆箱。

//自動裝箱Integer x = Integer.valueOf(5)
Integer x = 5;
//拆箱，實際上執行了 int t = i.intValue();
int t = i; 

• 數值類(byte,short,int,long,float,double)基本變量的包裝類實現的方法

方法	含義
xxxValue()	將 Number 對象轉換爲xxx數據類型的值並返回。
compareTo()	將number對象與參數比較。
equals()	判斷number對象是否與參數相等。
包裝類.valueOf()	返回一個 Number 對象指定的內置數據類型
包裝類.parseXXX()	靜態方法，將字符串解析爲XXX類。
toString()	以字符串形式返回值。

包裝類轉換爲字符串類型：toString()
基本變量轉換爲字符串類型：+""
使用System.out.println(n);時會自動調用n對應類的toString方法

int n=Integer.parseInt("10");
System.out.println(n+"");
System.out.println(n);

Integer x = 5;
System.out.println(x.toString());
System.out.println(x);

• 非數值類(char，boolean)基本變量的包裝類實現的方法

1.Character 方法

方法	含義
Character.isLetter()	是否是一個字母
Character.isDigit()	數字字符
Character.isWhitespace()	是否是一個空白字符
Character.isUpperCase()	是否是大寫字母
Character.isLowerCase()	是否是小寫字母
toString()	返回字符的字符串形式，字符串的長度僅爲1

2.Boolean方法：沒啥可說的

二、java字符串類String

java中： ’ '表示字符；" "表示字符串
python中：二者沒有區別
java中：有三種類型可以存儲字符串：

• java中幾種常用的字符串構造方法：

String greeting = "菜鳥教程";

//字符數組
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray);  

• 連接字符串：

"Hello," + " runoob" + "!"

//concat方法
String s2 = ".....";
String s1 = "菜鳥教程";
s1.concat(s2);

• 創建格式化字符串

System.out.printf("浮點型變量的值爲 " +
                  "%f, 整型變量的值爲 " +
                  " %d, 字符串變量的值爲 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮點型變量的值爲 " +
                   "%f, 整型變量的值爲 " +
                   " %d, 字符串變量的值爲 " +
                   " %s", floatVar, intVar, stringVar);

• String 方法

方法	說明
char charAt(int index)	返回第idx個字符
int compareTo(Object o)	把這個字符串和另一個對象比較
int compareTo(String anotherString)	按字典順序比較兩個字符串。
int compareToIgnoreCase(String str)	按字典順序比較兩個字符串，不考慮大小寫。
boolean contentEquals(StringBuffer sb)	當且僅當字符串與指定的StringBuffer有相同順序的字符時候返回真。
int indexOf(String str)	返回指定子字符串在此字符串中第一次出現處的索引。
int lastIndexOf(int ch)	返回指定字符在此字符串中最後一次出現處的索引。
int length()	返回此字符串的長度。
boolean matches(String regex)	告知此字符串是否匹配給定的正則表達式。
String replace(char oldChar, char newChar)	返回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 得到的。
String replaceAll(String regex, String replacement)	使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。
String[] split(String regex)	根據給定正則表達式的匹配拆分此字符串。
String substring(int beginIndex)	返回一個新的字符串，它是此字符串的一個子字符串。
String substring(int beginIndex, int endIndex)	它是此字符串的一個子字符串。
String trim()	返回字符串的副本，忽略前導空白和尾部空白。
String toUpperCase()	使用默認語言環境的規則將此 String 中的所有字符都轉換爲大寫。

分割操作

 String s="1,2,3,4,8,9";
 String[] ssp=s.split(",");
 for (int i=0;i<ssp.length;i++){
            System.out.print(ssp[i]);
        }

切片操作

String s1="abcdefghij";
System.out.println(s1.substring(0,5));

三、Java StringBuffer 和 StringBuilder 類

StringBuffer和StringBuilder 更適合於可變的字符存儲

StringBuffer sBuffer = new StringBuffer("菜鳥教程官網：");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer);  

• StringBuffer 方法：由於可變所以支持逆序，追加，插入，刪除等操作；注意使用後用toString()方法轉換爲字符串

方法	說明
StringBuffer append(String s)	字符串追加到此字符序列
StringBuffer reverse()	將此字符序列用其反轉形式取代。
delete(int start, int end)	移除此序列的子字符串中的字符。
insert(int offset, int i)	將 int 參數的字符串表示形式插入此序列中。
replace(int start, int end, String str)	使用給定 String 中的字符替換此序列的子字符串中的字符。
String substring(int start, int end)	返回一個新的 String，它包含此序列當前所包含的字符子序列。
String toString()	返回此序列中數據的字符串表示形式。

其餘與String方法類似

        StringBuffer sb=new StringBuffer();
        sb.append('a');
        sb.append('b');
        sb.append('c');

        System.out.println(sb);
        System.out.println(sb.reverse());

四、IO、Stream、Sancer實現鍵盤輸入

主要講解從控制檯輸入，把輸入的字符串解析爲基本類型或者容器

1.使用BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(System.in))

• 注意拋異常
• 可以read（）讀取一個字符，br.readLine()讀取一行

public class BRRead {
    public static void main(String args[]) throws IOException {
    	char c;
        // 使用 System.in 創建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        c = (char) br.read();

public class BRRead {
    public static void main(String args[]) throws IOException {
    	String str;;
        // 使用 System.in 創建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        str = br.readLine();

2.使用Scaner類

• 使用next() 與 nextLine() 方法獲取輸入的字符串
• 使用 hasNext 與 hasNextLine 判斷是否還有輸入的數據

next() ：

1. 一定要讀取到有效字符後纔可以結束輸入。
2. 對輸入有效字符之前遇到的空白，next() 方法會自動將其去掉。
3. 只有輸入有效字符後纔將其後面輸入的空白作爲分隔符或者結束符。
4. next() 不能得到帶有空格的字符串。

nextLine() ：

1. 以Enter爲結束符,也就是說 nextLine()方法返回的是輸入回車之前的所有字符。
2. 可以獲得空白。

public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 從鍵盤接收數據
        // 判斷是否還有輸入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("輸入的數據爲：" + str1);
        }
        scan.close();
    }

3.結合Stream和map實現輸入整體入容器

將Scaner獲取的String切分後轉換爲Stream，採用map轉換爲數值之後存入容器

python：

lst=list(map(int,input().split(" ")))

java:

Scanner sc=new Scanner(System.in);
String[] ss=sc.nextLine().split(" ");
List<Integer> r3 = Stream.of(ss).map(x->Integer.parseInt(x)).collect(Collectors.toList());

//
List<Integer> r3 = Stream.of(ss).map(Integer::parseInt).collect(Collectors.toList());
System.out.println(r3);

五、數組與工具類Arrays

1.數組定義及初始化

1. 定義

int[] a;
int[][] aa; 

2. 初始化

靜態：直接分配初始

a=new int[]{1,2,3};
aa=new int[][]{{1,2,3},{1,2,3}};

動態：直接分配空間，系統默認分配初值

a=new int[5];
aa=new int[5][];aa1=new int[5][5];

3. 定義時初始化

靜態
int[] a = new int[]{1,5};
int[][] aa = new int[][]{{1,5},{1,1},{2,4},{8,5}};
簡化版本
int[][] aa ={{1,5},{1,1},{2,4},{8,5}};


動態：
int[] a=new int[4];

2.數組使用：

1. 遍歷

for循環

for(int i=0;i<arr.length,i++){
	System.our.println(arr[i]);
}

for each,把數組中的值先傳遞給形參

for(int i:arr){
	System.our.println(i);
}

3.數組工具類Arrays：

方法	含義
fill()	數組賦值
sort()	排序
copyOf()	拷貝
binarySearch()	二分查找
asList()	轉換爲List
toString()	打印數組元素

填充數組：Arrays.fill(array, 5)：
5 5 5 5 5 
將數組的第2和第3個元素賦值爲8：Arrays.fill(array, 2, 4, 8)：
5 5 8 8 5 
對數組的第2個到第5個元素進行排序進行排序：Arrays.sort(intTest,2,6)：
15 78 5 22 29 32 17 34 
對整個數組進行排序：Arrays.sort(intTest)：
5 15 17 22 29 32 34 78 
比較數組元素是否相等:Arrays.equals(array, intTest):
false
克隆後數組元素是否相等:Arrays.equals(array, array1):
true
數組前兩個元素位置顛倒結果是否相等:Arrays.equals(intTesta, intTestb):
false
元素12在testA中的位置：Arrays.binarySearch(testA, 12)：
2
元素9在testA中的位置：Arrays.binarySearch(testA, 9)：
-3
元素12在testA中0到3的位置：Arrays.binarySearch(testA, 0,3,12)：
2
元素12在testA中0到2的位置：Arrays.binarySearch(testA, 0,2,12)：
-3
[5, 5, 8, 8, 5]
copyOf方法截取的數組元素爲：
5 5 8 8 
copyOfRange方法截取的數組元素爲：
5 8 8 
toString方法打印數組元素：
[hello, how, are, you, !]
數組轉換爲list，打印結果爲:
hello how are you ! 

六、容器/集合類

java的容器類定義的時候要具體指明模板參數，不如python的靈活

1.Collection接口方法（集合都有）

	功能
向後追加	add(x)
向後追加所有	addAll(Collection<? extends E> c)
刪除所有	clear()
包含	contains(Object o)
返回迭代器	iterator()
移除指定元素	remove(Object o)
大小	size()
流	stream()
轉換爲數組	toArray() / toArray(T[] a)
判空	isEmpty()

2.List

功能	python	java
向後追加	append(x)	add(x)
插入	insert(idx,x)	add(idx,x)
移除下標idx元素,並返回	pop(idx) 默認idx=-1最後一個	remove(idx)默認idx=0
移除指定元素	remove(x)默認移除左邊第一個	remove(Object)：如(Integer.valueOf(x));
取值	lst[idx]	get(idx)
賦值	lst[idx]=val	set(idx,val)

3 Queue（接口）

功能	python	java
入隊	append(x)	add(x)
出隊	pop(0)	poll()
隊首元素	queue[0]	peek()

3.1 Deque（接口）–》ArrayDeque

功能	java
隊尾入隊	add()/addLast()
隊頭入隊	addFirst()
獲取隊頭元素	peekFirst()
獲取隊尾元素	peekLast()
隊頭元素出隊	pollFirst()
隊尾元素出隊	pollLast()

4. Set

java包含(HashSet,LinkedHashSet,TreeSet)

功能	python	java
初始化	s=set()	Set<> s=new Hashset<>();
添加	add()	add()
s1交s2	s1 | s2	result.clear(); result.addAll(set1); result.retainAll(set2);
s1並s2	s1 & s2	result.clear(); result.addAll(set1); result.removeAll(set2);
s1差s2	s1-s2	result.clear(); result.addAll(set1); result.addAll(set2);
取出	轉化爲列表 list(s)	使用迭代器 Iterator it = set.iterator(); while(it.hasNext()){ System.out.print(it.next() + " ");}

5. Map(java) /dict字典（python）

功能	python	java
初始化	dic={}	Map<> map=new HashMap<>();
根據key獲取值	dic[key]	map.get(key)
添加key-value	dic[key] =value	map.put(key,value)
包含key	key in dic或者 key in dic.keys()	map.containsKey(key)
包含value	v in dic.values()	map.containsValue(V)
獲取條目	dic.items()	map.entrySet()

6.集合工具類collections

作用	靜態方法
添加	addAll(Collection
二分查找	binarySearch(List
拷貝	copy()
填充	fill(List<? super T> list, T obj)
從枚舉返回列表	list(Enumeration e)
大小	max(Collection),min,
逆序	reverse()
排序	sort()
交換	swap(List<?> list, int i, int j)

7.數組工具類Arrays

作用	靜態方法
轉換爲list	asList(T… a)
二分查找	binarySearch(int[] a, int key)
拷貝	copyOf(int[] original, int newLength)
排序	sort(float[] a)
轉換爲字符	toString(int[] a)

使用數組初始化List
ArrayList<Type> obj = new ArrayList<Type>(Arrays.asList(Object o1, Object o2, ..so on));
List<Integer> list=new ArrayList<>(Arrays.asList(1,2,3,4));

List轉數組

int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();

7.集合排序

此處只針對集合元素爲字符串和數值類型的集合
Java中對於數值類型和String實現了Comparable接口，重寫了compareTo方法，因此可以比較。
連接：https://blog.csdn.net/qq_43437465/article/details/89437637

java對於簡單排序都是ok的

List<Integer> list0 = new ArrayList<>();
Random random = new Random();
for(int i = 0; i<10;i++){
    list0.add(random.nextInt(100));

   //[2, 19, 44, 46, 61, 67, 68, 89, 91, 94]
}
System.out.println(list0);

Collections.sort(list0);
System.out.println(list0);

而對於python自帶的多級排序輸入爲二維數組，java實現起來就比較麻煩了：

python多級排序

d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(-x['score'], x['name']))
print(l)
//輸出
//[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]

參見java多級排序：

• 對二維數組實現兩級排序：

public class main {
    public static void main(String[] args){
        int [][]a = new int[][]{{1,5},{1,1},{2,4},{8,5}};
        Arrays.sort(a, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0]==o2[0]) return o1[1]-o2[1];
                return o1[0]-o2[0];
            }
        });
        for (int[] a1: a) {System.out.println(a1[0]+" "+a1[1]);
        }
    }
}

• 對自定義類實現多級排序
  http://blog.sina.com.cn/s/blog_5a15b7d10102w46p.html
  將員工按照級別工資工齡多級排序

public Class Employee {  
   
    public int level;  //級別  
    public int salary; //工資  
    public int years;  //入職年數 
}  

package net.oschina.tester;  
   
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.Comparator;  
import java.util.List;  
   
  
public class Employee {  
   
    public static void main(String[] args) {  
        List objs = new ArrayList(){{  
            add(new Employee(5,3,5000,2));  
            add(new Employee(1,9,10000,10));  
            add(new Employee(4,5,8000,6));  
            add(new Employee(2,9,12000,7));  
            add(new Employee(6,1,2000,1));  
            add(new Employee(3,5,8000,12));  
        }};  
        Collections.sort(objs, comparator);  
        System.out.println("No\tLevel\tSalary\tYears\n=============================");  
        for(Employee a : objs)  
            System.out.printf("%d\t%d\t%d\t%d\n",a.id,a.level,a.salary,a.year);  
    }  
   
    public Employee(int id, int level, int salary, int year){  
        this.id = id;  
        this.level = level;  
        this.salary = salary;  
        this.year = year;  
    }  
       
    public int id;  
    public int level;  
    public int salary;  
    public int year;  
   
    private final static Comparator comparator = new Comparator(){  
        @Override  
        public int compare(Employee a1, Employee a2) {  
            int cr = 0;  
            int a = a2.level - a1.level;  
            if(a != 0)  
                cr = (a>0)?3:-1;  
            else{  
                a = a2.salary - a1.salary;  
                if(a != 0)  
                    cr = (a>0)?2:-2;  
                else{  
                    a = (int)(a2.year - a1.year);  
                    if(a != 0)  
                        cr = (a>0)?1:-3;  
                }  
            }  
            return cr;  
        }         
    };  
       
}  

七、java8新特性 ——Stream

對於python來說，既沒有8大基本類型及其包裝類的轉換，還能支持函數式編程、lambda編程，可以說是非常方便，如sort，max，sum等函數，以及fliter等

java8通過stream也支持了這些操作
參考
https://www.cnblogs.com/chenpi/p/5915364.html

• Java中List, Integer[], int[]的相互轉換

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class Main {
    public static void main(String[] args) {
        int[] data = {4, 5, 3, 6, 2, 5, 1};
 
        "int[] 轉 List<Integer>"
        List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
        // Arrays.stream(arr) 可以替換成IntStream.of(arr)。
        // 1.使用Arrays.stream將int[]轉換成IntStream。
        // 2.使用IntStream中的boxed()裝箱。將IntStream轉換成Stream<Integer>。
        // 3.使用Stream的collect()，將Stream<T>轉換成List<T>，因此正是List<Integer>。
 
       "int[] 轉 Integer[]"
        Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
        // 前兩步同上，此時是Stream<Integer>。
        // 然後使用Stream的toArray，傳入IntFunction<A[]> generator。
        // 這樣就可以返回Integer數組。
        // 不然默認是Object[]。
 
        "List<Integer> 轉 Integer[]"
        Integer[] integers2 = list1.toArray(new Integer[0]);
        //  調用toArray。傳入參數T[] a。這種用法是目前推薦的。
        // List<String>轉String[]也同理。
 
        "List<Integer> 轉 int[]"
        int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
        // 想要轉換成int[]類型，就得先轉成IntStream。
        // 這裏就通過mapToInt()把Stream<Integer>調用Integer::valueOf來轉成IntStream
        // 而IntStream中默認toArray()轉成int[]。
 
        "Integer[] 轉 int[]"
        int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
        // 思路同上。先將Integer[]轉成Stream<Integer>，再轉成IntStream。
 
        "Integer[] 轉 List<Integer>"
        List<Integer> list2 = Arrays.asList(integers1);
        // 最簡單的方式。String[]轉List<String>也同理。
 
        // 同理
        String[] strings1 = {"a", "b", "c"};
        // String[] 轉 List<String>
        List<String> list3 = Arrays.asList(strings1);
        // List<String> 轉 String[]
        String[] strings2 = list3.toArray(new String[0]);
 
    }
}

八、python math和java Math

從實現的功能來說，python要比java強大很多

功能	java	python
三角函數	√	√
常量pi,e	√	√
數值舍取	round(),ceil(),floor()	round()不在math包中 默認就有
最大最小絕對值	√（max和min兩個參數）	√
sqrt()	√	√
對數	log():自然底數e log10()	log2() log(x,y=e) log10()
最大公約數	-	gcd(a,b)
n！	-	factorial(n)
範數	-	hypot(x,y)

注意
java

• gcd可以採用輾轉相除法計算

def gcd(a,b):
    if a%b == 0:
        return b
    else :
        return gcd(b,a%b)

• 任意底的對數，可以使用換底公式實現
  

python

• 階乘factorial(n)要比自身實現快