Java大整数乘法知识点（含面试大厂题和源码）

大整数乘法是指对超出常规整数类型（如int或long）能表示范围的整数进行乘法运算。在Java中，处理大整数乘法通常有两种方法：

使用BigInteger类：Java提供了BigInteger类来处理大整数运算，包括乘法。BigInteger类提供了一个multiply方法，可以用来进行乘法运算。
手动实现：如果没有使用BigInteger类的限制，你也可以手动实现大整数乘法，类似于我们在学校学习的手动乘法过程。

使用`BigInteger`类

下面是使用BigInteger类进行大整数乘法的一个简单示例：

import java.math.BigInteger;

public class Main {
    public static void main(String[] args) {
        // 创建两个大整数
        BigInteger bigInt1 = new BigInteger("12345678901234567890");
        BigInteger bigInt2 = new BigInteger("98765432109876543210");

        // 进行乘法运算
        BigInteger result = bigInt1.multiply(bigInt2);

        // 输出结果
        System.out.println("乘积: " + result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

手动实现大整数乘法

如果你想要手动实现大整数乘法，你需要按照以下步骤进行：

将每个大整数转换为字符串，或者使用数组来表示。
从最低位开始，逐位进行乘法运算。
将乘积按位相加，同时处理进位。

面试大厂时，编程题通常包括数据结构、算法、设计模式、并发编程等方面。以下是三道可能在面试中遇到的题目，以及它们的Java源码示例。

1. 二分查找算法

题目：给定一个升序排列的整数数组，找到其中某个特定值的位置。

源码：

public class BinarySearch {
    public static int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1; // 未找到
    }
    
    public static void main(String[] args) {
        int[] nums = {-3, 10, 20, 40, 60, 70};
        int target = 40;
        System.out.println("元素 " + target + " 的索引是: " + binarySearch(nums, target));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2. 链表中环的检测

题目：给定一个链表，判断链表中是否有环。

源码：

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
        next = null;
    }
}

public class LinkedListCycle {
    public static boolean hasCycle(ListNode head) {
        if (head == null) {
            return false;
        }
        
        ListNode slow = head;
        ListNode fast = head;
        
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            
            if (slow == fast) {
                return true; // 存在环
            }
        }
        
        return false; // 不存在环
    }
    
    public static void main(String[] args) {
        // 创建一个有环的链表作为示例
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = head.next; // 形成环
        
        System.out.println("链表中是否有环: " + hasCycle(head));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

3. 生成平衡二叉树

题目：给定一个排序好的数组，生成一个平衡二叉搜索树（AVL树）。

源码：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}

public class BalancedBST {
    public static TreeNode sortedArrayToBST(int[] nums) {
        return sortedArrayToBSTHelper(nums, 0, nums.length - 1);
    }
    
    private static TreeNode sortedArrayToBSTHelper(int[] nums, int start, int end) {
        if (start > end) {
            return null;
        }
        
        int mid = start + (end - start) / 2;
        TreeNode node = new TreeNode(nums[mid]);
        node.left = sortedArrayToBSTHelper(nums, start, mid - 1);
        node.right = sortedArrayToBSTHelper(nums, mid + 1, end);
        
        return node;
    }
    
    public static void main(String[] args) {
        int[] nums = {-10, -3, 0, 5, 9};
        TreeNode root = sortedArrayToBST(nums);
        // 此处可以添加代码来遍历树并打印节点值，以验证结果
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

这些题目覆盖了基本的算法和数据结构知识，是大厂面试中常见的题型。在准备面试时，理解这些算法的原理并能够高效地实现它们是非常重要的。