java 知识

1.Java中的集合类

（1）LinkedList的方法的应用

 LinkedList<String> linkedList = new LinkedList<>();

add
boolean add(E e)：在链表后添加一个元素，如果成功，返回true，否则返回false；
void addFirst(E e)：在链表头部插入一个元素；
addLast(E e)：在链表尾部添加一个元素；
void add(int index, E element)：在指定位置插入一个元素。

remove
E remove()；移除链表中第一个元素；
boolean remove(Object o)：移除链表中指定的元素；
E remove(int index)：移除链表中指定位置的元素；
E removeFirst()：移除链表中第一个元素，与remove类似；
E removeLast()：移除链表中最后一个元素；
boolean removeFirstOccurrence(Object o)：移除链表中第一次出现所在位置的元素；
boolean removeLastOccurrence(Object o)：移除链表中最后一次出现所在位置的元素

get
E get(int index)：按照下边获取元素；
E getFirst()：获取第一个元素；
E getLast()：获取第二个元素；

push、pop、poll
void push(E e)：与addFirst一样，实际上它就是addFirst；
E pop()：与removeFirst一样，实际上它就是removeFirst；
E poll()：查询并移除第一个元素；pollFirst(),pollLast()

peek
E peek()：获取第一个元素，但是不移除；
E peekFirst()：获取第一个元素，但是不移除；
E peekLast()：获取最后一个元素，但是不移除；

原文链接：https://blog.csdn.net/sinat_36246371/article/details/53709625

（2）HashMap

（1）put(K key, V value)
（2）get(Object key)
（3）size()
（4）clear()
（5）isEmpty ()
（6）remove(Object key)
（7）values()
（8）keySet() 
（9）entrySet() 
（10）iterator 迭代
 (11)containsKey(Object key)和containsValue(Object value)

原文链接：https://blog.csdn.net/Liuxiaoyang1999/article/details/98958742

（3）HashSet 的特点是不会存储重复元素，所以可以利用 HashSet 来查找出重复的元素；

Set<Integer> dic = new HashSet<>();
dic.contains(num);
dic.add(num);
dic1.addAll(dic2);
dic.remove(num);
dic1.removeAll(dic2);//dic1去掉dic2包含的元素;
dic1.retainAll(dic2)//dic1和dic2相同的保留在dic1中;

4Java-Arrays类常用方法详解

Arrays类位于 java.util 包中，主要包含了操纵数组的各种方法。
Arrays类的常用方法

1.Arrays.fill(Object[ ] array, Object obj),用指定元素填充整个数组(替换数组原元素);

2.Arrays.sort(Object [ ]arr),对传入数组进行递增排序，字符则按照ASCII进行排序(不区分大小写);
Arrays.sort(Object [ ]arr,int start,int end),对区间内的元素进行递增排序;

3.Arrays.equal(Object []arr,Object []nums),判断两个数组是否相等，实际上比较的是两个数组的哈希值;

4.Array.hashCode(Object []arr),返回数组的哈希值;

5.Arrays.toString(Object []arr)

将数组中的内容全部打印出来

2.String

字符串大小写转换

s.toLowerCase();
s.toUpperCase();

(1)StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象,由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类

StringBuilder builder. = new StringBuilder();
builder.append("%20");
builder.insert(0, "you");
builder.deleteCharAt(index);删除
builder.delete(beginIndex, endIndex);
builder.toString();
builder.reverse();//反转
builder.delete( 0, builder.length() );//清空

(2)String.valueOf()方法的使用

1）String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串 
（2）String.valueOf(char c) : 将 char 变量 c 转换成字符串 
（3）String.valueOf(char[] data) : 将 char 数组 data 转换成字符串 
（4）String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串 

（5）String.valueOf(double d) : 将 double 变量 d 转换成字符串 
（6）String.valueOf(float f) : 将 float 变量 f 转换成字符串 
（7）String.valueOf(int i) : 将 int 变量 i 转换成字符串 

由 String 转换成 数字的基本数据型态

1）byte : Byte.parseByte(String s) : 将 s 转换成 byte 

（2）Byte.parseByte(String s, int radix) : 以 radix 为基底 将 s 转换为 byte ，比如说 Byte.parseByte("11", 16) 会得到 17 

（3）double : Double.parseDouble(String s) : 将 s 转换成 double 

（4）float : Double.parseFloat(String s) : 将 s 转换成 float 

（5）int : Integer.parseInt(String s) : 将 s 转换成 int 

（6）long : Long.parseLong(String s)

原文链接：https://blog.csdn.net/weixin_41585557/article/details/83753958

(3)compareTo()方法

返回参与比较的前后两个字符串的ASCII码的差值，如果两个字符串首字母不同，则该方法返回首字母的ASCII码的差值。

String a1 = "a";
String a2 = "c";        
System.out.println(a1.compareTo(a2));//结果为-2

参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值。

String a1 = "aa";
String a2 = "ad";        
System.out.println(a1.compareTo(a2));//结果为-3

如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值。

String a1 = "aa";
String a2 = "aa12345678";        
System.out.println(a1.compareTo(a2));//结果为-8

原文链接：https://blog.csdn.net/weixin_38174000/article/details/1087746

Comparator

Comparator 是javase中的接口，位于java.util包下。

数组工具类和集合工具类中提供的工具方法sort方法都给出了含有Comparator接口的重载方法。

