剑指offer_编程题_java实现

最新推荐文章于 2024-06-04 23:11:16 发布
最新推荐文章于 2024-06-04 23:11:16 发布
阅读量174 收藏
点赞数
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thefantast/article/details/89068097
版权

编程练习

目录

1.有序二维数组中查找

题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

方法一：暴力双层循环，代码简洁，时间复杂度为O(m*n)，内存消耗大
运行时间：185ms 184ms
占用内存：17560k 17440k

public class Solution {
    public boolean Find(int target, int [][] array) {
        boolean flag=false;
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array[i].length;j++){
                if(array[i][j]==target){
                    flag=true;
                    break;
                }
            }
            if(flag==true){
                break;
            }
        }
        return flag;
    }
}

方法二：从左下角（或右上角）比照，大则上移，小则右移，时间复杂度为O(m+n)
运行时间：145ms 148ms
占用内存：17456k 17492k

public class Solution {
    public boolean Find(int target, int [][] array) {
        //定义多维数组的行数
        int len = array.length - 1;
        //定义多维数组的列数
        int row = 0;
        while(len >= 0 && row < array[0].length){
            if(array[len][row] > target)
                len--;
            else if(array[len][row] < target)
                row++;
            else
                return true;
        }       
        return false;
    }
}

2.替换空格

运行时间：24ms
占用内存：9548k

public class Solution {
    public String replaceSpace(StringBuffer str) {
    	return str.toString().replaceAll("\\s","%20");
    }
}

3.从尾到头打印列表

运行时间：27ms
占用内存：9516k

import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list =new ArrayList<Integer>();
        while(listNode!=null){
            //在列表的指定位置插入指定元素。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。
            list.add(0,listNode.val);
            listNode=listNode.next;
        }
        return list;
    }
}

4.重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。

第一次：
测试输出不通过
用例:
[1,2,3,4,5,6,7],[3,2,4,1,6,5,7]
对应输出应该为:
{1,2,5,3,4,6,7}
你的输出为:
{1,5,#,7}

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //前序的第一个数字定为根
        TreeNode root=new TreeNode(pre[0]);
        int length=pre.length;
        if(length==1){
            root.left=null;
            root.right=null;
        }
        //找出中序中根的位置
        int rootval=root.val;
        int i;
        for(i=0;i<length;i++){
            if(in[i]==rootval){
                break;
            }
        }
        //左子树构建，只要根不在中序最左就递归
        if(i>0){
            //pre[i]中1到i的全是左子树上的结点
            //in[i]中0到i-1的全是左子树上的结点
            int[] segPre=new int[i];
            int[] segIn=new int[i];
            for(int j=0;j<i;j++){
                segPre[j]=pre[j+1];
            }
            for(int j=0;j<i;j++){
                segIn[j]=in[j];
            }
            //再去递归根节点左子树上划分出的左右子树
            root.left=reConstructBinaryTree(segPre,segIn);
        }else{
            root.left=null;
        }
        //右子树构建,长度比下标多1，只要根不在中序最右就递归
        if(length-i-1>0){
            int[] segPre=new int[length-i-1];
            int[] segIn=new int[length-i-1];
            //[i]后的全是右子树上的节点
            for(int j=i+1;j<length;j++){
                //j和作为根的i相差值代表它在新数组第几个位置，此外数组下标减1
                segPre[j-i-1]=pre[j];
                segIn[j-i-1]=in[j];
            }
            root.left=reConstructBinaryTree(segPre,segIn);
        }else{
            root.right=null;
        }
        return root;
    }
}

