Java语言常用基础代码总结

编程语言 2025-04-08 09:01
0 阅读

目录

一、数字

1. 设置最值

int 类型：

 max_num = Integer.MAX_VALUE;
 min_num = Integer.MIN_VALUE;

无穷：

 正无穷：Double.POSITIVE_INFINITY
 负无穷：Double.NEGATIVE_INFINITY

2. 选择最值

 最大值：Math.max(a, b);
 最小值：Math.min(a, b);

3. 计算次方

 Math.pow(2, 3); // 2的三次方，结果为8

4. Random随机数

构造：Random random = new Random();
返回一个随机的整数，范围是所有可能的int值：int randomValue = random.nextInt();
返回一个0（包括）到15（不包括）之间的随机整数：int randomValue = random.nextInt(15);

二、数组

1. 数组排序

 Arrays.sort(nums);

2. 数组复制

int[] res = new int[]{1, 2, 3, 4};
int[] new_res = Arrays.copyOf(res, 3); // 只复制了前3个：new_res = [1, 2, 3]

3. 数组 与 List 相互转化

 Integer[] arr = {1, 2, 3, 4, 5};
 List<Integer> list = Arrays.asList(arr); // 数组转List
 Integer[] arr = list.toArray(new Integer[0]); // List转数组

4. 数组转字符串

 int[] intArray = { 1, 4, 6, 7, 8, 9, 10 };
 String res = Arrays.toString(intArray);

5. 两个数组比较是否相等

 Arrays.equals(arr1, arr2);

6. 二维数组根据第一个元素排序

有一个二维数组，根据第一个元素对其进行排序（也就是第一个元素换位置时，第二个元素也跟着一起换位置）：

int[][] intervals = new int[][]{
    
    {
    
    1,3},{
    
    2,6},{
    
    8,10},{
    
    15,18}}; // intervals = [[1,3],[2,6],[8,10],[15,18]]

// 法一：Java8新特性Lambda 表达式，性能高
Arrays.sort(intervals, Comparator.comparingInt(interval -> interval[0]));
/* 解释：
Comparator.comparingInt 是一个静态方法，它接受一个 ToIntFunction 函数作为参数，用于从每个元素中提取一个整数值进行比较。
interval -> interval[0] 是一个 Lambda 表达式，表示从每个 interval（即 intervals 数组中的一个元素，它本身是一个一维数组）中提取第一个元素 interval[0]（即这个区间的起始值）作为排序依据。
*/

// 法二：匿名 Comparator 类
Arrays.sort(intervals, new Comparator<int[]>() {
    
    
    public int compare(int[] interval1, int[] interval2) {
    
    
        return interval1[0] - interval2[0];
    }
});
/* 解释：
Comparator<int[]> 是一个泛型接口，int[] 表示这个比较器用于比较 int 类型数组的元素
compare() 方法是 Comparator 接口中的抽象方法，负责定义排序规则。
interval1[0] - interval2[0] 是一种整数差值的计算方式，结果有以下含义：
如果 interval1[0] - interval2[0] > 0，则返回正值，表示 interval1 排在 interval2 后面（即 interval1 的起始值大于 interval2 的起始值）。
如果 interval1[0] - interval2[0] < 0，则返回负值，表示 interval1 排在 interval2 前面（即 interval1 的起始值小于 interval2 的起始值）。
如果 interval1[0] - interval2[0] == 0，则返回 0，表示这两个区间在排序中是等价的（即它们的起始值相同）。
*/

7. char数组判空

 创建：char[] temp = new char[10];
 判空：if (temp[i] != '\u0000')，也就是没给char数组赋值时，默认为'\u0000'，而不是''

8. 字符串与char数组相互转化

 字符串转char数组：char[] str_array = s.toCharArray();
 char数组转字符串：String st=String.valueOf(char_s);

应用：对字符串的每个字符进行排序

char[] str_array = s.toCharArray(); // 字符串转char数组
Arrays.sort(str_array); // 数组排序
String str_sort = new String(str_array); //再还原成字符串

三、字符串

1. 通过index访问某个字符: s.charAt(index) == ‘a’

2. 删除字符串的头尾空白符： s.trim()

3. 截取子字符串，根据索引：s.substring(i,j)

4. 字符串分割：s.split

 String[] arr1 = str.split(" "); //仅分割一个空格
 // 正则表达式\s表示匹配任何空白字符，+表示匹配一次或多次
 String[] arr4 = str.split("\\s+"); //分割一个或者多个空格

5. indexOf() 使用方法

 int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
 int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

6. 数字与字符串相互转化

 字符串转数字：int i = Integer.parseInt(s);
 数字转字符串：String s = Integer.toString(i);
 数字转字符串：String res = String.valueOf(max_num);

7. 字符串全部转大小写

 字符串全部转小写：str.toLowerCase();
 字符串全部转大写：str.toUpperCase();

四、Set

 创建： Set<String> set = new HashSet<>();
 增加： set.add("xyz");
 删除： set.remove("xyz");
 查询： set.contains("xyz");
 数量： set.size();
 遍历：   
 for (String s : set) {
     System.out.println(s);
 }

有 key-value 用 Map , 只有 key 用 Set ，均是存储不重复的元素集合

五、Map

 创建： Map<Integer, Integer> mapNums = new HashMap<>();

 增加： mapNums.put(2, 5);

 删除： mapNums.remove(2);

注意：put()方法的签名是V put(K key, V value)，如果放入的key已经存在，put()方法会返回被删除的旧的value，否则，返回null。通俗理解：调用put方法时，如果已经存在一个相同的key， 则返回的是前一个key对应的value，同时该key的新value覆盖旧value，如果是新的一个key，则返回的是null。

 查询： mapNums.containsKey(num)

