Java API速记手册（持续更新ing...）

之所以干这个事原因也很简单，因为我3年没写Java了，现在在复健。
因为我最近都在用Python，所以跟Python一样的部分我就不写了。

最基本的框架

public class MainClass {
      
      
    public static void main(String[] args) {
      
      
        //主函数代码
    }
}

打印：System.out.println(打印内容);
内置对象
Java数组（未完待续）
实例化对象
1. 内置对象
  int x=1;
2. 自定义对象：类名实例名=new 类名();

对象类型转换

将float转int¹

Float类的intValue()

Float f = 10.5f;
int i = f.intValue();
System.out.println("Float转Int：" + i);

强制转换

float f1 = 10.5f;
int i1 = (int) f1;
System.out.println("浮点型强制转换为整型：" + i1);

循环（Java循环（未完待续））

条件语句²

if(布尔表达式)
{
        
        
   //如果布尔表达式为true将执行的语句
}

if-else

if(布尔表达式){
        
        
   //如果布尔表达式的值为true
}else{
        
        
   //如果布尔表达式的值为false
}

static静态方法
private私有方法
final

Arrays类

赋值 fill()
public static void fill(arrayname,value)
public static void fill(arrayname ,starting index ,ending index ,value)

import java.util.*;
public class Example{
      
      
    public static void main(String[] args) {
      
      
        int array[] = new int[10];
        Arrays.fill(array, 1);
        for (int arrays:array) {
      
      
            System.out.print(arrays+" ");
        }
        System.out.println();
        Arrays.fill(array, 3, 6, 9);
        for (int arrays:array) {
      
      
            System.out.print(arrays+" ");
        }
    }
}

输出：

1 1 1 1 1 1 1 1 1 1 
1 1 1 9 9 9 1 1 1 1

排序 sort()
public static void sort(Object[] arrayname) 对一个数组的所有元素进行排序，并且是按从小到大的顺序
public static void sort(Object[] arrayname,int fromIndex, int toIndex) 对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序

import java.util.*;
public class Example{
        
        
    public static void main(String[] args) {
        
        
        int array[] = {
        
        2,5,85,30,75,66,-18,0};
        Arrays.sort(array,2,5);
        for (int arrays:array) {
        
        
            System.out.print(arrays+" ");
        }
        System.out.println();
        Arrays.sort(array);
        for (int arrays:array) {
        
        
            System.out.print(arrays+" ");
        }
    }
}

输出：

2 5 30 75 85 66 -18 0 
-18 0 2 5 30 66 75 85

Arrays.sort()的底层原理：
假设数组长度为n
1<=n<47，使用插入排序
47<=n<286，使用快速排序
n>=286，使用归并排序或快速排序（有一定顺序使用归并排序，毫无顺序使用快速排序）

查找 binarySearch()
用二分法查找：数组在调用前必须排序好
public static int binarySearch(Object[] a,Object key) 在一个数组的所有元素中进行查找

返回值：
在数组范围内，索引值为“ - 插入点索引值”
小于数组内元素，索引值为 – 1
大于数组内元素，索引值为 – (length + 1)

public static int binarySearch(Object[] a,int fromIndex,int toIndex,Object key) 在该数组指定的范围内进行查找

返回值：
在搜索范围内，索引值为“ - 插入点索引值”
小于搜索范围内元素，返回–(fromIndex + 1)
大于搜索范围内元素，返回 –(toIndex + 1)

import java.util.*;
public class Example{
        
        
    public static void main(String[] args) {
        
        
        int array[] = {
        
        2,5,85,30,75,66,-18,0};
        Arrays.sort(array);
        for (int arrays:array) {
        
        
            System.out.print(arrays+" ");
        }
        System.out.println();
        System.out.println(Arrays.binarySearch(array,5));
        System.out.println(Arrays.binarySearch(array,-99));
        System.out.println(Arrays.binarySearch(array,100));
        System.out.println(Arrays.binarySearch(array,60));
        System.out.println(Arrays.binarySearch(array,1,5,5));
        System.out.println(Arrays.binarySearch(array,1,5,-99));
        System.out.println(Arrays.binarySearch(array,1,5,100));
        System.out.println(Arrays.binarySearch(array,1,5,60));
    }
}

