进制转换
十进制转十六进制：Integer.toHexString(int i)
十进制转八进制：Integer.toOctalString(int i)
十进制转二进制：Integer.toBinaryString(int i)
十六进制转十进制：Integer.valueOf("FFFF",16).toString()
八进制转十进制：Integer.valueOf("876",8).toString()
二进制转十进制：Integer.valueOf("0101",2).toString()
String
比较
compareTo方法最为重要，如 A.compareTo(B)返回结果有三种：
- >0: 字符串A>B；
- <0:字符串A<B;
- =0:字符串A=B；
分割
String str = "hello world";
String[] data = str.split(" ");
for (int i = 0; i < data.length; ++i) {System.out.println(data[i]);
}
判空
if(str.equals(""));
查找
contains()方法
获取某一字符
str.charAt(idx)
裁剪
str.substring(idx)
容器
序列式容器
数组
ArrayList
- 底层是Object数组
- 常用方法：get()、remove(idnex/obj)、size()、indexOf(obj)、contains()相当于find、clear、isEmpty()
int[] intArray = new int[]{1, 2, 3};
Integer[] integerArray = new Integer[]{1, 2, 3};List<int[] > intArrayList = Arrays.asList(intArray);
List<Integer> integerList = Arrays.asList(integerArray);
List<Integer> integerList2 = Arrays.asList(1, 2, 3);
LinkedList
- 底层是双向链表
- 常用方法：get()、remove(idnex/obj)、size()、indexOf(obj)、contains()相当于find、clear、isEmpty()
- addFirst(E e)、addLast(E e)、removeFirst()、removeLast()
//List 的ArrayList 实现
List<String> list1 = new ArrayList<>();// List 的LinkedList 实现
List<String> list2 = new LinkedList<>();// Stack对象创建
Stack<Integer> stk = new Stack<>();
NOTE：尖括号里不能用基础数据类型，需要包装。
| 基础数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| boolean | Boolean |
| char | Character |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
栈Stack
- 常用方法：push(obj)、pop()、peek()、isEmpty()、empty()
队列Queue
- 常见方法：offer(elem)/add(elen)、peek()/element、remove()
双端队列Deque
Deque<String> deque = new LinkedList<>();
- 常用方法：
- addFirst()/getFirst()、addLast()/geLast()
- removeFirst()、removeLast()、remove(idx)/remove(object)
- set(idx,elem)
- size()、isEmpty()、toArray()
优先队列PriorityQueue
PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {public int compare(Integer o1, Integer o2) {return o2-o1; //从大到小排序}
});
- 常用方法：offer(elem)、peek()、poll()、remove(elem)
关联式容器
set
- 常见方法：add()、addAll()、size()、remove()、iterator()、contains(obj)、clear()
HashSet
HashSet<String> sites = new HashSet<String>();
- 常见方法：add()、remove(obj)、size()、isEmpty()、contains(obj)、clear
TreeSet
有序map
map
- 常用方法：put(k，v)、get(key)、remove()、size()、containsKey()
HashMap
- 常用方法：put(k，v)、get(key)、remove()、size()、containsKey()
TreeMap
有序map
- 常用方法：put(k，v)、get(key)、remove()、size()、containsKey()
自定义排序
对List进行排序
//数组
Integer[] integers = {2,7,5,3,1};
String[] strings = {"watermelon","apple","orange"};
//对数组排序
Arrays.sort(integers);
Arrays.sort(strings);//List
List<Integer> integerList = Arrays.asList(integers);
List<String> stringList = Arrays.asList(strings);
//对List进行排序
Collections.sort(integerList);
Collections.sort(stringList);Collections.sort(list, new Comparator<User>() {@Overridepublic int compare(User o1, User o2) {int age1 = o1.getAge();int age2 = o2.getAge();if (age1 == age2) {return 0;}else {// 从小到大return age1 > age2 ? 1 : -1 ;// 如果需要从大到小，可以将return的值反过来即可}}
});
对Object进行排序
1. 通过实现Comparator接口排序（重写compare方法，作为sort的第二参数）
class Student {public Student(String name, int score, int age) {this.name = name;this.score = score;this.age = age;}
}class sortAge implements Comparator<Student> {@Overridepublic int compare(Student stu1, Student stu2) {return stu1.getAge() - stu2.getAge();}
}public class customSorting {public static void main(String[] args) {// 1. 通过实现Comparator接口排序（重写compare方法）List<Student> list = new ArrayList<Student>();list.add(new Student("As", 23, 55));list.add(new Student("A2", 135, 23));list.add(new Student("cv", 99, 27));list.add(new Student("edrf", 123, 43));Collections.sort(list,new sortAge());for (int i = 0; i < list.size(); i++) {Student temp = list.get(i);System.out.println(temp.getName()+","+temp.getScore()+","+temp.getAge()+",");}}
}
输出：
A2,135,23,
cv,99,27,
edrf,123,43,
As,23,55,
2.通过实现Comparable接口排序（重写compareTo方法，不需要传参）
class Student implements Comparable<Student> {public Student(String name, int score, int age) {this.name = name;this.score = score;this.age = age;}@Overridepublic int compareTo(Student stu) {return this.getScore() - stu.getScore();}
}public class customSorting {public static void main(String[] args) {... ...// 2. 通过实现Comparable接口排序（重写compareTo方法）Collections.sort(list);for (int i = 0; i < list.size(); i++) {Student temp = list.get(i);System.out.println(temp.getName()+","+temp.getScore()+","+temp.getAge()+",");}}
}
输出：
As,23,55,
cv,99,27,
edrf,123,43,
A2,135,23,
Stream流体系
- 目的：用于简化集合和数组操作的APl。
Stream流式思想的核心：
- 先得到集合或者数组的Stream流（就是一根传送带）
- 把元素放上去
- 然后就用这个Stream流简化的API来方便的操作元素。
集合获取Stream流的方式
使用Collections接口中的默认方法Stream()
//Collection集合获取流
Collection<String> list = new ArrayList<>();
Stream<String> s = list.stream();//Map集合获取流
Map<String,Integer> maps = new HashMap<>();
//键流
Stream<String> keyStream = maps.keySet().stream();
//值流
Stream<Integer> valueStream = maps.values().stream();
//键值对流
Stream<Map.Entry<String,Integer>> keyAndValueStream = maps.entrySet().stream();
数据获取Stream流的方式
Stream()或of()方法
//数组获取流
String[] names = {"赵敏","小昭","灭绝","周芷若"};
Stream<String> nameStream = Arrays.stream(names);
Stream<String> nameStream2 = Stream.of(names);
- filter()：用于对流中的数据进行过滤
- limit()：获取前几个元素
- skip()：跳过前几个元素
- distint()：去除流中重复的元素
- concat()：合并a和b两个流为一个流
//stream<T> filter(Predicatex?super T> predicate） 过滤
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));long size = list.stream().filter(s -> s.length() == 3).count();
System.out.println(size);//Stream<T> limit(long maxSize) 获取前几个元素
list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);//Stream<T> skip(long n) 跳过前几个元素
list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);//map加工方法：第一个参数原材料 -> 第二个参数是加工后的结果。
//给集合元素的前面都加上一个：黑马的：
list.stream().map(s -> "黑马的：" + s).forEach(s -> System.out.println(s));//需求：把所有的名称 都加工成一个学生对象。
list.stream().map(s -> new Student(s)).forEach(student -> System.out.println(student));//合并流
Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
Stream<String> s2 = Stream.of("hello","你好");
Stream<String> s3 = Stream.concat(s1,s2);
s3.forEach(s -> System.out.println(s));
注意：
- 中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程。
- 在Stream流中无法直接修改集合、数组中的数据。
常见终结操作方法
- forEach()：对此流中的每个元素执行遍历操作
- count()：返回此流中的元素数
Stream流的收集操作
**收集Stream流的含义：**就是把Stream流操作后的结果数据转回到集合或者数组中去。
Stream流：方便操作集合/ 数组的手段。
集合/数组：才是开发中的目的。
具体方法：
-
collect()：开放收集Stream流，指定收集器
-
toList()：收集到List集合中
-
toSet()：收集到Set集合中
-
toMap()：收集到Map集合中
Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
List<String> zhangList = s1.collect(Collectors.toList());
System.out.println(zhangList);//注意："流只能使用一次"
Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
Set<String> zhangSet = s2.collect(Collectors.toSet());
System.out.println(zhangSet);
)
