知识点

常用知识点

类型	函数名	作用	输入参数	返回值	例子
String	split	根据输入参数分拆成字符串数组	String	String[]	String[] tokens = s.split(“ “);
String	trim	将前后空格去掉	N/A	String	s = s.trim()
String	toCharArray	将字符串变成字符数组	N/A	char	char[] a = s.toCharArray()
String	charAt	取某字符	int	char	num1.charAt(i)
String	length	取某字符长度	int	int	num1.length()
String	equals	判断相等	String	boolean	“”.equals(str)
String	substring	取某字符[beginIdx, endIdx)子串	int, int	String	“smiles”.substring(1,5)->”mile”
Integer	parseInt	字符串变整型	String	int	Integer.parseInt(“2”); Integer.parseInt(“100”, 2) -> 4，任意进制数转为10进制。
Integer	Integer.MIN_VALUE	整型最小值	N/A	int	Integer.MIN_VALUE
Integer	Integer.toString	整型->String	int	String	Integer.toString(root.val)
StringBuilder	append	将新字符（串）加入到末尾	String或char	N/A	sb.append(“abc”)
StringBuilder	new StringBuilder()	新建这个类当然也将目前字符串清空	N/A	N/A	sb=new StringBuilder()
StringBuilder	reverse	反转	N/A	StringBuilder	sb.reverse()
StringBuilder	toString	StringBuilder变成字符串	N/A	String	sb.reverse().toString()
StringBuilder	deleteCharAt	StringBuilder删除某字符	N/A	int	sb.deleteCharAt(sb.length() - 1);
Arrays	length	数组长度	N/A	int	ary.length
Arrays	sort	对数组正(逆)排序	T[]	N/A	Arrays.sort(nums1); Arrays.sort(nums1,Collections.reverseOrder()); Arrays.sort(nums1,new Comparator(){});
Arrays	asList	包装类型数组转化成List	T[]	List	Arrays.asList(ary), ary为Integer数组或者常量 List: Arrays.asList(“a”, “b”);
Arrays	stream	基本类型数组转化成List	N/A	N/A	List re = Arrays.stream(ints).boxed() .collect(Collectors.toList())
Arrays	N/A	去重	int[]	int[]	Set set = new HashSet<>(list);set->int[]
Collections	sort	对List排序	List	N/A	Collections.sort(list); Collections.sort(l, Collections.reverseOrder());
ArrayList	new ArrayList<>()	新建List	N/A	List	List l = new ArrayList<>()
ArrayList	stream	List转为基本类型数组	List	int[]	int[] re = l.stream().mapToInt(i->i).toArray()
ArrayList	stream	List转为Object类型数组	List	Integer[]	Integer[] re = l.toArray(new Integer[0]);
ArrayList	add	把一个元素加入到List l中	List	N/A	l.add(“pen”);
ArrayList	addAll	把一个List的所有元素加入到另一个中	List	N/A	l2.addAll(l);
ArrayList	get	返回给定的下标对应的元素	List	T	l.get(2);
ArrayList	remove	把给定下标的元素从List l中删除	List	N/A	l.remove(2);
ArrayList	remove	把第一个出现的元素从List l中删除	List	N/A	l.remove(“pen”);
ArrayList	size	大小	List	int	l.size();
ArrayList	reverse	反转	List	N/A	Collections.reverse(l);
LinkedList	add	加到末尾	T	N/a	ll.add(2);
LinkedList	remove	头部删除	N/A	T	ll.remove();
LinkedList	addFirst	加到头部	T	N/A	ll.addFirst(2);
LinkedList	removeLast	末尾删除	N/A	T	ll.removeLast();
Queue	new LinkedList()	新建/复制队列	N/A	Queue	Queue q = new LinkedList<>(q2)
Queue	offer	不抛异常的加入尾元素	T	N/A	q.offer(5)
Queue	poll	不抛异常的取出头元素	N/A	T	Integer i = q.poll()
Queue	peek	不抛异常的看看头元素	N/A	T	Integer i = q.peek()
Stack	new Stack	新建栈	N/A	Stack	Stack s = new Stack<>()
Stack	peek	获取栈顶元素但不出栈	N/A	T	Integer i = s.peek()
Stack	pop	获取栈顶元素且出栈	N/A	T	Integer i = s.pop()
Stack	push	加入	T	N/A	s.push(5)
Stack	isEmpty	是否为空	N/A	boolean	s.isEmpty()
HashMap	new HashMap	新建哈希表	N/A	Map	Map m = new HashMap<>()
HashMap	get	获取	T	T	m.get(‘a’)
HashMap	put	加入	T,T	N/A	m.put(‘a’,5)
HashMap	containsKey	是否含有某个key	T	boolean	m.containsKey(‘a’)
HashMap	get,put	更新key对应的value	N/A	N/A	m.put(‘a’,m.get(‘a’)+1)
Map	Map.of	Map常量	N/A	Map	Map.of(2, “abc”, 3, “def”);
Iterator	Iterator	entrySet	N/A	N/A	Iterator it = map.entrySet().iterator();
Iterator	Iterator	keySet	N/A	N/A	Iterator it = map.keySet().iterator();
Iterator	hasNext	有无下一个元素	N/A	N/A	while(it.hasNext())
Iterator	next	下一个元素	N/A	N/A	Map.Entry pair = (Map.Entry)it.next()
Map.Entry	getValue, getKey	得到key, Value	N/A	N/A	pair.getValue(), pair.getKey()
HashSet	new HashSet	新建哈希集	N/A	Set	Set m = new HashSet<>()
HashSet	add	加入	T	N/A	m.add(‘a’)
HashSet	remove	删除	T	N/A	m.remove(‘a’)
HashSet	contains	是否含有某个元素	T	boolean	m.contains(‘a’)
PriorityQueue	offer,poll,peek	与Queue相同	N/A	N/A	N/A
PriorityQueue	Comparator	k大小的heap	N/A	N/A	见下

PriorityQueue<Node> minHeap = new PriorityQueue<Node>(k,
				new Comparator<Node>() {
					@Override
					public int compare(Node o1, Node o2) {
						return o1.value - o2.value;
					}
				}
		);

Arrays的二分法： 若找不到，返回比tgt大的数的下标数组长度的负值-1。

int[] lis = new int[len];
int index = Arrays.binarySearch(lis, 0, len, tgt);
if(index < 0) {
	index = -index - 1;
	lis[index] = tgt;
}
else
	lis[index] = tgt;