检查发现：
只有单节点时忘记返回根
右子树创建时 root.right 输错为 root.left
修改：
运行时间：250ms
占用内存：23660k

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //前序的第一个数字定为根
        TreeNode root=new TreeNode(pre[0]);
        int length=pre.length;
        //当只有一个结点时
        if(length==1){
            root.left=null;
            root.right=null;
            return root;
        }
        //找出中序中根的位置
        int rootval=root.val;
        int i;
        for(i=0;i<length;i++){
            if(rootval==in[i]){
                break;
            }
        }
        //左子树构建，只要根不在中序最左就递归
        if(i>0){
            //pre[i]中1到i的全是左子树上的结点
            //in[i]中0到i-1的全是左子树上的结点
            int[] segPre=new int[i];
            int[] segIn=new int[i];
            for(int j=0;j<i;j++){
                segPre[j]=pre[j+1];
            }
            for(int j=0;j<i;j++){
                segIn[j]=in[j];
            }
            //再去递归根节点左子树上划分出的左右子树
            root.left=reConstructBinaryTree(segPre,segIn);
        }else{
            root.left=null;
        }
        //右子树构建,长度比下标多1，只要根不在中序最右就递归
        if(length-i-1>0){
            int[] segPre=new int[length-i-1];
            int[] segIn=new int[length-i-1];
            //[i]后的全是右子树上的节点
            for(int j=i+1;j<length;j++){
                //j和作为根的i相差值代表它在新数组第几个位置，此外数组下标减1
                segIn[j-i-1]=in[j];
                segPre[j-i-1]=pre[j];
            }
            root.right=reConstructBinaryTree(segPre,segIn);
        }else{
            root.right=null;
        }
        return root;
    }
}

5.用两个栈实现队列

题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
运行时间：15ms
占用内存：9372k

import java.util.Stack;

public class Solution {
    Stack<Integer> input = new Stack<Integer>();
    Stack<Integer> output = new Stack<Integer>();
    /*
	1，整体思路是元素先依次进入栈1，再从栈1依次弹出到栈2，然后弹出栈2顶部的元素，
	整个过程就是一个队列的先进先出
	2，但是在交换元素的时候需要判断两个栈的元素情况：
	“进队列时”，队列中是还还有元素，若有，说明栈2中的元素不为空，
	此时就先将栈2的元素倒回到栈1中，保持在“进队列状态”。
    “出队列时”，将栈1的元素全部弹到栈2中，保持在“出队列状态”。
    */
    public void push(int node) {
        while(!output.empty()){
            input.push(output.pop());
        }
        input.push(node);
    }
    
    public int pop() {
        while(!input.empty()){
            output.push(input.pop());
        }
        return output.pop();
    }
}

6.旋转数组的最小数字

题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路：
旋转后的数组实际上可以划分为两个有序的子数组，前面的子数组中的所有数都大于后面的子数组中的数。
（1）用left，right两个指针分别指向数组的第一个元素和最后一个元素，无重复时，按旋转规则，第一个元素大于最后一个元素
（2）找到中间元素，
若中间元素大于left，则中间元素位于前面的子数组中，最小值在中间元素后面的数组中
若中间元素小于left，则中间元素位于后面的子数组中，最小值在中间元素前面的数组中
（3）这样，第一个指针left总是指向前面子数组中的元素，第二个指针right总是指向后面子数组中的元素，最终他们将指向相邻的两个元素，最小值将是right指向的元素。
但是当存在重复元素时，比如｛1，0，1，1，1｝ 和 ｛1，1， 1，0，1｝，第一种情况下，中间数字位于后面的子数组，第二种情况，中间数字位于前面的子数组。因此当两个指针指向的数字和中间数字相同的时候，我们无法确定中间数字1是属于前面的子数组还是属于后面的子数组。

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0){
            return 0;
        }
        int leftIndex=0;
        int rightIndex=array.length-1;
        int mid=0;
        while(array[leftIndex]>=array[rightIndex]){
            //如果left和right相邻，最小值就是right指向的值，取值后跳出循环
            if(rightIndex-leftIndex<=1){
                mid=rightIndex;
                break;
            }
            //取中值mid
            mid=(leftIndex+rightIndex)/2;
            //left和right指向重复的元素时，
            if(array[leftIndex]==array[rightIndex]&&array[leftIndex]==array[mid]){
                //left和right相邻元素不等
                if(array[leftIndex+1]!=array[rightIndex-1]){
                    mid=array[leftIndex+1]<array[rightIndex-1]?(leftIndex+1):(rightIndex-1);
                    break;
                }
                //left和right相邻元素相等，各自向中间位移继续试探
                 else{
                    leftIndex++;
                    rightIndex--;
                }
            } 
            //
             else{
                //中间值比left大，最小值在后面子数组，mid位置赋给left
                if(array[mid]>=array[leftIndex]){
                    leftIndex=mid;
                }else{
                    //中间值比right小，最小值在前面子数组，mid位置赋给right
                    if(array[mid]<=array[rightIndex]){
                        rightIndex=mid;
                    }
                }
            }
        }
        return array[mid];
    }
}

