java常见API和集合

java常见API
- map的遍历：
- 数据类型转换
常见的好用的数据结构
常见数据类型的一些问题总结

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接口，再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对象上修改。
- Sting.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\';

常见的好用的数据结构

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()

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

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