leetcode常用java集合和容器

一，字符串String

返回类型及内容	方法描述
char：返回String中指定索引处的字符	charAt(int index)
int：按字典顺序比较两个字符串。	compareTo(String anotherString)
int：返回此字符串的长度。	length()
String[]：将此字符串分割为给定的 regular expression的匹配。	split(String regex)
char[]：将此字符串转换为新的字符数组。	toCharArray()
int：返回指定字符第一次出现的字符串内的索引。	indexOf(int ch)
int：返回指定子字符串第一次出现的字符串内的索引。	indexOf(String str)

 二，动态数组ArrayList<E>

 

 (105条消息) LeetCode刷题心得之Java常用容器及方法_陈阿土i的博客-CSDN博客

 

 

 

数组操作

初始化数组

int[]prices=new int[]{550,300,480,230};  //指定初始值

int[]sum=new int[length];  //指定长度

二维数组

int[][] a = {{1,2,3},{4,5,6},{7,8,9,10}};  //指定初始值 每一组大括号就是一个一维数组。有几对大括号那么k数组就有几个一维数组

int[][] k = new int[i][j]; //指定长度  i这个位置必须赋值，而j 这个位置 可以赋值 也可以空着不赋值。

数组长度

arr.length // 长度

截取数组

Arrays.copyOfRange(arr,j,i)// 返回一个数组等于array[j] ~ array[i - 1]

数组复制

System.arraycopy(srcArr,srcPos, desArr, desPos, length);

数组转字符串

Arrays.toString(arr)

数组转List

List<Character> vowList= Arrays.asList('a', 'e', 'i', 'o', 'u'); // 数组转化为List

需要注意的是， Arrays.asList() 返回一个受指定数组决定的固定大小的列表。所以不能做 add 、 remove 等操作，否则会报错。

字符串数组转整数数组

int[] values = Arrays.stream(params).mapToInt(Integer::parseInt).toArray();

数组排序

采用Arrays工具类的流计算
int[] sortPrices=Arrays.stream(prices).sorted().toArray();

重写排序方法
Arrays.sort(items, (o1, o2)->o1[0]==o2[0]?o2[1]-o1[1]:o1[0]-o2[0]); // 二维数组排序

数组遍历（不需要下标 foreach）

for(int sortPrice:sortPrices){

……

}

数组二分查找（数组必须经过排序才可以使用此方法，否则返回下标显示不准）

[1] 搜索值不是数组元素，且在数组范围内，从1开始计数，得“ - 插入点索引值”；

[2] 搜索值是数组元素，从0开始计数，得搜索值的索引值；

[3] 搜索值不是数组元素，且小于数组内元素，索引值为 – 1；

[4] 搜索值不是数组元素，且大于数组内元素，索引值为 – (length + 1);

Index = Arrays.binarySearch(arr, target); //如果存在肯定大于等于0.不存在小于0

数组去重（转set）

String[] array = {"a","b","c","c","d","e","e","e","a"};
Set<String> set = new HashSet<>();
for(int i=0;i<array.length;i++){
  set.add(array[i]);
}
String[] arrayResult = (String[]) set.toArray(new String[set.size()]);
System.out.println(Arrays.toString(arrayResult));

字符串操作

StringBuilder对字符串的每个字符进行操作

StringBuilder sb=new StringBuilder(inputStr);
Char cur=sb.charAt(i);  //取出
sb.deleteCharAt(i);  //删除
sb.toString(); //还原为字符串

字符串截取子串

String sub = string.subString(i,j);  // i到j  左闭右开

字符串拼接（推荐String.join）

String string = String.join(" ", str);// 快很多
string = " " + str;
string = "" + 5; // int转string

字符串分割为数组

String[]  splits=str.split("/"); // 字符串分割为数组

判断是否含字符

str.contains("/") //判断是否含字符

字符替换

str=str.replaceFirst("/|*/",""); //替换首个

result = result.replaceAll("u","U"); //替换所有

去除前后空格

str.trim()  

