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的元素都必须为包装类型