输出：

-18 0 2 5 30 66 75 85 
3         //5在数组内，返回排完序后的索引3
-1        //-99小于数组内元素，返回索引值为-1
-9        //100大于数组内元素，返回索引值为-(length+1)=-(8+1)
-6        //60在数组范围内，返回索引值为-插入点索引值=-6
3         //5在搜索范围内，返回排完序后的索引3
-2        //-99小于搜索范围内元素，返回–(fromIndex + 1)=-(1+1)=-2
-6        //100大于搜索范围内元素，返回–(toIndex + 1)=-(5+1)=-6
-6        //60在搜索范围内，索引值为-插入点索引值=-6`

比较 equals()
如果两个指定的数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。
public static boolean equals(Object[] arrayname,Object[] arrayname2)

import java.util.*;
public class Example{
      
      
    public static void main(String[] args) {
      
      
        int[] array1 = {
      
      2,5,85,30,75,66,-18,0};
        int[] array2 = {
      
      75,2,66,30,5,85,0,-18};
        
        if(Arrays.equals(array1, array2)){
      
      
            System.out.println("array1等于array2");
        }
        else{
      
      
            System.out.println("array1不等于array2");
        }
        
        Arrays.sort(array1);
        Arrays.sort(array2);
        
        for(int arrays:array1){
      
      
            System.out.print(arrays+" ");
        }
        System.out.println();
        for(int arrays:array2){
      
      
            System.out.print(arrays+" ");
        }     
        System.out.println();
        
        if(Arrays.equals(array1, array2)){
      
      
            System.out.println("排序后，array1等于array2");
        }
        else{
      
      
            System.out.println("排序后，array1不等于array2");
        }
    }
}

输出：

array1不等于array2
-18 0 2 5 30 66 75 85 
-18 0 2 5 30 66 75 85 
排序后，array1等于array2

复制
copyOf() 将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数） public static Object[] copyOf(original,newLength)

copyOfRange() 将某个范围内的元素复制到新的数组中 public static Object[] copyOfRange(original,int from,int to) from为拷贝的开始位置（包含），to为拷贝的结束位置（不包含）

import java.util.*;
public class Example{
      
      
    public static void main(String[] args) {
      
      
        int[] array1 = {
      
      2,5,85,30,75,66,-18,0};
        int[] array2 = Arrays.copyOf(array1, 6);
        int[] array3 = Arrays.copyOfRange(array1, 2, 4);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        System.out.println(Arrays.toString(array3));       
    }
}

输出：

[2, 5, 85, 30, 75, 66, -18, 0]
[2, 5, 85, 30, 75, 66]
[85, 30]

Deque<Integer> stack = new ArrayDeque<Integer>();
stack.push(Integer.parseInt(arr[i]));
stack.peek()
stack.pop();
列表List<Integer> list = new ArrayList<Integer>();
列表转字符串：String str = list.toString(); String.join(" ", nums);
list.add(factor);
字符串按分隔符分割为数组：String[] arr = data.split(", "); nums = Arrays.asList(data.split(" "));
字符串切片：str.substring(1, str.length() - 1);
检验对象是否为None（Java中None就是光声明不创建）：data.isEmpty()
属性和方法：length size()
Integer.MIN_VALUE
Integer.MAX_VALUE
数字转字符串：String.valueOf(root.val)
Integer.parseInt(nums.get(i))

Math类

min()³

public class Test{
        
        
    public static void main(String args[]){
        
        
        System.out.println(Math.min(12.123, 12.456));      
        System.out.println(Math.min(23.12, 23.0));  
    }
}

输出结果：

12.123
23.0

本文撰写过程中使用的其他参考资料：

Java 浅谈数组(Array)和列表(ArrayList)的区别介绍Arrays常用方法_数组和列表的区别_senxu_的博客-CSDN博客

Java API速记手册（持续更新ing...）

猜你喜欢