7.斐波那契数列

题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
递归
运行时间：21ms
占用内存：9248k

public class Solution {
    public int Fibonacci(int n) {
        int result=0;
        int preOne=0;
        int preTwo=1;
        if(n==0){
            return preOne;
        }
        if(n==1){
            return preTwo;
        }
        for(int i=2;i<=n;i++){
            result=preOne+preTwo;
            preOne=preTwo;
            preTwo=result;
        }
        return result;
    }
}

迭代
运行时间：15ms
占用内存：9408k

public class Solution {
    public int JumpFloor(int target) {
        if (target <= 0||target>39) {
            return -1;
        }
        if (target == 1) {
            return 1;
        }
        if (target == 2) {
            return 2;
        }
        int result=0;
        int firstJump=1,secondJump=2;
        for(int i=3;i<=target;i++){
            result=firstJump+secondJump;
            firstJump=secondJump;
            secondJump=result;
        }
        return result;
    }
}

8.跳台阶

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
（1）假设有n个台阶，第一次跳1个台阶，剩下解一个跳f(n-1)级台阶的问题
（2）如果第一次跳2个台阶，剩下解一个跳f(n-2)级台阶的问题，这样总解决次数
f(n)=f(n-1)+f(n-2)
（3）当最后剩下一级或两级台阶时，f(1)=1，f(2)=2，整个问题转化为斐波那契数列问题

递归
运行时间：637ms
占用内存：9348k

public class Solution {
    public int JumpFloor(int target) {
        if (target <= 0||target>39) {
            return -1;
        } else if (target == 1) {
            return 1;
        } else if (target == 2) {
            return 2;
        } else {
            return  JumpFloor(target-1)+JumpFloor(target-2);
        }
    }
}

迭代
运行时间：16ms
占用内存：9380k

public class Solution {
    public int JumpFloor(int target) {
        if (target <= 0||target>39) {
            return -1;
        } else if (target == 1) {
            return 1;
        } else if(target == 2) {
            return 2;
        }
        int result=0;
        int firstJump=1,secondJump=2;
        for(int i=3;i<=target;i++){
            result=firstJump+secondJump;
            firstJump=secondJump;
            secondJump=result;
        }
        return result;
    }
}

9.变态跳台阶

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
f(1)=1
f(2)=f(2-1)+f(2-2)=f(1)+1
…
f(n)=f(n-1)+f(n-2)+…+f(1)+1=2*f(n-1)

运行时间：19ms
占用内存：9088k

public class Solution {
    public int JumpFloorII(int target) {
        if(target<=0){
            return -1;
        }else if(target==1){
            return 1;
        }else {
            return 2*JumpFloorII(target-1);
        }
    }
}

10.矩形覆盖

题目描述
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

依然是斐波那契数列，对非法、1、2 解释后，对于n，纵向覆盖一个新的小矩形，排列方法为f(n-1)，横向排列一个新的小矩形，排列方法为f(n-2)。

运行时间：507ms
占用内存：9332k

public class Solution {
    //target 代表要覆盖2*target大的大矩形
    public int RectCover(int target) {
        if(target<=0){
            return 0;
        }else if(target==1){
            return 1;
        }else if(target==2){
            return 2;
        }else{
            return (RectCover(target-1)+RectCover(target-2));
        }
    }
}

11.二进制中1的个数

题目描述：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

逐次辨别二进制补码最后一位是否为1
运行时间：12ms
占用内存：9784k

public class Solution {
    public int NumberOf1(int n) {
        int count=0;
        while(n!=0){
            count+=(n&1);
            n>>>=1;
        }
        return count;
    }
}

jdk自带计算位数的API
运行时间：18ms
占用内存：9436k

public class Solution {
    public int NumberOf1(int n) {
        return Integer.bitCount(n);
    }
}