遍历：
根据key遍历：for (int key: mapNums.keySet()) {}
根据value遍历：for (Integer value : map.values()) {}
根据index下标遍历Map：

        Map<String, String> map = new HashMap<>();
        map.put("A", "Apple");
        map.put("B", "Banana");

        // 获取所有的键并转化为List
        List<String> keyList = new ArrayList<>(map.keySet());

        // 使用索引遍历
        for (int i = 0; i < keyList.size(); i++) {
    
    
            String key = keyList.get(i);
            String value = map.get(key);
            System.out.println("Index: " + i + ", Key: " + key + ", Value: " + value);
        }

map判断赋值的简洁写法：

// 原代码：
 int num = 1;
 char c = s.charAt(i);
 if (map_s.containsKey(c)) {
    
    
     num = map_s.get(c);
     num++;
 }
 map_s.put(c, num);
 
// 简洁写法：
char ch = s.charAt(i);
map_s.put(ch, map_s.getOrDefault(ch, 0) + 1);

在这里插入图片描述
根据Map的Value值进行排序：

扫描二维码关注公众号，回复： 17553926 查看本文章 
        Map<Integer, Integer> map = new HashMap<>();
        for(int num: nums) {
    
    
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet()); // 注意此处的写法，因为list有sort函数
        Collections.sort(list, (a, b) -> {
    
    	// 重写sort函数
            return b.getValue() - a.getValue();	// value越大，越靠前
        });

        int[] res = new int[k];
        for(int i=0; i < k; i++) {
    
    
            res[i] = list.get(i).getKey();	// 获取前 K 个高频元素
        }

六、List

 创建：List<List<Integer>> list = new ArrayList<>();
 增加：list.add(Arrays.asList(nums[i], nums[l], nums[r]));
 获取：list.get(index);
 修改：list.set(index, "新值");
 删除1：list.remove(index); // 移除下标为index的元素
 删除2：list.remove("值"); // 移除第一次出现的指定元素
 数量：list.size();
 判空：list.isEmpty();
 包含：list.contains("值");
 清空：list.clear();

注意 删除1 和 删除2 ， 如果 list 中存储的是数字，那么传入一个数字，删除的是index还是值呢？

// 结果展示如下
List<Integer> list = new ArrayList<>(); // 注意List里放的是Integer类型
list.remove(1); 　　// 删除索引为1的元素
list.remove(new Integer(1));　　// 删除元素1

因为泛型类的类型必须为引用类型，而不能为基础类型。所以传int的时候，会被当做下标值，传Integer的时候，会被视为泛型类。

七、队列 / 栈

1. 队列 Queue

 创建：Queue<String> queue = new LinkedList<>();
 求长度：queue.size();

在这里插入图片描述

2. 双端队列 Deque

 创建：Deque<String> deque = new LinkedList<>();
 求长度：deque.size();

在这里插入图片描述

3. 栈 Stack

JDK官方已建议优先使用Deque的实现类来代替Stack（具体原因可查看此篇文章：Java中的栈Stack、Deque、ArrayDeque、LinkedList），使用的双端队列Deque，只在一端操作。（ArrayDeque和LinkedList这两者底层，一个采用数组存储，一个采用链表存储；ArrayDeque用作栈时比Stack快没有疑问，用作队列的时候似乎也会比LinkedList快！）

创建

 ArrayDeque创建：Deque<Integer> stack = new ArrayDeque<>();
 LinkedList创建：Deque<String> deque = new LinkedList<>();

使用
当我们把 Deque 作为 Stack 使用时，注意只调用push() / pop() / peek()方法，不要调用 addFirst() / removeFirst() / peekFirst() 方法，这样代码更加清晰。

 判空：stack.isEmpty();
 求长度：stack.size();

4. 优先队列 PriorityQueue

PriorityQueue 和 Queue 的区别在于：它的出队顺序与元素的优先级有关，对PriorityQueue调用remove()或poll()方法，返回的总是优先级最高的元素。由于 PriorityQueue 继承自 Queue ，所以对元素的基本操作函数都一样，就是返回的内容是有序的。
在这里插入图片描述

PriorityQueue 按元素比较的顺序排序，默认是最小堆。
示例1：定义的是 PriorityQueue<Integer>，那么里边的元素是按照从小到大排序，如果让弹出，最先得到的是最小的数字，然后得到的是第二小的数字。

    PriorityQueue<Integer> queue = new PriorityQueue<>();
    queue.offer(8);
    queue.offer(5);
    queue.offer(10);
    queue.offer(2);
    while (!queue.isEmpty()){
    
    
        System.out.println(queue.poll());  //输出2, 5, 8, 10
    }

示例2：定义的是PriorityQueue<String>

        PriorityQueue<String> q = new PriorityQueue<>();
        // 添加3个元素到队列:
        q.offer("apple");
        q.offer("pear");
        q.offer("banana");
        System.out.println(q.poll()); // apple
        System.out.println(q.poll()); // banana
        System.out.println(q.poll()); // pear
        System.out.println(q.poll()); // null,因为队列为空

PriorityQueue也提供了自定义比较规则：
示例3：将最小堆改为最大堆

// 写法一
PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
    
    
    	  
	    public int compare(Integer o1, Integer o2) {
    
    
	        return o2-o1;
	    }
	});
// 写法二
PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> (o2 - o1));

* 常见数据结构

// 链表
public class ListNode {
    
    
    int val;
    ListNode next;
    ListNode(int x) {
    
    
         val = x;
         next = null;
    }
}

// 树
public class TreeNode {
    
    
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {
    
    }
    TreeNode(int val) {
    
     this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
    
    
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

猜你喜欢

目录

热门文章