Java编程刷题常用

Posted 2023-02-28 萌萌滴太阳

文章目录

• String
• • String与基本数据类型转换
  • String与字符数组转换
  • compareTo字符串比较大小
  • StringBuilder/StringBuffer删除指定位置的字符
  • String.join()
  • s.contains()
  • 位图
  • split
• 堆
• 栈、队列、双端队列
• • 队列
  • 双端队列
  • 栈
• 集合
• • LinkedList

String

String与基本数据类型转换

• 字符串转换成基本类型：
  parseXxx(String s)：将字符串s解析成Xxx

String s1 = "123";
int num = Integer.parseInt(s1);
double num1 = Double.parseDouble(s1);

• 基本类型转换成字符串：
  1、String.valueOf(num)：将num转换成字符串
  2、使用 + ，和“” 拼接

String s1 = "123";
int num = 123;
String s2 = String.valueOf(num);
String s3 = num + "";

String与字符数组转换

• String-----> 字符数组，toCharArray()

String s1 = "123";
char[] charArray = s1.toCharArray();

• 字符数组-----> String，String str = new String(char[])

char[] arr = '1', '2', '3';
String s2 = new String(arr);

compareTo字符串比较大小

compareTo比较数据的大小

int compareTo(String str)
//忽略大小写【不忽略时，小写大于大写】
int compareToIgnoreCase(String str)
int compareTo(object str)

通过使用上面的函数比较两个字符串，并返回一个int类型。

• 若字符串等于参数字符串、则返回0，
• 字符串小于参数字符串、则返回值小于0，
• 字符串大于参数字符串、返回值大于0。（ASCII码）

String a = "a";
String b = "b";
int res = a.compareTo(b)//res = 1 ,大于0

判断字符串大小的依据是根据他们在字典中的顺序决定的。

使用equals()

equals比较的是内容是否相等，但它只能判断相不相等，无法知道哪个大。
相等返回true或false

使用操作符==

比较的是引用的变量地址是否相等。
例如：
System.out.println(s1 == s2);
System.out.println(s2 == s3);
System.out.println(s3 == s4);

返回true 或false

StringBuilder/StringBuffer删除指定位置的字符

StringBuffer path = new StringBuffer();
path.deleteCharAt(path.length() - 1);

String.join()

• 字符串类型的集合或数组，使用String.join() 以某拼接符拼接到一起形成新的字符串。

List<String> list = new ArrayList<>();
list.add("Mxy");
list.add("String");
list.add("join");
String join = String.join("-",list);//传入String类型的List集合，使用"-"号拼接
System.out.println(join);

String[] s = new String[]"Yuan","Mxy";//传入String类型的数组，使用"-"号拼接
String join2 = String.join("-",s);
System.out.println(join2);

Mxy-StringUtils-join
Yuan-Mxy

s.contains()

s[r , s.length - 1]中是否包含子串s[l , r - 1]
str.substring(r).contains(str.substring(l, r))

位图

对于字符串的题目，常常用数组的下标表示字符a~z，eg：0–a , 1–b…

下标0--a , 1--b.....，num[i]一般是对应字符出现的次数等；
int[] num = new int[26];

split

对于'.'、'|'隔开的字符串，进行分割，需使用转义字符即：

a.split("\\\\.")
a.split("\\\\|")

其它，直接分割即可：(eg：，隔开)

a.split(",")

堆

Java 中提供了现成的类 PriorityQueue，默认是小根堆，实现大根堆需要重写一下比较器。PriorityQueue<Integer> pq = new PriorityQueue<>((v1 , v2) -> v2 - v1);

栈、队列、双端队列

参考

栈、队列、双端队列的具体方法

• LinkedList实现了Deque和Queue接口，可以按照队列、栈和双端队列的方式进行操作，所以栈、队列、双端队列都用new LinkedList<>();创建

Queue<> q = new LinkedList<>();
Deque<> dq = new LinkedList<>();//双端队列和栈

• 之所以双端队列和栈都用Deque<> dq = new LinkedList<>();表示；
  Java中有一个类Stack，用于表示栈，但这个类已经过时了。Java中没有单独的栈接口，栈相关方法包括在了表示双端队列的接口Deque中

队列

Queue<> q = new LinkedList<>();
q.add(i);
q.remove();
q.isEmpty();
q.peek();//返回队头元素
q.poll();//弹出队头，并返回队头元素；

双端队列

Deque<> q = new LinkedList<>();

q.addLast(i);
q.addFirst(i);
q.removeFirst();
q.removeLast();
q.isEmpty();
q.peekFirst();
q.peekLast();

栈

Deque<> stack = new LinkedList<>();
stack.peek();获取队头元素，如果队列为null将返回null。
stack.push(i);栈顶添加一个元素。
stack.pop(); 移除栈顶元素，返回移除的元素，如果栈没有元素抛出异常。

集合

LinkedList<int[]> 转换成int[][]

LinkedList<int[]> 转换成int[][]
面试题57 - II. 和为s的连续正数序列