12.数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

原始做法：
运行时间：75ms
占用内存：10828k

public class Solution {
    public double Power(double base, int exponent) {
        double result=1;
        for(int i=0;i<Math.abs(exponent);i++){
            result*=base;
        }
        if(exponent<0){
            result=1/result;
        }
        return result;
  }
}

运行时间：39ms
占用内存：10564k

public class Solution {
    public double Power(double base, int exponent) {
        if(exponent==0&&base!=0){
            return 1;
        }
        if(exponent==1){ 
            return base;
        }
        if(base==0&&exponent<=0){ //非法输入
            throw new RuntimeException();
        }
        if(base==0&&exponent>0){
            return 0;
        }
        int n=Math.abs(exponent);
        double result=Power(base,n>>1);
        result*=result;
        if((n&1)==1){
            result*=base;
        }
        if(exponent<0){
            result=1/result;
        }
        return result;
  }
}

15.反转链表

非递归方法：
第一次：
空指针异常抛出

public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null)
            return null;
        ListNode p=head.next;
        ListNode next=p.next;
        head.next=null;
        while(p!=null){
            p.next=head.next;
            head.next=p;
            p=next;
            next=p.next;
        }
        return head;
    }
}

第二次：
这个方法，链表如果有头结点，最后一个结点是空val的头结点。所以这个适合没有头结点的链表。
运行时间：20ms 26ms
占用内存：9716k 9532k

public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null)
            return null;
        ListNode next,pre;
        pre=null;
        while(head!=null){
            next=head.next;//next保存当前结点head的下一个节点防止断链
            head.next=pre;//当前节点head的链指向上一个节点pre
            pre=head;//把当前节点赋给pre
            head=next;//当前节点head后移一位
        }
        return pre;
       }
}

第三次：
适用于带头结点的链表

public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null)
            return null;
        ListNode next,p,pre;
        pre=head;
        p=head.next;
        next=p.next;
        pre.next=null;	//提前处理头结点head
        while(p!=null){
            next=p.next;
            p.next=pre.next;
            pre.next=p;
            p=next;
        }
        return pre;
       }
}

16.合并排序列表

非递归：
运行时间：21ms
占用内存：9700k

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null)
            return list2;
        if(list2==null)
            return list1;
        ListNode head=new ListNode(0);    //预设头结点
        ListNode temp=head;		//当前结点指示器
        while(list1!=null&&list2!=null){		//两链表当前都未空
            if(list1.val<=list2.val){
                temp.next=list1;
                list1=list1.next;
            }else{
                temp.next=list2;
                list2=list2.next;
            }
            temp=temp.next;		//移动当前结点指示器
        }
        if(list1!=null){		//有没空的表继续连上
            temp.next=list1;
        }
        if(list2!=null){
            temp.next=list2;
        }
        return head.next;		//剔除预设头结点返回
    }
}

递归：
运行时间：23ms
占用内存：9632k

