文章目录
1、类型转换
1.1 Set变成int[ ]
1.2 int[ ]变成list
int[] data = {4, 5, 3, 6, 2, 5, 1};
// int[] 转 List<Integer>
List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
// Arrays.stream(arr) 可以替换成IntStream.of(arr)。
// 1.使用Arrays.stream将int[]转换成IntStream。
// 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
// 3.使用Stream的collect(),将Stream<T>转换成List<T>,因此正是List<Integer>。
// int[] 转 Integer[]
Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
// 前两步同上,此时是Stream<Integer>。
// 然后使用Stream的toArray,传入IntFunction<A[]> generator。
// 这样就可以返回Integer数组。
// 不然默认是Object[]。
// List<Integer> 转 Integer[]
Integer[] integers2 = list1.toArray(new Integer[0]);
// 调用toArray。传入参数T[] a。这种用法是目前推荐的。
// List<String>转String[]也同理。
// List<Integer> 转 int[]
int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
// 想要转换成int[]类型,就得先转成IntStream。
// 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
// 而IntStream中默认toArray()转成int[]。
// Integer[] 转 int[]
int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
// 思路同上。先将Integer[]转成Stream<Integer>,再转成IntStream。
// Integer[] 转 List<Integer>
List<Integer> list2 = Arrays.asList(integers1);
// 最简单的方式。String[]转List<String>也同理。
// 同理
String[] strings1 = {"a", "b", "c"};
// String[] 转 List<String>
List<String> list3 = Arrays.asList(strings1);
// List<String> 转 String[]
String[] strings2 = list3.toArray(new String[0]);
1.3 string相互转换char[ ]
//char[]变成string
String.valueOf(c);//之前直接toString后 经常会出现比较两个字符串内容相等时 为false
1.4 stringbuilder 变成 string
1.5 LinkedList<Int[ ]> 变成二维数组
1.6 基本数据类型变成String
1.7 char[]变成int
1.8 int[] 变成 string输出
System.out.println(Arrays.toString(nums));
2. ArrayList 和 LinkedList
2.1 二者区别
removeLast方法:只有linkedlist有
2.2 LinkedList变成数组
LinkedList<int[]> res = new LinkedList<>();
res.toArray(new int[res.size()][]);
2.3 ArrayList动态更新元素
arraylist.set(int index, E element)
//index - 索引位置
//element - 将在 index 位置替换进去的新元素
3. 二维数组
3.1 排序
Arrays.sort(intervals, (a,b)-> {
return Integer.compare(a[0],b[0]);
}
//按照第一个元素升序 排列
3.2 遍历
3.3 填充
char[][] chessboard = new char[n][n];
for (char[] c:chessboard){//记住写法
Arrays.fill(c,'.');
}
4. 遍历hashmap的key
5. 遍历hashmap
map.entrySet
//大顶堆 [ [key,count], ... ]
PriorityQueue<int[]> pq = new PriorityQueue<>( (x,y) -> y[1]-x[1]);
//用map.entrySet 把map解析为 entry类型
for(Map.Entry<Integer,Integer> entry:map.entrySet()){
pq.add(new int[]{entry.getKey(),entry.getValue()});
}
6. 删除前后空格
7. StringBuilder
8. substring方法:左闭右开
9. String判断是否存在某个字串
常用contains方法和substring方法
10. 英文字母
10.1 排序
//对List<String>的按字典序排序
Collections.sort(res);
//对char[]排序
Arrays.sort(temp);
10.2 大小写转换
//小写变大写
c[i] = (char)(c[i] - 'a' + 'A' );
//大写变小写
c[i] = (char) (c[i] - 'A' + 'a' );
11. Arrays.sort 对字符排序
1. 数字排序
int[] intArray = new int[] {4, 1, 3, -23};
Arrays.sort(intArray);
输出: [-23, 1, 3, 4]
2. 字符串排序,先大写后小写
String[] strArray = new String[] {"z", "a", "C"};
Arrays.sort(strArray);
输出: [C, a, z]
3. 严格按字母表顺序排序,也就是忽略大小写排序 Case-insensitive sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
输出: [a, C, z]
4. 反向排序, Reverse-order sort
Arrays.sort(strArray, Collections.reverseOrder());
输出:[z, a, C]
5. 忽略大小写反向排序 Case-insensitive reverse-order sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(strArray));
输出: [z, C, a]
12. str.compareTo()字符串相等
public class Test {
public static void main(String args[]) {
String str1 = "Strings";
String str2 = "Strings";
String str3 = "Strings123";
int result = str1.compareTo( str2 );
System.out.println(result);
result = str2.compareTo( str3 );
System.out.println(result);
result = str3.compareTo( str1 );
System.out.println(result);
}
}
13. Queue与Deque对比
- 使用deque作为栈
Deque<Integer> stack = new LinkedList<>();//后进先出
stack.push(0);
stack.peek()
stack.isEmpty()
stack.pop();
- Queue作为队列
Queue<> que = new LinkedList<>();
//个人习惯采用第一种
//成功返回true,失败时返回一个特殊值(取决于操作,为NULL或false)
que.offer();
que.poll();
que.peek();
//成功返回true,在操作失败时抛出异常
add(E e):添加一个元素到队尾
remove():获取队首的元素,并从队列中移除
element():获取队首的元素,但不从队列中移除
//
que.isEmpty();
14. 反转数组
Collections.reverse(list);
15.TreeMap的使用:对key排序
需要对HashMap的key进行排序
TreeMap<Integer,List<Integer>> map = new TreeMap<>();
//如果需要对其中的list添加元素
List<Integer> list = map.get(diff[i]);
if(list!=null){
list.add(i);
}else{
list = new LinkedList<>();
list.add(i);
}
map.put(diff[i],list);
//数据结构:
//key : 多个值,其中key是排序好的。
16. 判断两个数组相等
Arrays.equals(arr1,arr2)
17. String常用函数
- indexOf() 方法有以下四种形式:
public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1。
public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1。
int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1。
int indexOf(String str, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1。
- substring:左闭右开
public String substring(int beginIndex)
public String substring(int beginIndex, int endIndex)
beginIndex -- 起始索引(包括), 索引从 0 开始。
endIndex -- 结束索引(不包括)。
18. TreeMap自定义排序,字典序逆序输出
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
Map<Character,Integer> map = new TreeMap<>(new Comparator<Character>() {
@Override
public int compare(Character o1, Character o2) {
return o2 - o1;
}
});
for(int i=0;i<str.length();i++){
map.put(str.charAt(i),map.getOrDefault(str.charAt(i),0)+1);
}
for(Map.Entry entry: map.entrySet()){
System.out.print(entry.getKey());
System.out.print(entry.getValue());
}
}
}
输入:ccddDDAAA
输出:d2c2D2A3