唐昊

SpringMVC是Spring框架提供的一款基于MVC（Model-View-Controller）模式的轻量级Web开发框架MVC是一种软件架构的思想，它将软件按照模型（Model）、视图（View）、控制器（Controller）来划分，将web层进行职责解耦，在Spring MVC中，控制器的问题得到了很好的解决。（ MVC中，控制器的核心功能是根据用户的请求调用对应业务功能，并依据业务处理的结果，控制程序的运行流程。

CentOS 7不带Mysql数据库了，默认的数据库是MariaDB（Mysql的一个分支）。可以按照以下步骤手动安装Mysql数据库。下载rpm安装文件wget http://repo.mysql.com/mysql-community-release-el7.rpm执行rpm安装rpm -ivh mysql-community-release-el7.rpm依赖解析完成后，出现下列选项：Dependencies Resolved=======================

package leetcode.lianbioa.project;import java.util.ArrayList;import java.util.List;import java.util.Stack;public class Day3 { public static Stack<Integer> stack1 = new Stack<>(); public static Stack<Integer> stack2 = new Sta

解法一：使用目标值遍历比较 public static int findPeakElement(int[] nums) { if (nums.length < 3) { if(nums.length == 1 ){ return 0; } return nums[0] > nums[1] ? 0:1; } // write code here

public int maxArea(int[] a) { int max = 0; for(int i = 0, j = a.length - 1; i < j ;){ int minHeight = a[i] < a[j] ? a[i ++] : a[j --]; max = Math.max(max, (j - i + 1) * minHeight); } return max; }

使用StringBuilder的方式 public static String form(String arr){ LocalDateTime begin = LocalDateTime.now(); StringBuilder stringBuilder = new StringBuilder(); StringBuilder append = stringBuilder.append(arr); StringBuilder reverse

采用逐步遍历 public ListNode mergeKLists(ArrayList<ListNode> lists) { ListNode root = new ListNode(-1); for(int i = 0 ;i< lists.size();i++){ root.next = mergeTwoLists(root.next,lists.get(i)); } return

哈希存储 public boolean hasCycle(ListNode head) { HashSet<ListNode> map = new HashSet<ListNode>(); ListNode temp = head; while(temp != null){ if(map.contains(temp)){ return true;

问题描述输入：[1,2,3] [4,5,6]输出：6 5 4 3 2 1代码实现package leetcode.lianbioa;import java.util.ArrayList;public class test1 { public static void main(String[] args) { Node node = new Node(1); Node node1 = new Node(2); Node node2 = n

问题描述给定一串无序数组，给定K值，需要找出从1-k个有序数字例如：[1,2,5,3,2,3] k = 2输出：1 2解题思路利用堆排序对该数组进行排序，并每次取出堆顶元素，取出K个即可时间复杂度 O(logn)构建大顶堆 public void buildHeap(int[] input) { // for (int i = input.length / 2 - 1; i >= 0; i--) { adjustHeap

利用hash算法public int FirstNotRepeatingChar(String str) { if (str == null || str.length() == 0) return -1; char[] c = str.toCharArray(); LinkedHashMap<Character,Integer> hash=new LinkedHashMap<Character,Integer&gt

问题描述有一组数据[1,2,3,4,5,6,7,8]需要将其分成[1, 3, 5, 7, 2, 4, 6]代码实现public static void sort(int[] arr, int left, int right) { // 定义左下标 int l = left; // 定义右下标 int r = right; // 定义临时变量 int temp = 0; // 当左下标

质数概念质数，又称素数，指在一个大于1的自然数中，除了1和此整数自身外，无法被其他自然数整除的数（也可定义为只有1和本身两个因数的数）。最小的素数是2，也是素数中唯一的偶数；其他素数都是奇数。质数有无限多个，所以不存在最大的质数。 public void prinf(int n ){ for (int i = 2; i < n; i++) { if(get(i)){ System.out.print(i+" ");

// 动态规划 求出 一串数组，最大的组合 public int maxSubArray(int[] nums) { int len = nums.length; int max = nums[0]; int [] dp = new int[len]; dp[0] = nums[0]; for (int i = 1; i < len; i++) { // 求出当前值和上一步的值 + 当前值.

问题描述利用hash表 public ListNode detectCycle(ListNode head) { HashMap<ListNode, Integer> hashMap = new HashMap<>(); int i = 0; ListNode temp = head; while (temp != null){ if(hashMa

import java.util.*;/* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */public class Solution { /** * * @param root TreeNode类 * @return int整型ArrayList<ArrayList<>&g

讲一下快速排序算法通过一次排序将数列分为两部分，一部分比另一部分数字都小时间复杂度O(nlogn)空间复杂度O(1)先确定一个中间比较值，确定一个左指针（从头开始），右指针（从尾部开始）while循环左子针一直往右找，右指针一直往左找，一直到二者有交集，就会退出循环，说明没有找到，若是在退出循环前找到了，则交换二者的位置// 交换完毕 如果该值 等于中轴值 则需 将右下标往前推进 if (arr[l] == pivot) { r -= 1;

乐观锁：就像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态，乐观锁认为竞争不总是会发生，因此它不需要持有锁，将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。悲观锁：还是像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态，悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁，就像synchronized，不管三七二十一，直接上了锁就操作资源了。悲观锁 代表是synchronized 和 lock锁其

事务：一般是指要做的事，在计算机中指的是访问并可能更新数据库中各种 数据项的一个程序执行单元ACID原则原子性：一个事务是是一个不可分割的工作单元，要么都做，要么都不做一致性：事务必须是从数据库从一个一致性到另一个一致性隔离性：一个事务的执行不受其他事务的干扰，即一个事务内部的操作及使用的数据对并发的其他事务都是隔离的，并发执行互不干扰持久性：一个事务一旦提交，它对数据库的改变就是永久的，对于接下来的操作就不应该有任何的影响...

如下图所示的三角形，有三个边s1,s2,s3,边s1有四个圆圈⭕️1，2，3，4，边s2有四个圆圈⭕️4，5，6，7，边s3有四个圆圈⭕️7，8，9，1把1-9这9个数字，分别填写到下图所示的9个圆圈圆圈里， 使每条边上的4个圆圈⭕️的和相等（9个圆圈里的数字不能重复)例如：s1=[1=>9,2=>8,3=>1,4=>3]=9+8+1+3=21,s2=[4=>3,5=>5,6=>7,7=>6]=3+5+7+6=21,s3=[7=>6,8=>2.

import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int[] weight = {2, 3, 1,5,4,3}; //重量的分布 int[] val = {2, 2, 3,1,5,2};// 价值的分布 int n = in.nex.

package JTanG.ChinaEmp;import java.util.concurrent.locks.Lock;public class Test2 { public volatile static int flag = 0; public volatile static int i = 0; public static void main(String[] args) { Thread thread = new Thread(() ->

1. 通过new关键字创建对象，按需调用我们所需的构造函数Object a = new Object();2. 通过class类的newInstance()方法class EmpObj{ private String name; public EmpObj() { } public String getName() { return name; } public void setName(String name) {

IDE在DUBUG默认的情况下显示的数据是经过简化后的，需要进行设置才能显示完整有参构造，无参构造如果是有参构造器Vector类的底层源码剖析多线程并发建议使用Vector（底层有线程互斥操作）Vector 和 ArrayList的比较...

说明‘1’ ----> 1 （前面一个为char类型1，后面的为整型1）代码如下 public static int transform(char a){ return Character.isDigit(a)?Integer.valueOf(a - '0'):-1; }说明：Character.isDigit：检测所传入的字符是否为数字（根据结果返回TRUE，FALSE）a - '0'因为’0’的ASCII为48，数字1,2,3…递增，可以求

Stream流计算创建的几种方式distinct去重需要 ，重写hashcode与equals方法map 和 reduce

区别1.可变性String是使用字符串数组保存字符串，底层是使用final修饰的，属于不可变类型StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。2.线程安全String中的对象是不可变的，也就可以理解为常量，线程安全StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。Strin

顺序存储二叉树从数据储存来看，数组存储方式和树的存储方式可以转换，即数组可转换成树，树也可以转换成数组按照二叉树的构造，要以数组的形式去储存arr[1,2,3,4,5,6]在遍历数组arr时，可以前序中序后序的形式去遍历顺序存储二叉树的特点：顺序二叉树通常只考虑完全二叉树第n个元素的左子节点 2 * n + 1第n个元素的右子节点为 2 * n + 2第n个元素的父节点为 （n - 1 )/2n 表示二叉树的第几个袁术...

算法步骤

Java 内存模型

死锁出现场景： 一个线程需要同时获得多把锁的时候，容易发生死锁的问题应用实例thread-1线程获取a锁，同时想要获取b锁thread-2线程获取b锁，同时想要获取a锁 public static void main(String[] args) { Object a = new Object(); Object b = new Object(); new Thread(() -> { synchroni

轻量级锁栈帧中创建锁记录对象，lock record（对象指针（object reference））解锁工作锁膨胀出现原理：00已经加了轻量级的锁了，执行methed1 要执行栈帧，里面生成新的lock Record 记录，让reference对象引用地址指向object对象、再将lock record的地址值与object的值进行交换（然而00表示轻量级锁的状态，不能成功交换了），进入锁膨胀流程进入重量级的状态然而当进行解锁的时候，由于monitor地址指向重量级的锁，不能成

平衡二叉树基本介绍也叫平衡二叉搜索树，又被称为AVL树，可以保证查询效率较高具有以下的特点：他是一颗空树或者它的左右两个子树的高度差不能超过1，并且左右两个子树都是一颗平衡二叉树，平衡二叉树的常用实现方法有红黑树，AVL，替罪羊树，Treap,伸展树等...

package tree.threadedbinarytree;import java.util.concurrent.SynchronousQueue;public class ThreadedBinaryTreeDemo { public static void main(String[] args) { //测试一把中序线索二叉树的功能 HeroNode root = new HeroNode(1, "tom"); HeroNode node2 = new HeroNode(3

骑士周游问题的解决步骤和思路创建棋盘chessBoard是一个二维数组将当前位置设置为已经访问，然后根据当前的位置，计算马儿能走到哪个位置，并放入到一个集合中，而集合最大为8个数据，每走一步就递归，并且step + 1将集合按照非递减的形式排列，提高效率，再循环试走，如果走通，递归尝试，不通则回溯设置标志位，进行判断，如果全部遍历（使用step和应该走的步数进行比较，如果没有达到数量，则将整个棋盘置空）贪心算法优化算法对于遍历获取的步骤集合的先后顺序进行优化，进行非递减排序9,7,

DFS深度优先遍历

堆排序调整，然而每次都需要交换，将最大放在末尾，并每次调整，每次遍历都length-1

package kruskal;import java.util.Arrays;public class KruskalCase { private int edgeNum; //边的个数 private char[] vertexs; //顶点数组 private int[][] matrix; //邻接矩阵 //使用 INF 表示两个顶点不能连通 private static final int INF = Integer.MAX_VALUE; public static voi

弱引用垃圾回收算法标记清除标记整理优点：没有内存碎片缺点：内存重新整理，影响效率复制算法清除FROM里面的全部，再交换FROM和TO的位置完成复制回收操作分代垃圾回收新生代：代表老年代垃圾回收算法，一开始对象创建之后会放入伊甸园中当再次创建对象的时候，内存不够用，将会触发Minor GC算法回收将存活的对象放入到存活去TO，并将幸存对象的寿命+1，再次将存活区的FROM和TO区进行交换，之前的伊甸区清理内存如此以往，当存活区FROM中的对象达到阈值15，.

求出从某一结点开始到达其他结点距离花费最少的组合