java常见API和集合

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();
posted @ 2021-07-02 15:41  RealGang  阅读(202)  评论(0编辑  收藏  举报