public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null)
            return list2;
        if(list2==null)
            return list1;
        ListNode head=null;	//头结点指示器
        if(list1.val<=list2.val){
            head=list1;
            head.next=Merge(list1.next,list2);		//递归压栈，head这个引用
        }else{								    	//最后会指向合并后第一个结点
            head=list2;
            head.next=Merge(list1,list2.next);
        }
        return head;
    }
}
thefantast
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
剑指Offer习题集锦——Java实现及思路分析
tongdanping的博客
03-04 377
这里主要是关于数据结构中树的内容，题目主要是剑指offer上的题目，用Java实现，我现在还在做题，所以是做到哪里更新到哪里，我会尽量详述解题思路。1、数据结构（1）树二叉树镜像问题：点击打开链接二叉搜索树中第K大的节点：点击打开链接数据流中的中位数：点击打开链接从上到下打印二叉树：点击打开链接搜索二叉树的后序遍历：点击打开链接（2）链表查找队列中的最大值：点击打开链接两个链表的公共节点：点击打开...
剑指offerC++编程
a446712385的博客
06-16 526
剑指offerC++编程 1.二维数组查找 class Solution { public: bool Find(int target, vector
剑指Offer编程题-思路、代码
唱歌古树的博客
09-23 191
一、二维数组中的查找 题目描述: 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 解题思路: 这道题考算法,需要根据二维数组的特性进行分析,从而实现最快速的查找. 因为二维数组是矩形,首先需要找对角线,然后确定对角线,哪一条线适合用于比较,此题选择左下...
剑指offer中使用的C++知识
a362682954的博客
12-30 171
栈： 建栈：stack&lt;int&gt; a; 出栈：a.pop(); //出栈没有返回值，只能用top查看栈顶。 入栈：a.push(value); 查看栈头：a.top(); 查看是否为空：a.empty(); vector： 初始化：vector&lt;int&gt; a; 添加：a.push_back(value)； //不能直接赋值 查看最后一位:a.bac...
剑指Offer C++总结
xiaomifanhxx的博客
12-12 1944
1、向量vector用法 1.1  Vector的存储空间是连续的，List不是连续存储的。 定义初始化：  vector&lt;type&gt; v //默认v为空，即v[0]=5是错误的； vector&lt;type&gt; v1(v) 或者v1=v或者vector&lt;type&gt; v1(v.begin(),v.end()); vector&lt;type&gt; v(n,i...
剑指offer_牛客网_编程题_Java
点滴
04-18 687
剑指offer_牛客网_编程题_Java 目录 二维数组中的查找 替换空格 从尾打印链表 重建二叉树 用两个栈实现队列 旋转数组的最小数字 斐波那契数列 跳台阶 变态跳台阶 矩形覆盖 二进制中1的个数 数值的整数次方 调整数组顺序使奇数位于偶数前面
剑指offer（java版）.rar_剑指offer_剑指offer java_剑指offer（java版）
09-24
java方向面试经常考的编程题47道，比如单例模式等
sword_offer:剑指 offer 编程题的 Java 描述
05-19
sword_offer剑指offer编程题的Java描述详解见：
剑指offer算法题的java实现.zip
01-13
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
剑指Offer面试题，Java实现版本.zip
01-02
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
剑指Offer——编程题的Java实现（更新完毕……）
热门推荐
mine_song的博客
03-20 1万+
剑指Offer——编程题的Java实现
剑指Offer_编程题（66题） 题解 C++版本
DeathYmz的博客
08-19 1065
剑指Offer_编程题原题链接 题目目录&题解链接： 考点 题目 热度指数 通过率 数组 二维数组中的查找 157790 23.83% 字符串 替换空格 146574 24.56% 链表 从尾到头打印链表 127775 24.62% 树 重建二叉树 91028 23.02%...
剑指offer所有的题目总结
weixin_42268217的博客
12-22 662
目录 &nbsp; 基本都是参考别的博客和书本的代码，仅作为自己笔记用！！ 零、小结： 一、位运算 1、二进制中1的个数 2、判断二进制中0的个数 3.二进制高位连续0的个数 二、二叉树 1、二叉搜索树第k个结点 2.0&nbsp;从上往下打印二叉树 2.1二叉树打印成多行 2.2按之字形顺序打印二叉树 题目...
剑指Offer题目汇总(C++版)
Yummy
04-11 2461
最近，鉴于目前网上关于《剑指Offer》C++版的汇总资料特别少或者不规范，特整理了一版书中重要的考题，以备学习使用。 目录 一、位运算 1. 二进制中1的个数 2. 二进制中0的个数 3. 二进制高位连续0的个数 二、二叉树 1. 二叉搜索树第k个结点 2. 从上往下打印二叉树 3. 二叉树打印成多行 4. 数据流中位数 5. 二叉树中和为某一值的路径 6. 重建二叉树 ...
java中Overload和Override的区别
codedadi的博客
06-04 474
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
最新发布
星途码客的博客
06-04 1333
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 1177
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 606
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 702
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
剑指offer java
09-18
《剑指offer》是一本程序猿面试的经典书籍，其中包含了很多常见的算法题和解答。在这本书中，有关跳台阶的问题有两个，分别是《剑指offer》10 矩阵覆盖和《剑指offer》9 青蛙变态跳台阶。 对于《剑指offer》10 矩阵...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值