Java刷题API

0：输入输出

import java.util.Scanner;
public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //方法1：一般用来接收数组。以空格分界
        int[] ints = new int[5];
        int i = 0;
        while (scanner.hasNext()) {

            int num = scanner.nextInt();
            if (num == -1) break;
            ints[i] = num;

            /*或者*/
            String next = scanner.next();
        }

        //方法2：一般用来接受字符串,以换行符分界
        String[] arr = new String[5];
        i = 0;
        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();
            if (str == "") break;
            arr[i++] = str;
        }
    }
}

一：Integer 类

1.String -> int：int value = Integer.parseInt(str);
2.将二进制字符串str转换成int： int binary = Integer.parseInt(str,2);//“111”->7
3.十进制int转二进制字符串：String binaryN=Integer.toBinaryString(N);//15 -> “1111”

二：String 类

public class StringExample {
    public static void main(String[] args) {

        String s = "hel"+"lo";//连接
        int len = s.length();
        char c = s.charAt(0);
        //返回指定字符在此字符串中第一次出现处的索引,找不到返回-1
        int index1 = s.indexOf("el");//1

        String substr = s.substring(0,3);//hel,前闭后开

        String s2 = "Hi,Linda,Hello";
        String[] ss = s2.split(",");//分割

        //和Integer的相互转换
        int i = Integer.parseInt("24");
        String string = Integer.toString(i);

        //和Long的相互转换
        long ll = Long.parseLong("25");
        string = Long.toString(ll);

        //和char[]的相互转换
        char[] cc = string.toCharArray();
        string = String.valueOf(cc);

        //字符串是否相等
        String str1 = "hello",str2 = "hello";
        if (str1.equals(str2))
            System.out.println(true);

        //替换
        str1.replace("1","a");//将1替换为a

        //去除头尾空格
        str1 = str1.trim();
        
    }
}

三：数组

关于多重数组【重点】

public static void main(String[] args) {
    int[][] nums = {{1,1},
                    {2,2},
                    {3,3}};
    System.out.println(nums.length);//3,一共有多少行
    System.out.println(nums[0].length);//2,第0行的长度
}

import java.util.*;

public class ArrayExample {
    public static void main(String[] args) {

        int[] arr = new int[10];
        int[] arr2 = {1,4,3,7,5};

        //全部填充
        Arrays.fill(arr,3);
        System.out.println(Arrays.toString(arr));//[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

        //排序,默认从小到大
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));//arr2:[1 3 4 5 7 ]

        //排序，从大到小,lambda方法
        Integer[] arr3 = {3,6,2,1,8};
        Arrays.sort(arr3, (a, b) -> b - a);
        System.out.println(Arrays.toString(arr3));//[8, 6, 3, 2, 1]

        //排序，从大到小，匿名类
        Integer[] arr4 = {3,6,2,1,8};
        Arrays.sort(arr4, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr4));//[8, 6, 3, 2, 1]
    }
}

四：动态数组（ArrayList）

import java.util.*;

public class ArrayListExample {
    public static void main(String[] args) {

        //初始化空的list
        ArrayList<Integer> a1 = new ArrayList<>(10);

        //另一种初始化方式,不过是List，不是ArrayList
        List<Integer> a2 = Arrays.asList(1, 5, 3, 2, 7, 0);

        //填充
        Collections.fill(a2, 100);//将a2全部元素设置为100

        //增删
        a1.add(0,4);//将4插入到第三个位置
        a1.remove(0);//删除下标为0的

        //遍历
        //1.下标
        for(int i=0;i<a1.size();i++){
            a1.get(i);//访问下标为i的
        }
        //2.循环
        for(int item:a1){
        }

        //排序
        Collections.sort(a2);//排序
        Collections.max(a2);//最大值
        Collections.min(a2);//最小值

        //翻转
        Collections.reverse(a2);

    }
}

五：栈Stack

