1. 二维数组
-
初始化
int[][] grid = { {1,2,3}, {2,0,4}, {3,1,1} }; -
判断二维数组是否为空
二维数组为空，要检查三个部分:
-
一是数组首地址是否为空
-
二是是否为{}，也就是array.length==0的情况
-
三是是否为{{}}，这时array.length=1，但是array[0].length==0。
所以判断语句为
if(array==null||array.length==0||(array.length==1&&array[0].length==0)) -
2. List< Character>
List<Character> list = new LinkedList<Character>();
list.add("a");
获取第0个元素list.get(0)，而不是list[0]
3. Arrays工具类
-
复制数组
Arrays.copyOfRange(arr, from, to)表示从arr数组的from下标出开始复制，复制到下标to处。不包含下标为to的元素。int a[] = new int[] { 18, 62, 68, 82, 65, 9 }; int[] b = Arrays.copyOfRange(a, 0, 3);int[] b = Arrays.copyOf(arr, newLength)表示从arr数组开头位置复制newLength个元素 -
排序
Arrays.sort(Object[] array);//默认按照升序排序 Arrays.sort(Object[] array, new MyComparator());//按自定义的排序规则排序 //对数组元素指定范围进行排序（排序范围是从元素下标为from,到下标为to-1的元素进行排序 Arrays.sort(Object[] array, int from, int to); -
二分搜索
Arrays.binarySearch(Object[] arr, Object key)//返回数组中key的索引，否则返回-1或插入点索引（负数） -
转换为字符串
Arrays.toString(arr);
4. Collection & Collections
-
java.util.Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。List和Set继承了Collection接口。
-
java.util.Collections是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
Collections中的方法
https://www.cnblogs.com/guweiwei/p/6511974.html
-
排序操作（主要针对List接口相关）
- reverse(List list)：反转指定List集合中元素的顺序
- shuffle(List list)：对List中的元素进行随机排序（洗牌）
- sort(List list)：对List里的元素根据自然升序排序
- sort(List list, Comparator c)：自定义比较器进行排序
- swap(List list, int i, int j)：将指定List集合中i处元素和j出元素进行交换
- rotate(List list, int distance)：将所有元素向右移位指定长度，如果distance等于size那么结果不变
-
查找和替换（主要针对Collection接口相关）
- binarySearch(List list, Object key)：使用二分搜索法，以获得指定对象在List中的索引，前提是集合已经排序
- max(Collection coll)：返回最大元素
- max(Collection coll, Comparator comp)：根据自定义比较器，返回最大元素
- min(Collection coll)：返回最小元素
- min(Collection coll, Comparator comp)：根据自定义比较器，返回最小元素
- fill(List list, Object obj)：使用指定对象填充
- frequency(Collection Object o)：返回指定集合中指定对象出现的次数
- replaceAll(List list, Object old, Object new)：替换
5. Array & Arrays
-
数组类Array
Java中最基本的一个存储结构,提供了动态创建和访问 Java 数组的方法,其中的元素的类型必须相同。
效率高，但容量固定且无法动态改变。它无法判断其中实际存有多少元素，length只是告诉我们array的容量。 -
工具类Arrays
此静态类专门用来操作array ，提供搜索、排序、复制等静态方法。
equals()比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
注意区分==，这个是地址相等sort()使用归并排序对数组进行排序，默认升序binarySearch()使用二分查找 在排好序的array中寻找元素Arrays.asList(array)将数组array转化为List
6. 求长度
-
字符串，使用
length()String str = "abd"; int len = str.length(); -
数组，使用
lengthint[] arr = new int[]{1,2,3}; int len = arr.length; -
Integer.MIN_VALUEInteger.MAX_VALUE经常会用到
7. LinkedList<>
使用什么类型就用什么类型的方法，不能混用，否则容易出错
class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
- 实现了
List<E>接口，可以当链表使用； - 实现了
Deque<E>接口，可以当队列使用，也可以当栈使用。
LinkedList的定义中，有两个节点，first和last，分别指向队列的头和尾。
然后使用linkFirst(E)、linkLast(E)、unlinkFirst(E)、unlinkLast(E)来维持元素之间的关系
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
...
}
7.1 当链表使用
E get(int);
E set(int, E);
void add(int, E);
E remove(int);
7.2 当双端队列使用
//添加
void addFirst(E);
void addLast(E);
boolean offerFirst(E);
boolean offerLast(E);
//删除
E removeFirst(E);
E removeLast(E);
E pollFirst(E);
E pollLast(E);
//获取
E getFirst();
E getLast();
其中还有如下方法
boolean add(E);
boolean offer(E);
E remove();
E poll();
其中offer和add方法如下
public boolean offer(E e) {
return add(e);
}
public boolean add(E e) {
linkLast(e);
return true;
}
7.3 当栈使用
当栈使用的时候，操作first节点。
public void push(E e) { addFirst(e); }
public E pop() { return removeFirst(); }
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
也可以按照意愿获取栈顶或栈底元素
E peekFirst();//和E peek()实现方式一模一样
E peekLast();
8. 使用平衡二叉树(红黑树)
//定义一个红黑树
TreeMap<Integer, String> map = new TreeMap<>();
map.put(1, "zuo");
mpa.put(12, "0.0");
map.put(25, "xiang");
mpa.put(20, "qwq");
//具有普通HashMap的功能
System.out.println(map.containsKey(5));
System.out.println(map.get(12));
//也具有一些特殊功能，红黑树已经把key排好序了
//找到最大key值的值
System.out.println(map.lastKey());
//找到最小key值的值
System.out.println(map.firstKey());
//找到最接近一个值且比其大的key的值
System.out.println(map.ceilingKey(12));//返回20
//找到最接近一个值且比其小的key的值
System.out.println(map.floorKey(12));//返回1
//返回一个具有与TreeMap相同元素的集合。
for(Entry<Integer, String> entry : map.entrySet()){
int num = entry.getKey();
String name = entry.getValue();
...
}
9. 位运算
^异或运算：如a与b异或，为a^b
异或操作满足交换律：a^b=c则b^c=a和a^c=b
~非运算，位上0变为1， 1变为0。
10. Scanner
- next()遇到 空格 就结束，对输入有效字符之前遇到的空白，next() 方法会自动将其吃掉
- nextLine()遇到 回车 就结束，获得的字符串中可以有空格
- nextInt()根据分隔符（回车，空格等）只取出输入的流中分割的第一部分并解析成Int，然后把后面的字节传递下去。后面要跟一个nextLine()方法“消化”掉那个多余的回车字符。
输入单行的多个数字应使用如下方式：使用hasNext()把空格吃掉
Scanner sc = new Scanner(System.in);
int n = 0;
System.out.println("请输入数组的长度");
n = sc.nextInt();
System.out.println("请输入数组中的元素");
int[] arr = new int[n];
for(int i = 0; i < n; i++){
if(sc.hasNext()){
arr[i] = sc.nextInt();
}
}
也可以先当成字符串读取进来，然后转换为int
Scanner sc = new Scanner(System.in);
String inputString = sc.nextLine();
String[] stringArray = inputString.split(" ");
int num[] = new int[stringArray.length];
for (int i = 0; i < stringArray.length; i++) {
num[i] = Integer.parseInt(stringArray[i]);
}
例子：
输入样例：第一行为字符串，第二行为一个数字
abc
2
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String s = sc.nextLine();//代码1：使用nextLine()能获取字符串，遇到回车结束
System.out.println("s " + s);
int k = sc.nextInt();//代码2：使用nextInt()能获取数字，遇到回车结束。
//如果没有代码3，代码1就会把这个回车吃掉。当有多个测试用例的时候，就会出现错误
System.out.println("k " + k);
String eat = sc.nextLine();//代码3
System.out.println("eat " + eat);
System.out.println(printK(s, k));
}
}
11. String & StringBuilder & StringBuffer
-
StringBuilder线程不安全
-
StringBuffer线程安全
创建一个空的StringBuilder不能使用
StringBuilder stringBuilder = nullStringBuilder stringBuilder = new StringBuilder("");
String常用函数
String s = "abc";
String[] str = s.split(" ");char c = s.charAt(0);char[] charArr = s.toCharArray();s.substring(int start, int end);//左闭右开s.substring(int start)- 将数字转换为字符串
String s = String.valueOf(123);
12. 链表转数组
leetcode 和为s的连续正数序列用到了链表转数组
使用滑动窗口，但是需要返回一个二维数组int[][]
先构造一个int[]型的链表lists，然后使用toArray(T[] t)方法转换为数组
本题中
List<int[]> lists = new ArrayList<>();
...
return lists.toArray(new int[lists.size()][]);
传入的参数最好指定二维数组有多少行，如果指定二维数组较小，就会新创建一个数组，将链表中的值复制到这个新数组上，这不就有多余的操作了吗。还不如直接定义好二维数组的大小，转换为数组的时候，直接将链表中的值复制到这个定义好的二维数组上。
13. 小数点后几位
System.out.printf("%.2f",a);
14. HashMap的遍历
public static void iteratorMap(HashMap<Integer, String> map){
map.put(1, "aaa");
map.put(2, "bbb");
map.put(3, "ccc");
Iterator iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry entry = (Map.Entry) iterator.next();
Object key = entry.getKey();
Object value = entry.getValue();
int a = (int) key;
String s = (String) value;
System.out.println(a + " " + s);
}
}
15. ArrayList的遍历
public static void iteratorArrayList(ArrayList<String> list){
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
if(iterator.next().equals("b")){
iterator.remove();
}
}
}
16. 比较器
- 实现一个大根堆
Queue<Integer> pq = new PriorityQueue<>((v1, v2) -> v2 - v1);
- “aa"与"b”，让"aa"排前面，“30”与“3”，让“30”排前面
public static class MyComparator implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
return (o1 + o2).compareTo(o2 + o1);
}
}
17. 使用lamada表达式遍历集合
public static void main(String[] args){
Map<String,String> map= new HashMap<>();
map.forEach((k,v)->{
// 打印键
System.out.println(k);
// 打印值
System.out.println(v);
});
List<Stu> list = new ArrayList();
list.forEach((l)->{
System.out.println(l.getId());
System.out.println(l.getName());
});
Set<Stu> set = new HashSet<>();
set.forEach((s)->{
System.out.println(s.getId());
System.out.println(s.getName());
});
}
2154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