SimpleDateFormat类实现日期和字符串的相互转换

SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
String strDate1 = "2019-02-18 13:58";
Date date1 = simpleDateFormat1.parse(strDate1);
System.out.println(date1);


SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
Date currentTime = new Date();
System.out.println(currentTime);    // Mon Feb 18 13:53:50 CST 2019
System.out.println(simpleDateFormat2.format(currentTime));  // 输出2019-02-18 13:53:50.629

字符串转整数

int lines=Integer.parseInt(intStr);// 字符串转整数

数字转字符串

String day = String.valueOf(31); // "31"

字符串与char数组互转

char[] charArray = str.toCharArray(); // 字符串转char数组
String string = String.valueOf(charArray); //char数组转字符串

字符串相等比较

if ("success".equals(result) && "/login.do".equals(url)) // 常量放前面

字符串大小写转换

str.toLowerCase()

str.toUpperCase()

字母大小写转换 （采用character工具类）

Character.toLowerCase(char)

Character.toUpperCase(char)

字母大小写相差32

'A' - 'a'=32

正则表达式

典型的调用顺序是

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

String regex = "1[3578]\\d{9}";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher("我的电话号码18729256882；备用号码15970965918；还有不知道谁的17743685479");
while(m.find()) {
    System.out.println(m.group());
}

Arrays工具类

Collectors工具类

Math工具类

求绝对值

Math.abs(num) //求绝对值

乘方

Math.pow(10.0,n) // 乘方  10的n次方

开根号

Math.sqrt(a)

最大值和最小值

Math.max(a,b)
Math.min(a,b)

四舍五入

Math.roud(a)
Math.ceil(a)
Math.floor(a)

Map操作

map的查询效率较高，建议优先使用

map初始化

Map<Integer,Integer>record=new HashMap<>();  //初始化

添加元素

record.put(0,1); //添加单个元素

获取指定key的value

record.get(i); //获取指定key的value

Int same=record.getOrDefault(mod,0); //指定key获取元素value，默认0

获取value值的list

List<Integer> len = new ArrayList<Integer>(record.values());

获取key的set

Set<String> set = record.keySet();

遍历map

for (Integer i : record.keySet()) {
    Integer alarm = record.get(i);  //获取指定key的value
}


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

List操作

初始化

List<Integer> cabinTickets=new ArrayList<>(); 

List<String> subList=new LinkedList<>(); //有序list，按添加顺序

ArrayList<Integer> arr = (ArrayList<Integer>) Arrays.stream(office).boxed().collect(Collectors.toList());//数组转换arraylist

元素操作

cabinTickets.add(value);  //添加单个元素  

cabinTickets.set(j, value);  //修改单个元素

cabinTickets.remove(j);  //删除单个元素  此处是index，不是值

cabinTickets.addAll(j);  //添加多个元素

cabinTickets.removeAll(j);  //删除多个元素

cabinTickets.get(j) //  获取指定下标元素

cabinTickets.indexOf(value) // 获取指定元素的下标，没有则返回-1

if (!dayLogInfoes.contains(dayLogInfo)) { dayLogInfoes.add(dayLogInfo); } //判断是否包含元素

大小

cabinTickets.size()  // 大小

判空

cabinTickets.isEmpty()  // 判空

list排序可以先转换为array,用函数处理

Object[] arr = list.toArray();
Arrays.sort(arr);

cabinTickets.sort(Integer::compareTo); // 排序

覆写比较器进行排序

Collections.sort(scoreList, Comparator.comparingInt(o -> -o));

Collections.sort(voList, new Comparator<Vo>() {
    @Override
    public int compare(Vo o1, Vo o2) {
        if(o1.gold>o2.gold){
            return -1 ;
        } else if(o1.gold<o2.gold){
            return 1 ;
        } else if(o1.silver>o2.silver){
            return -1 ;
        } else if(o1.silver<o2.silver){
            return 1 ;
        } else if(o1.bronze>o2.bronze){
            return -1 ;
        } else if(o1.bronze<o2.bronze){
            return 1 ;
        } else {
            //System.out.println(o1.name+"  "+o2.name); 字符串直接用compareTo比较即可
            return (o1.name.compareTo(o2.name)) ;
        }
    }
}) ;