import java.util.*;
public class StackExample {
    public static void main(String[] args) {

        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.pop();//移除堆栈顶部的对象，并作为此函数的值返回该对象
        stack.peek();//查看堆栈顶部的对象，但不从堆栈中移除它
        
        //注意：另一方面，不推荐使用Stack(),应该使用Deque(双端队列)
        Deque<Integer> stack1 = new ArrayDeque<Integer>();
        stack1.push(2);
        stack1.pop();
        stack1.peek();
    }
}

六：队列Queue

单向队列Queue

Queue<Integer> q = new LinkedList<>(); //实例化
 
offer(E e);    // 队尾加入元素e。 若成功入队返回值true，否则返回false --- O(1)
 
poll();    // 出队头，返回出队元素e --- O(1)
 
peek();    // 查看队头元素， 返回值队首元素e --- O(1)
 
isEmpty()    // 若队空返回true， 否则返回false --- O(1)
 
size()    // 返回队中元素个数 --- O(1)

Queue<Integer> queue = new ArrayDeque<>();
//Queue<Integer> q = new LinkedList<>();
queue.offer(1);
int a = queue.peek();//返回第一个元素
int b = queue.poll();//删除并返回第一个元素

双向队列Deque

Queue有一个子接口Dueue，即双向队列，和单向队列不同，它的出队入队可以从两个方向。

Dueue<Integer> q = new LinkedList<>(); //实例化
 
offFirst(Object e)   // 将指定元素添加到双端队列的头部 --- O(1)
 
offLast(Object e)   //将指定元素添加到双端队列的尾部 --- O(1)
 
pollFirst()   //获取并删除双端队列的第一个元素 --- O(1)
 
pollLast()   //获取并删除双端队列的最后一个元素 --- O(1)
 
peekFirst()   //获取但不删除双端队列的第一个元素 --- O(1)
 
peekLast()   //获取但不删除双端队列的最后一个元素 --- O(1)
 
isEmpty() //非空返回true，否则返回false
 
size() //队列中元素个数

七：Map 对象

import java.util.*;
public class MapExample {
    public static void main(String[] args) {
        
        Map<String,Integer> map = new HashMap<>();
        map.put("Linda",18);//增加
        boolean isContain = map.containsKey("Linda");//时间复杂度O(1)
        boolean isContain2 = map.containsValue(18);
        int age = map.get("Linda");//18
        int age2 = map.getOrDefault("Bob",0);//含有默认值
        map.remove("Linda");//移除
        //遍历map键值对
        for (Map.Entry<String,Integer> entry:map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
        }
        //遍历key
        for (String key:map.keySet()) {
            System.out.println(key);
        }
        //遍历value
        for (Integer value:map.values()) {
            System.out.println(value);
        }
    }
}

八：Set 对象

import java.util.*;
public class SetExample {
    public static void main(String[] args) {
        
        Set<Integer> set = new HashSet<>();//创建
        set.add(23);//增加
        boolean isContain = set.contains(15);//是否包含
        set.remove(23);//移除
        //遍历set
        for (Integer item : set) {
            System.out.println(item);
        }
        //清除
        set.clear();
    }
}

//T
import java.util.TreeSet;
public class TreeSetExample {
    public static void main(String[] args) {

        TreeSet<Integer> set = new TreeSet<>();

        for (int i = 0; i < 12; i += 2)
            set.add(i);

        Integer floor = set.floor(7); //6,向下取整，包括自身 <=7
        Integer ceiling = set.ceiling(5); //6,向上取值，包括自身 >=5
    }
}

九：优先队列PriorityQueue

offer(E e);    // 在堆中加入元素e，并调整堆。若成功入堆返回值true，否则返回false --- O(logN)
 
poll();    // 弹出堆顶元素，并重新调整堆，返回出队元素e --- O(logN)
 
peek();    // 查看堆顶元素， 返回值堆顶元素e --- O(1)j
 
isEmpty(); //判断队列是否为空
 
size(); //队列中元素数量

import java.util.*;

public class PriorityQueueExample {
    public static void main(String[] args) {

        PriorityQueue<Integer> minH = new PriorityQueue<>();//小根堆
        PriorityQueue<Integer> maxH = new PriorityQueue<>((a,b) -> b-a);//大根堆

        PriorityQueue<Integer> pq2 = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
    }
}

十：保留小数有效数字（四舍五入）

