常用api
ArrayList: List 接口
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public boolean addAll(collection 对象) ：将collection 的对象加入到
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public E set(int index,E element) 修改索引中的值，并返回原来的值
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
public boolean remove(Object o)直接删除数据，删除成功返回true,删除失败返回false
【Java】常用API——ArrayList类 - 陶然同学 - 博客园 (cnblogs.com)
List<Object> list = new ArrayList<Object>()
Collections.sort(list,(o1,o2)->{return o2-o1;});
Arrarys.sort()是用于给数组排序的，默认的情况下，是顺序排序，即从小到大
Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(arr, (o1,o2)->{return o2-o1;});
Collections.sor(list,(o1,o2)->{return o2-o1;});
List<Person> list = new ArrayList<Person>() {{
add(new Person(1, 30, "北京"));
add(new Person(2, 20, "西安"));
add(new Person(3, 40, "上海"));
}};
// 使用匿名比较器排序
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
})
java-------Arrary.sort 用 Comparator比较器定制排序方式（例如逆序）_java sort排序comparator-CSDN博客
LinkedList
队列
数组
LinkedList<String> lList = new LinkedList<String>();
public Object removeFirst()//删除第一个元素
public Object removeLast() //删除最后一个元素
双端队列
Deque<> queue = new LinkedList<>();
offerFirst() - 在双端队列的开头添加指定的元素。如果双端队列已满，则返回false。
offerLast() - 在双端队列的末尾添加指定的元素。如果双端队列已满，则返回false
peekFirst() - 返回双端队列的第一个元素。如果双端队列为空，则返回null。
peekLast() - 返回双端队列的最后一个元素。如果双端队列为空，则返回null。
pollFirst() - 返回并删除双端队列的第一个元素。如果双端队列为空，则返回null。
pollLast() - 返回并删除双端队列的最后一个元素。如果双端队列为空，则返回null。
队列
Queue<> queue = new LinkedList<>()
offer(e)
poll()
peek();
栈
Deque<> stack = new LinkedList<>();
push();
pop();
peek();
PriorityQueue
API
PriorityQueue<对象> q = new PriorityQueue<String>();
offer(E e) // 将指定元素插入此优先队列
add
peek() // 获取第一个元素，及最小或最大元素
poll() // 获取并移除第一个
remove(Object o) // 移除指定元素
size() // 返回元素个数
contains(Object o) // 如果包含指定元素返回true
自定义排序
Comparator<Object>cmp=new Comparator<Object>() {
public int compare(Object o1, Object o2) {
//升序
return o1-o2;
//降序
return o2-o1;
}
};
//自定义比较类，先比较长，长升序排列，若长相等再比较宽，宽降序
static Comparator<Node> cmp=new Comparator<Node>() {
public int compare(Node o1, Node o2) {
if(o1.chang!=o2.chang)
return o1.chang-o2.chang;
else
return o2.kuan-o1.kuan;
}
};
PriorityQueue<对象> q = new PriorityQueue<String>(cmp);
算法竞赛中的常用JAVA API：PriorityQueue(优先队列)（转载） - 记录学习Blog - 博客园 (cnblogs.com)
HashMap
HashMap<String,String> map = new HashMap<>();
map.getOrDefault("key", default)//如果map里有key就返回key对应的value，没有就返回default
在查找场景中，defualt设置为0，如果查询结果为空，则返回0；
map.containsKey("name"); //是否包含某个key
map.keySet(); //所有key----返回一个set集合
map.values(); //所有value
map.put("name","zhangsan"); //添加,若key存在，直接修改值
map.get("name"); //根据key--获取value
for(Map.Entry<Integer,String> entry : map.entrySet()){
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
刷题API
int [] ans;
ans.length;//长度
int [] result;
Arrays.sort(result); // 先进行排序
char[][]board;
board.length;//行
board[0].length // 列
String word;
word.charAt(index);//遍历第index位置的字符
String 转char[]
String word;
char[]words=word.toCharArray();
word.length();// 字符串的长度
String s;// 字符串 截取 startIndex,i+1 范围内
s.substring(startIndex, i + 1);
Map<Character, Character> pairs = new HashMap<Character, Character>() {{
put(')', '(');
put(']', '[');
put('}', '{');
}};
pairs.containsKey(ch)//判断是否包含ch 键值
map.put(num,map.getOrDefault(num,0)+1);//
map.getOrDefault(num,0);// 如果不存在赋值为0
Deque<Character> stack= new LinkedList<>();
stack.push(value);//入栈
stack.pop()//出zhan
stack.peek()// 栈顶元素
stack.size()// 栈中元素的个数
(1+2)/2.0=1.50000 转double 类型
字符串操作
StringBuilder()操作
public StringBuilder() 创建一个空白的可变的字符串对象，不包含任何内容
public StringBuilder(String str) 创建一个指定字符串内容的可变字符串对象
StringBuilder的常用方法
方法名称 说明
append(任意类型) 添加数据并返回StringBuilder对象本身
reverse() 将对象的内容反转
length() 返回对象内容长度
toString() 通过toString()就可以实现把StringBuilder转换为String
append方法的使用
String 常用api
String word;
word.charAt(index);//遍历第index位置的字符
String 转char[]
String word;
char[]words=word.toCharArray();
word.length();// 字符串的长度
String s;// 字符串 截取 startIndex,i+1 范围内
s.substring(startIndex, i + 1);
字符转int
String a="1";
System.out.println(Integer.parseInt(a));
int 转String
int c=1;
String d=c+"";
//字符串分割
String test="1,2,3,4,5";
String[] split = test.split(",");
排序算法
Arrays.sort
1维排序
默认升序
public static void main(String[] args) {
Integer []a={2,3,4,5,1};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
修改降序
public static void main(String[] args) {
Integer[]a={2,3,4,5,1};
Arrays.sort(a,(o1,o2)-> o2-o1);//降序
System.out.println(Arrays.toString(a));
}
注意事项
数组类型必须是Integer 类型，如果使用int类型 则降序报错
2维数组排序
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
// 初始化二维数组
int[][] array = {{5, 4}, {6, 4}, {6, 7}, {2, 3}};
// 首先按照每个子数组的第一个元素进行升序排列，如果第一个元素相同，则按照第二个元素进行降序排列
Arrays.sort(array, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
if (o1[0] == o2[0]) {
return o2[1] - o1[1]; // 如果第一个元素相同，则按照第二个元素降序排列
} else {
return o1[0] - o2[0]; // 否则按照第一个元素升序排列
}
}
});
// 打印排序后的二维数组
for (int i = 0; i < array.length; i++)
System.out.println(Arrays.toString(array[i]));
}
}
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
int[][] array = {{5, 4}, {6, 4}, {6, 7}, {2, 3}};
// 使用Lambda表达式简写Comparator接口的compare方法
Arrays.sort(array, (o1, o2) -> {
// 如果第一个元素相同，则按照第二个元素降序排列；否则按照第一个元素升序排列
if (o1[0] == o2[0]) {
return o2[1] - o1[1];
} else {
return o1[0] - o2[0];
}
});
// 打印排序后的二维数组
for (int i = 0; i < array.length; i++) {
System.out.println(Arrays.toString(array[i]));
}
}
}
[2, 3]
[5, 4]
[6, 7]
[6, 4]
PriorityQueue排序
Comparator<int> cmp = new Comparator<int>(){//自定义比较器
@Override
public int compare(int o1, int o2) {
return o1-o2;//升序
}
};
PriorityQueue<Integer> pq=new PriorityQueue<>(cmp);
等价于下面
PriorityQueue<Integer> pq=new PriorityQueue<>(((o1, o2) -> o1-o2));