list转set(可用于去重)

Set<String> setString=new TreeSet<>(list); // list转set  

遍历list（不需要下标foreach）

for(Vo item:voList){
  System.out.println(item.name);
}

set操作(不能有重复元素)

初始化

Set<String> set= new TreeSet<>(); //初始化，treeset自带排序

大小

int len = set.size();

判断是否包含

boolean isContain = set.contains(elem);

set转数组

String[] resultArray=set.toArray(new String[set.size()]); 

set遍历

迭代器
Set set = new HashSet();
Iterator it = set.iterator();
while (it.hasNext()) {
String str = it.next();
System.out.println(str);
}


泛型处理
Set set = new HashSet();
for循环遍历：
for (Object obj: set) {
if(obj instanceof Integer){
int aa= (Integer)obj;
}else if(obj instanceof String){
String aa = (String)obj
}
…

}

queue操作

优先队列（重写排序方法）

PriorityQueue<Site> oilSites = new PriorityQueue<Site>(Comparator.comparingInt(o -> -o.oil));// 按oil倒序排列

PriorityQueue <Integer> queue = new PriorityQueue<>(
                new Comparator<Integer>() {
                    public int compare(Integer i1, Integer i2) {
                        return i2 - i1;
                    }
                }); // 倒序数字队列

PriorityQueue<Site> oilSites = new PriorityQueue<Site>((o1, o2) -> {
    return o2.oil - o1.oil;
});// 按oil倒序排列


PriorityQueue<Site> oilSites = new PriorityQueue<Site>((o1, o2) -> o2.oil - o1.oil);// 按oil倒序排列 lambda表达式

元素操作

que.poll()  // 取出队首元素

queue.offer(ele)  // 入列

queue.isEmpty() // 判空

queue.peek()  // 查看队首元素

大小

queue.size()

Stack操作

初始化

Stack<Integer> table = new Stack<Integer>();

元素操作

table.search(temp) // 查找元素位置，找不到返回-1
table.contains(card) //判断是否含有元素
table.push(temp); // 添加
tmp.pop() //出栈

输入输出

输入元素处理

Scanner  cin=new Scanner(System.in,StandardCharsets.UTF_8.name());

cin.nextLine()

cin.hasNextInt()  //判断

int a = cin.nextInt();

cin.hasNextDouble()

double num = s.nextDouble();

byte[] by = cin.next().getBytes();

// 记得关闭资源

cin.close();

输出元素处理

System.out.printf("%.10f",convert);   // 格式化输出

System.out.println("input error!");  // 打印并换行

二进制技巧

判断是否为2的n次方

这个数用2进制表示是 1000…（连续多个0），那这个数减一就是 01111…（连续多个1）。两个“与”操作就是0

boolean flag=（n & (n-1) ) == 0 //  true代表不是2的n次方

求奇数偶数（对2求余），采用字节操作

Int mod = k & 1

等同于

Int mod = k%2

灵活使用位运算

1 << 2 // 4

4 << 2 // 16

Int div = k >> 1 等同于 k/2

大数操作

考虑整数溢出问题

int 类型的最大值是 2^{31}-1

long res = ……

Int result = (int) res == res ? (int) res : 0; // 三目运算

long c = Long.bitCount(i); // 返回long值i对应二进制数的1的个数

Integer.MAX_VALUE
Integer.MIN_VALUE

大整数（加减乘除和比较必须用函数）

BigInteger one = BigInteger.valueOf(1L); //初始化
BigInteger first = BigInteger.valueOf("14512451451245124512"); //初始化(字符串转大整数)

add、subtract、multiply、divide、mod、compareTo、equals

大小数

public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)

特殊数据结构

完全二叉树

父节点个数不超过整体数据量的一半