Arrays.sort(T[],Comparator<? super T> c);
Collections.sort(List<T> list,Comparator<? super T> c);

List实例调sort方法

default void sort(Comparator<? super E> c) 

demo如下：

List<Character> letters = new ArrayList<>(str.length());

// 将英文字母先排序好
letters.sort(new Comparator<Character>() {
    @Override
    public int compare(Character o1, Character o2) {
        return Character.toLowerCase(o1) - Character.toLowerCase(o2);
    }
});

-------
int[][] envelopes
//将二维数组envelopes按照每行第一列重新排序
Arrays.sort(envelopes, (a,b) -> (a[0]-b[0]));
//将二维数组envelopes按照每行第一列重新排序，第一列相同就按第二列
Arrays.sort(envelopes, (a, b) -> (a[0] == b[0] ? b[1]-a[1] : a[0]-b[0]));

我们只需要重写compare方法即可实现排序。

int compare(Object o1, Object o2) 返回一个基本类型的整型
如果要按照升序排序，
则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序
则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

版权声明：本文为CSDN博主「西京刀客」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/inthat/article/details/113540405

（4）substring

① public String substring(int beginIndex)
这个方法截取的字符串是从索引beginIndex开始的，到整个字符串的末尾。

② public String substring(int beginIndex, int endIndex)
这个方法截取的字符串从beginIndex开始，到字符串索引的endIndex - 1结束。

String s = saahdfasgfdga;
System.out.println(s.substring(0, 2));
// sa
System.out.println(s.substring(2));
//ahdfasgfdga

（5）Java String 方法 matches的使用及正则表达式

\d	数字：[0-9]
\D	非数字：等同于 [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]
\	将下一字符标记为特殊字符、文本、反向引用或八进制转义符。
        例如，“n"匹配字符"n”。"\n"匹配换行符。序列"\\“匹配”\"，"\(“匹配”("。
*	等价于｛0，｝ 匹配0至多个在它之前的字符。
        例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。正则表达式 “.*” 意味着能够匹配任意字符串。
+	等价于｛1，｝ 匹配前面的子表达式一次或多次。例如正则表达式9+匹配9、99、999等。
?	等价于｛0，1｝匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 或 “does” 中的"do" 。
        此元字符还有另外一个用途，就是表示非贪婪模式匹配。
{n}	n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,}	n 是非负整数。至少匹配 n 次。例如，"o{2,}“不匹配"Bob"中的"o”，而匹配"foooood"中的所有 o。"o{1,}“等效于"o+”。
        "o{0,}“等效于"o*”。
{n,m}	m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。
        ‘o{0,1}’ 等效于 ‘o?’。注意：您不能将空格插入逗号和数字之间。
.	匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
（）	将 () 之间括起来的表达式定义为“组”(group)，并且将匹配这个表达式的字符保存到一个临时区域。
        这个元字符在字符串提取的时候非常有用。捕获组可以通过从左到右计算其开括号来编号。
(\d)	第一组
((A)(B©))	第一组 ((A)(B©)) 第二组 (A) 第三组(B©) 第四组©

原文链接：https://blog.csdn.net/juzixiansheng/article/details/87867118

（6）Character类成员方法

public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
public static boolean isDigit(char ch):判断给定的字符是否是数字字符
public static char toUpperCase(char ch):把给定的字符转换为大写字符
public static char toLowerCase(char ch):把给定的字符转换为小写字符
public static boolean isLetter(char ch):判断给定的字符是否是字母

版权声明：本文为CSDN博主「@Wenk」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/hewenqing1/article/details/103765380

(6)indexOf()方法

• indexOf()方法：
  直接上代码：

String s = "01234560123456";

int a = s.indexOf('1'); // 返回第一个字符1的下标
int b = s.indexOf("23"); // 返回第一个字符串“23”的下标
int c = s.indexOf('1',5); // 以下标5开始，返回第一个字符1的下标
int d = s.indexOf("23",5); // 以下标5开始，返回第一个字符串“23”的下标

判断是否有该字符：

Number 查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1。

• lastIndexOf()方法：

直接上代码

String s = "01234560123456";

int a = s.lastIndexOf('1'); // 返回最后一个字符1的下标
int b = s.lastIndexOf("23"); // 返回最后一个字符串“23”的下标
int c = s.lastIndexOf('1',5); // 以下标5为终点，返回最后一个字符1的下标
int d = s.lastIndexOf("23",5); // 以下标5为终点，返回最后一个字符串“23”的下标

原文链接：https://blog.csdn.net/weixin_43849277/article/details/108321315

3.构建一个栈，用来存储链表中每个节点的值

Stack<Integer> stack = new Stack<>();
// 把每个节点的值加入到栈中
stack.push(curNode.val);
// 数组接收栈顶元素值
res = stack.pop();

4.位运算

通过异或消掉相同的数
sum^=num;
----
找出sum最右边的1，求出两个异或数最右侧不同位
sum^=num1;
sum^=num2;
flag=(-sum)∑
flag&num1==0;flag&num2!=0;
----
消掉最右边的1,有多少1可以消多少次
n&(n-1)

其他

MATH 类常用方法

保留两位小数

public class Solution {
    public static void main(String[] args) {
        double d = 1.24556;
        System.out.println(String.format("%.2f",d));
        System.out.println((double) Math.round(d*100)/100);
    }
}
/*
1.25
1.25
*/