class Solution 
    public int[][] findContinuousSequence(int target) 
        if(target < 3) return new int[0][0];
        LinkedList<int[]> res = new LinkedList<>();
        int i = 1 , j =2 , sum = 3;
        while(i < j)
            if(sum == target)
                int[] temp = new int[j - i + 1];
                for(int k = i ; k <= j ; k++)
                    temp[k - i] = k;
                
                res.add(temp);
            
            if(sum >= target)
                sum -= i;
                i++;
            else
                j++;
                sum += j;
            
        

        return res.toArray(new int[res.size()][]);

    

集合初始化时添加元素

ArrayList的构造函数，即，可以添加Collection的实现类进行初始化
public ArrayList(Collection<? extends E> c)

eg:
List<Integer> path = new ArrayList<>();
List<Integer> newPath = new ArrayList<>(path);

ArrayList<Integer> res = new ArrayList<Integer>(Arrays.asList(1, 2, 3);
eg：
要求返回List<List<Integer>>：
 List<List<Integer>> res = new ArrayList<>();
 res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[i], nums[j])));

HashMap中Entry的使用

347. 前 K 个高频元素
类似于上道题215，上题是求 “数组中的第K个最大元素”，进而也可以求出前k大元素，这里求“出现频率前 k 高的元素” 若将各数字出现的频率形成数组，则和上题一样

参考

class Solution 
    public int[] topKFrequent(int[] nums, int k) 
        HashMap<Integer , Integer> map = new HashMap<>();
        for (int num : nums) 
            map.put(num, map.getOrDefault(num, 0) + 1);
        

        PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() 
            public int compare(int[] a , int[] b)
                return a[1] -  b[1];
            
        );

        for(Map.Entry<Integer , Integer> entry : map.entrySet())
            int num = entry.getKey();
            int count = entry.getValue();
            if(pq.size() == k)
                if(count > pq.peek()[1])
                    pq.poll();
                    pq.add(new int[]num , count);
                else continue;
            else
                pq.add(new int[]num , count);
            
        
        int[] res = new int[k];
        int i = 0;
        for(int[] arry : pq)
            res[i++] = arry[0];
        

        return res;
    

List集合转数组

一、集合转数组的时候，集合提供了两种方法

1，toArray的不带参方法但是其返回值类型为Object

2，toArray的带参方法，在创建数组的时候指定数组的长度，最好与集合size保持一致，否则集合长度大于数组长度，原数组江北重置为null

Collections工具类

Collections和Array一样也有sort排序方法

Collections.sort(arr , (a , b) -> a[0]- b[0]);

多重数组集合创建

//外面一层是数组，用new创建了，里面是ArrayList<Integer>，声明了它，但还没创建，所以下面要创建；
ArrayList<Integer>[] adjacency = new ArrayList[n];

字符

字符转数字

• 两个字符相减，实际是两个字符的ASCII相减；

c的范围是：[0 , 9]:【'0'--0 , '1'--1...】
int x = c - '0';

c的范围是：[a , z]:【a--0 , b--1...】
int x = c - 'a';

c的范围是：[A , Z]:【A--0 , B--1...】
int x = c - 'A';

字符大小写转换

• 用包装类Character

Character.isLetter(c)//c是否是字母a~z||A~Z
Character.isDigit(c))//c是否是数字
Character.toUpperCase(c)
Character.toLowerCase(c)

• 用数字

(char)('a' - 32)--------A
(char)('A' + 32)--------a

(char)('a' ^ 32)--------A
(char)('A' ^ 32)--------a

Java中int ，long的最大值表示

Integer.MAX_VALUE
Integer.MIN_VALUE

Long.MAX_VALUE
Long.MIN_VALUE

PriorityQueue & Arrays.sort中比较器的重写

• 两个一样

//按数组0号下标元素，升序排序
Arrays.sort(num, new Comparator<int[]>() 
            public int compare(int[] person1, int[] person2) 
            return person1[0] - person2[0];
            
        );
new PriorityQueue<>(new Comparator<int[]>() 
            public int compare(int[] person1, int[] person2) 
                return person1[0] - person2[0];
            
        );
        
//lambda表达式
Arrays.sort(num, (v1 , v2) -> v1[0] - v2[0]);
new PriorityQueue<>((v1 , v2) -> v1[0] - v2[0]);

比较器重写（在一个字段排序的基础上再排序）

例题：【NC97 字符串出现次数的TopK问题】https://blog.nowcoder.net/n/4a41d180b3774cedbddd33d49b3bd756?f=comment

class MyCompare implements Comparator<Map.Entry<String  , Integer>>
    public int compare(Map.Entry<String  , Integer> a , Map.Entry<String  , Integer> b)
        if(a.getValue().equals(b.getValue())) return b.getKey().compareTo(a.getKey());
        else return a.getValue() - b.getValue();
    

写好的比较器可以直接放在优先队列里PriorityQueue<Map.Entry<String , Integer>> pq = new PriorityQueue<>(myCompare);

数组

数组的初始化

int[] num = new int[]1,2,3;
or
int[] dp = new int[n];
//所有值初始化为-1
Arrays.fill(dp以上是关于Java编程刷题常用的主要内容，如果未能解决你的问题，请参考以下文章
 
 Java编程刷题常用
 Java 线程在循环中执行余数运算会阻塞所有其他线程
 python 整型字符串常用方法for循环
 程序员常用刷题网站分享
 程序员常用刷题网站分享
 #yyds干货盘点# 前端歌谣的刷题之路-第二十九题-余数