import java.math.*;

public class BigDecimalExample {
    public static void main(String[] args) {

        double a = 2.5111;
        BigDecimal decimal = new BigDecimal(a).setScale(2, RoundingMode.HALF_UP);
        System.out.println(decimal.toString());
    }
}

十一：长度计算

length属性是针对数组说的，比如说你声明了一个数组，想知道这个数组的长度则用到了length这个属性。
length()方法是针对字符串String说的，如果想看这个字符串的长度则用到length()这个方法。
size()方法是针对泛型集合泛型集合(Collection)如Set、List、Map说的，如果想看这个泛型有多少个元素，就调用此方法来查看。数组没有size()方法。

工具类

1、java.util.Math：主要包含数学内的应用方法

（1）Math.abs(参数)

作用：返回参数的绝对值

参数可以是 int，float，long，double等类型，返回值类型同参数类型。（参数也可以是short，byte，但是返回类型会转成int）

Math.abs(double a); 

（2）Math.max(参数1，参数2)，Math.min(参数1，参数2)

作用：返回两个参数的最大值，最小值。

参数可以是 int，float，long，double等类型，返回值类型同参数类型。（参数也可以是short，byte，但是返回类型会转成int）

Math.max(long a, long b);    //返回两个参数中较大的值
Math.min(long a, long b);    //返回两个参数中较小的值

（3）Math.sqrt(参数)、Math.cbrt(参数)

作用：开平方，开立方

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.sqrt(long a) //开平方
Math.cbrt(long b) //开立方

（4）Math.pow(参数1，参数2）

作用：返回参数1的参数2次方。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.pow(double a, double b)

（5）Math.ceil(参数)

作用：对浮点数向上取整。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.ceil(double a)

（6）Math.floor(参数)

作用：对浮点数向下取整。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.floor(double a)

（7）Math.round(参数)

作用：对浮点数四舍五入。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为int或者long。

Math.round(double a)

（8）Math.log(参数），Math.log10(参数)

作用：取对数。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.log(double a) //以e为底取对数
Math.log10(double b) //以10为底取对数

那么，以m为底取N的对数该如何求呢？

//注意：logmN：以m为底取N的对数。
Math.log(8)/Math.log(2); //该代码意为：以2为底取8的对数为：3。

（9）Math.random()

作用：返回一个随机数，随机数范围为[0，1)，左闭右开。返回值类型为double。

2、java.util.Arrays：主要包含了操作数组的各种方法

（1）Arrays.toString(arr)

作用：返回字符串，便于打印数组内容

String str = Arrays.toString(arr); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);

（2）Arrays.sort(arr，fromIndex，toIndex)

作用：数组升序

int[] a = new int[]{1,4,2,3,5};
Arrays.sort(a,0,5);//默认对全部元素升序，对下标0到下标为5-1的5个元素进行排序。

（3）Arrays.sort(arr，fromIndex，toIndex，Collections.reverseOrder())

作用：数组降序

Arrays.sort(a,1,3,Collections.reverseOrder());

（4）Arrays.equals()

作用：比较数组元素

int[] arr1 = {1,2,3};
int[] arr2 = {1,2,3};
System.out.println(Arrays.equals(arr1,arr2)); //输出：true
//如果是arr1.equals(arr2),则返回false，因为equals比较的是两个对象的地址，不是里面的数，而Arrays.equals重写了equals，所以，这里能比较元素是否相等。

（5）Arrays.copeOf() 和Arrays.copeOfRange()

作用：截取数组，传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。

int[] arr = {10,20,30,40,50};
int[] arr1 = Arrays.copyOf(arr, 3);
String str = Arrays.toString(arr1); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[10, 20, 30] （截取arr数组的3个元素赋值给新数组arr1）


int []arr = {10,20,30,40,50};
int []arr1 = Arrays.copyOfRange(arr,1,3);
String str = Arrays.toString(arr1); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[20, 30] （从第1位（index=0开始）截取到第3位（不包括）

3、java.util.Collections：主要对集合进行操作

（1）Collections.sort()

作用：升序/降序

4、基本类型的最大值与最小值

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;