java常见API和集合

目录

• java常见API
  • 拷贝数组
  • list初始化一些数据
    • 数组批量赋值初始化：
  • List 的API
    • ArrayList
  • 数组的Arrays.sort()自定义排序的实现
  • 实现Comparator接口有两种方式:
    • 匿名内部类实现:
    • 新建一个类然后实现Comparator接口
  • Map的API
    • map的遍历：
      • 在 for 循环中使用 entries 实现 Map 的遍历（最常见和最常用的）。
      • 使用 for-each 循环遍历 key 或者 values，一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好。
      • 使用迭代器（Iterator）遍历
      • 通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作。
  • String以及StringBuilder的常用API
    • replace方法
  • java一些数学用到的常量定义
    • 随机函数
  • 数据类型转换
    • String转换为char
    • char转换为String
    • Java List、int数组、Integer数组之间的转换
• 常见的好用的数据结构
  • LinkedHashMap
  • LinkedHashSet
  • PriorityQueue
    • 常用函数
  • Stack
  • Queue
  • Deque
  • LinkedList
    • LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：
    • LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：
• 常见数据类型的一些问题总结
  • 获取用键盘输入常用的两种方法

java常见API

更详细的可以参考文章蓝桥杯知识点汇总：基础知识和常用算法

拷贝数组

Arrays.copyOf()

int[] numsCopy = (int[]) Arrays.copyOf(nums,nums.length);

list初始化一些数据

Arrays.asList()

数组批量赋值初始化：

Arrays.fill（ a1, value ）;

a1是一个数组变量，value是一个a1中元素数据类型的值，作用：填充a1数组中的每个元素都是value

List ArraysasList = Arrays.asList("a","b","c");

List 的API

ArrayList

添加方法是：.add(e)；依次有序往后添加，获取方法是：.get(index)；　　
删除方法 是：.remove(index)； 按照索引删除；　　.remove(Object
o)； 按照元素内容删除；
根据索引将元素数值改变(替换)；注意 .set(index, element); 和
.add(index, element); 的不同；
set是替换，add是将index的元素及其以后的都后移一位，在index上添加
元素
利用list中索引位置重新生成一个新的list（截取集合；
.subList(fromIndex, toIndex)；　

数组的Arrays.sort()自定义排序的实现

当sort()传入参数只是一个数组时，默认将数组按升序排列。
数组的部分排序：public static void sort(T[] a, int fromIndex, int toIndex)

实现Comparator接口有两种方式:

匿名内部类实现:

Arrays.sort(arr, new Comparator<Integer>()
        {
@Override
public int compare(Integer o1, Integer o2) {
        return o2-o1;
        }
        });

二维数组的自定义排序（匿名内部类实现）：

// 按起点升序排列，起点相同的降序排列
Arrays.sort(clips,new Comparator<int[]>() {
    public int compare(int[] a,int[] b) {
        if (a[0] == b[0]) {
            return b[1] - a[1];
        } else {
            return a[0] - b[0];
        }
    }
});

新建一个类然后实现Comparator接口

第二种是新建一个类然后实现Comparator接口，再new一个类传入sort函数中

public class Main{
    public static void main(String[] args){
        Integer[] arr = {1,5,8,4,2,6,4};
        System.out.println("排序前："+Arrays.toString(arr));
        Comparator myComparator = new MyComparator();
        Arrays.sort(arr, myComparator );
        System.out.println("排序后："+Arrays.toString(arr));
    }
}
class MyComparator implements Comparator<Integer>{

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }

}

Map的API

Map.getOrDefault()
Map.remove(key)

map的遍历：

在 for 循环中使用 entries 实现 Map 的遍历（最常见和最常用的）。

for (Map.Entry<String, String> entry : map.entrySet()) {
    String mapKey = entry.getKey();
    String mapValue = entry.getValue();
    System.out.println(mapKey + "：" + mapValue);
}

使用 for-each 循环遍历 key 或者 values，一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好。

// 打印键集合
for (String key : map.keySet()) {
	System.out.println(key);
}
// 打印值集合
for (String value : map.values()) {
	System.out.println(value);
}

使用迭代器（Iterator）遍历

Iterator<Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Entry<String, String> entry = entries.next();
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + ":" + value);
}

通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作。

for(String key : map.keySet()){
String value = map.get(key);
System.out.println(key+":"+value);
}

String以及StringBuilder的常用API

replace方法

String类
主要有三种：
(1) replace(char oldChar, char newChar)：将所有与oldChar相同的字符替换为newChar，返回新的字符串，原字符串不改变。
(2) replaceAll(String regex, String replacement) ：将所有与regex相同的字符串替换为replacement，返回新的字符串，原字符串不改变。
(3) replaceFirst(String regex, String replacement)：将第一个与regex相同的字符串替换为replacement，返回新的字符串，原字符串不改变。

StringBuilder
一种：
replace(int start, int end, String str)：将起始位置为start，结束位置为end-1的子串替换为str。不生成新的StringBuilder对象，在原来的StringBuilder对象上修改。

• String.repeat(N)（java11之后才有的）

  此方法返回一个字符串，该字符串的值是给定字符串的重复count次的串联。如果字符串为空或count为零，则返回空字符串。

java一些数学用到的常量定义

Math.max()
Math.min()
Integer.MAX_VALUE
Integer.MIN_VALUE

随机函数

Random rdm = new Random(100);
rdm.nextInt() //返回int取值范围内的伪随机数，[2147483648 ,
2147483647]
rdm.nextInt(n) //返回0~n的伪随机数，[0 , n)
Math.random()*(n-m)+m，生成大于等于m小于n的随机数(伪随机 double 值)；

