【java笔试】常见方法汇总

数组

int[] nums = new int[5]
//默认nums[i]全为0；
int[] arrays = {1, 2, 3, 4, 5};
nums.length

排序

数组升序排序
Arrays.sort(nums);
数组降序排序
import java.util.Arrays;
import java.util.Collections;
public class Main {
	public static void main(String[] args) {
		Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, Collections.reverseOrder());
        int[] arr2 = Arrays.stream(a).mapToInt(Integer::valueOf).toArray();
        for(int arr:arr2) {
            System.out.print(arr + " ");
        }
	}
}
List升序（如果list是5 7 2 6 8 1 4）
Collections.sort(list) //list： 1 2 4 5 6 7 8
List降序
Collections.sort(list，Collections.reverseOrder())//list:8 7 6 5 4 2 1
List逆序
Collections.reverse(list)//list：4 1 8 6 2 7 5

二叉树常用知识点

存储树结点：List<TreeNode> listNode = new LinkedList<TreeNode>();
1、结点总数为n，则父节点数组下标从0到 n/2 -1 ，但是遍历时要小于n/2-1，因为最后一个父节点可能没有右孩子，当n/2-1为奇数时才有右孩子，为偶数时只有左孩子。
2、结点 i 左孩子下标为2i+1，右孩子下标为2i+2。
3、结点个数为n的完全二叉树的深度为|log2(n)|+1（取2的对数，然后向下取整+1）

scanner类的常用方法

Scanner scan = new Scanner(System.in)
scan.next()(默认是String类型，一个一个读取，遇到空格结束)
scan.hasNext()
scan.nextLine()（读取一整行，String类型）
scan.hasNextLine()
scan.nextInt()
scan.hasNextInt()

List集合的常用方法

List<Integer> list = new ArrayList<Integer>()
list.add("a")		//添加元素到末尾
list.add(1, "a")	//指定位置添加元素
list.size()			//长度
list.get(0)			//根据元素下标获取元素
list.remove(7)		//根据元素下标删除元素
list集合和数组转化（直接循环，简单粗暴不出错）

队列Queue用法

Queue<String> queue = new LinkedList<String>();
queque.size()			//长度
queque.offer('a')		//入队
queque.poll()			//删除队首元素
queue.peek()			//返回队首元素
add()和remove()方法在失败的时候会抛出异常(不推荐)

类型转化

java中List、integer数组、int数组之间的转化-1

java中List、integer数组、int数组之间的转化-2

int转化为String
1.String s=""+i;
2.String s=Integer.toString(i);
3.String s=String.valueOf(i);
把String转化为int型。
1.int i=Integer.parsenInt(s);
2.int i=Integer.valueOf(s).intValue();
String转char[]，字符串转字符数组
char ss[] = str.toCharArray()

String 常用方法

str = str.replace('H', 'W'); //可以字符，可以字符串，替换全部，新返回一个字符串
str = str.replaceFirst("He", "Wa");
str = str.replaceAll("He", "Wa");
str.length()						//长度
str1.equals(str2);					//两个串是否相等
str.trim()							//移除字符串两边的空格
str.split(" ")						//字符串分割
str.charAt(0)						//根据索引取出单个字符
str.substring(int beginIndex, int endIndex)	//截取字符串（左闭右开）
char[] charArray = str1.toCharArray()		//字符串转为字符数组

字符串中是否包含另外一个字符串
str.indexOf()方法：返回要匹配的字符串第一次出现的索引的位置,没出现过返回-1
str.contains()方法：判断是否包含指定字符串，包含返回true，不包含返回false
str.lastIndexOf()方法： 要匹配的字符串最后一次出现的索引

字符串反转
public static String reverseString(String str) {
        StringBuffer sBuffer = new StringBuffer(str);
        String string = sBuffer.reverse().toString();
        return string;
    }

StringBuffer常用方法

StringBuffer sBuffer = new StringBuffer("123")
sBuffer.append("a")							//添加元素
sBuffer.reverse()							//反转字符串
sBuffer.insert(int offset, int i)			//指定位置插入
sBuffer.delete(int start, int end)			//删除
sBuffer.replace(int start, int end, String str)//替换
sBuffer.toString()							//转化为字符串String
sBuffer.replace(9,12,"java")//，指定位置替换字符串，左包右不包，直接修改sBuffer本身

HashMap常用操作

HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
hashMap.put(key, value)				//存储键值对
hashMap.get(key)					//根据键获取值
hashMap.containsKey()				//是否包含键
hashMap.containsValue()				//是否包含值
hashMap.keySet()					//获得所有值
hashMap.values()					//获得所有值
hashMap.entrySet()					//获得键值对
hashMap.size()						//元素个数
hashMap.remove(key)					//根据键删除键值对
hashMap.isEmpty()					//是否为空
遍历哈希表
for(Integer id : hashMap.keySet()){
	System.out.println(hashMap.get(id))
}

实例（二维动态数组的存储）

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        String s = null;
        while (!(s = sc.nextLine()).equals("")) {
            String[] str = s.split(" ");
            List<Integer> list1 = new ArrayList<Integer>();
            for (int i = 0; i < str.length; i++) {
                list1.add(Integer.parseInt(str[i]));
            }
            list.add(list1);
        }
        System.out.println(list);
    }
}

//打印
5 6
1 2 3
1 2
1 5 6 7 8
1 2 3

[[5, 6], [1, 2, 3], [1, 2], [1, 5, 6, 7, 8], [1, 2, 3]]