数据类型转换

String转换为char

1. 使用String.charAt(index)（返回值为char）可以得到String中某一指定位置的char。
2. 使用String.toCharArray()（返回值为char[]）可以得到将包含整个String的char数组

char转换为String

1. String s = String.valueOf('c'); //效率最高的方法
2. String s = String.valueOf(new char[]{'c'}); //将一个char数组转换成String
3. String s = Character.toString('c');
   // Character.toString(char)方法实际上直接返回String.valueOf(char)
4. String s = new Character('c').toString();
5. String s = "" + 'c';

Java List、int数组、Integer数组之间的转换

int[] data = {1,2,3};

// int[]转List<Integer>
// Arrays.stream(data): int[] -> IntStream
// IntStream.boxed(): IntStream -> Stream<Integer>
// Stream<Integer>.collect(Collectors.toList()): Stream<Integer> -> List<Integer>
List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());

// int[]转Integer[]
Integer[] arr1 = Arrays.stream(data).boxed().toArray(Integer[]::new);

// List<Integer>转int[]
// Collection<Integer>.stream(): Collection<Integer> -> Stream<Integer>
// Stream<Integer>.mapToInt(Integer::intValue): Stream<Integer> -> IntStream
// IntStream.toArray(): IntStream -> int[]
int[] arr2 = list1.stream().mapToInt(Integer::intValue).toArray();

// List<Integer>转Integer[]
Integer[] arr3 = list1.toArray(new Integer[0]);

// Integer[]转List<Integer>
List<Integer> list2 = Arrays.asList(arr3);

// Integer[]转int[]
int[] arr4 = Arrays.stream(arr1).mapToInt(Integer::valueOf).toArray();

常见的好用的数据结构

LinkedHashMap

既满足O(1) 时间内快速访问，也满足O(1) 时间内快速删除添加数据，同时能保证数据时序，利用map和双向链表一起实现

LinkedHashSet

LinkedHashSet顾名思义，是链表和哈希集合的结合体。链表不能快速访问链表节点，但是插入元素具有时序；哈希集合中的元素无序，但是可以对元素进行快速的访问和删除。

它俩结合起来就兼具了哈希集合和链表的特性，既可以在 O(1) 时间内访问或删除其中的元素，又可以保持插入的时序，其内部是通过 LinkedHashMap 来实现的

PriorityQueue

优先级队列，默认初始化是小顶堆，可以利用一个大顶堆和一个小顶堆来高效查询数据流的中位数

利用以下姿势初始化为大顶堆：

PriorityQueue<Integer> small = new PriorityQueue<Integer>((a,b)->{
       return b-a;
   });

常用函数

add(E e)//将指定的元素插入此优先级队列。
clear()//清空
contains(Object o) // 如果包含指定元素返回true
iterator()//返回在此队列中的元素上进行迭代的迭代器。
offer(E e) // 将指定元素插入此优先队列
peek() // 获取第一个元素，及最小或最大元素
poll() // 获取并移除第一个
remove(Object o) // 移除指定元素
size() // 返回元素个数

Stack

Stack<Integer> s = new Stack<Integer>();
// 顶点
s.peek()
s.push()
s.pop()

Queue

Queue 是单端队列

Queue 接口	抛出异常	返回特殊值
插入队尾	add(E e)	offer(E e)
删除队首	remove()	poll()
查询队首元素	element()	peek()

Deque

Deque 是双端队列;Deque 扩展了 Queue 的接口, 增加了在队首和队尾进行插入和删除的方法，同样根据失败后处理方式的不同分为两类：

Deque 接口	抛出异常	返回特殊值
插入队首	addFirst(E e)	offerFirst(E e)
插入队尾	addLast(E e)	offerLast(E e)
删除队首	removeFirst()	pollFirst()
删除队尾	removeLast()	pollLast()
查询队首元素	getFirst()	peekFirst()
查询队尾元素	getLast()	peekLast()

LinkedList

• contains(Object object) //包含
• getFirst() // 获取LinkedList的第一个元素
• getLast() // 获取LinkedList的最后一个元素
• removeFirst() // 删除LinkedList的第一个元素
• removeLast() // 删除LinkedList的最后一个元素
• addFirst(E e) // 将元素添加到LinkedList的起始位置
• addLast(E e) // 将元素添加到LinkedList的结束位置
• contains(Object o) // 判断LinkedList是否包含元素(o)
• clear() // 清空双向链表
• peek() // 返回第一个节点
• poll() // 删除并返回第一个节点
• offer(E e) // 将e添加双向链表末尾
• offerFirst(E e) // 将e添加双向链表开头
• offerLast(E e) // 将e添加双向链表末尾
• peekFirst() // 返回第一个节点
• peekLast() // 返回最后一个节点
• pollFirst() // 删除并返回第一个节点
• pollLast() // 删除并返回最后一个节点
• push(E e) // 将e插入到双向链表开头(这里可以当做栈来使用)
• pop() // 删除并返回第一个节点(这里可以当做栈来使用)

LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()

LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

常见数据类型的一些问题总结

• 字符串的长度是s.length()(带括号)
• 字符串的子串截取函数：s.substring(start,end)
• HashMap的元素都必须为包装类型

获取用键盘输入常用的两种方法

方法 1：通过 Scanner

Scanner input = new Scanner(System.in);
String s  = input.nextLine();
input.close();

方法 2：通过 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();