JDBC工具类的封装 

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
public class JDBCUtil {
    /**
     * 一般工具类的构造方法都是私有的，
     * 因为工具类中的方法都是静态的，不需要new对象，直接类名调用即可
     */
    private JDBCUtil(){};
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?&useSSL=false&serverTimezone=UTC","root","123456");

    }
    public static void close(Connection conn, Statement ps, ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(ps!=null){
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

展开全文 >>

JDBC

一、首先什么是JDBC

  • JDBC接口（API）包括两个层次：
    • 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
    • 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。

不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。 ————面向接口编程

  • 二、编写JDBC程序的步骤（六个步骤）
    • 加载并注册驱动
    • 创建Connection对象来获取连接
    • 获取数据库的操作对象
    • 执行sql语句
    • 返回结果集
    • 关闭资源

1.注册驱动
首先我们要new出Driver类，Driver接口在java.sql.Driver()中，Driver接口实现类在com.mysql.jdbc.Driver()中，两者包名不同但名字相同，注意正确地导包

展开全文 >>

关于排列组合和子集的区别

这篇文章将会比较两种常见的回溯体型，一种是全排列问题，一种是求子集的问题，两者都是利用回溯解法，但是两者的for循环选取下一个可选值时的起始坐标是不同的，先上部分代码我们来比较以下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//子集求法
for(int j = i;j<nums.length;j++) {
			temp.add(nums[j]);
			dfs(nums, j+1);
			temp.remove(temp.size()-1);
		}
//全排列求法		
for(int i = 0;i<len;i++) {
			if(!visited[i]) {
				path.add(nums[i]);
				visited[i] = true;
				dfs(nums, len, depth+1, path, res, visited);
				//恢复操作
				visited[i] = false;
				path.remove(path.size()-1);
			}
		}



我们观察两者的区别，发现前者的代码for循环是从startIndex开始的，而后者的代码for循环总是从0开始的，这是为什么呢？
因为全排列是有顺序的1，2和2，1是不同的，而对于集合来说1，2和2，1是相同的，所以在变量集合的过程中，我们不能回头，否则会产生重复，正是因为子集求法没有回头，所以我们不需要创建used数组来判断数字是否使用过，仔细品味上述的图片和代码就会明白其中的道理！！

展开全文 >>

Servlet接口实现类

一、介绍：
1.servlet接口来自于Servlet规范下一个接口，这个接口存在Http服务器提供的jar包中
2.TomCat服务器下lib文件有一个servlet-api.jar存放servlet接口
3.servlet规范中规定，Http服务器能调用的【动态资源文件】必须是一个Servlet接口实现类

展开全文 >>

所有左叶子节点的和 

1
2
3
4
5
6
7
8
9
10
11
计算给定二叉树的所有左叶子之和。

示例：

    3
   / \
  9  20
    /  \
   15   7

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

主要思路：
本题在于判断一个节点是否为左叶子节点，如何判断一个节点是否是左叶子节点的？
我们单单通过当前节点是无法判断的，我们需要根据其父节点来判断 

1
2
3
if(root.left!=null&&root.left.left==null&&root.left.right==null){
    return 0;
}

普通版： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
    int sum = 0;
    public int sumOfLeftLeaves(TreeNode root) {        
        if(root==null) {
			return 0;
		}
		dfs(root);
		return sum;
    }
    public void dfs(TreeNode root) {
		if(root==null)
			return;
		if(root.left!=null&&root.left.left==null&&root.left.right==null) {
			sum+=root.left.val;
		}
		dfs(root.left);
		dfs(root.right);
	}
}

简洁进化版：

1
2
3
4
5
6
7
8
9
public static int sumOfLeftLeaves(TreeNode root) {
		if(root==null)
			return 0;
		int sum = 0;
		if(root.left!=null&&root.left.left==null&&root.left.right==null) {
			sum +=root.left.val;
		}
		return sum+sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right);
    }

展开全文 >>

TomCat服务器

http网络协议包

一、网络协议包：
1.在网络中传递信息都是以二进制形式催在的
2.接收方[浏览器/服务器]在接受信息后，要做的第一件事就是将[二进制数据]进行编译[文字，图片，视频，命令]
3.传递信息数据量往往比较巨大，导致接收方很难在一组连续二进制得到对应的数据
4.网络协议包一组有规律的二进制数据，在这组数据中存在了固定的空间，每一个固定的空间存放特定的信息，这样接收方在接受网络协议包之后就可以得到固定空间的对应的信息，网络协议包极大降低了接收方接受对应二进制数据编译的难度
二、常见的网络协议：
1.FTP网络协议包
2.Http网络协议包
三、Http网络协议包：
在基于B/S结构下互联网通信过程中，所有在网络中传递信息都是保存在Http网络协议包中分为Http请求协议包和Http响应协议包
四、Http请求协议包与Http响应协议包介绍：
1.Http请求协议包：
在浏览器准备发送请求时，负责创建一个Http请求协议包，浏览器将请求信息以二进制的形式保存在请求协议包各个空间中，由浏览器负责将Http请求协议包推送到指定服务端计算机
2.Http响应协议包：
Http服务器在定位到被访问的资源后负责创建一个Http响应协议包，Http服务器将定位文件内容以二进制写入到Http响应协议包中推送会发起请求的浏览器上
五、Http请求协议包内部空间
1.按照自上而下划分，分为4个空间
2.空间划分，自上而下：
请求行 

1
2
url：请求地址  
method：请求方式

请求头 

1
请求参数信息[当请求方式为GET]

空白行

1
没有任何内容，起到隔离作用

请求体 

1
请求参数信息[当请求方式为POST]

六、Http响应协议包内部结构
1.按照自上而下的划分，分为4个空间
2.空间划分，自上而下：
状态行

1
Http状态码

响应头

1
content-type：指定浏览器采用对应的编译器。对响应体二进制数据进行解析

空白行

1
没有任何内容，起到隔离作用

响应体

1
2
3
4
可能被访问静态资源文件内容
可能被访问的静态资源文件命令
可能被访问的动态资源文件运行结果
（都是以二进制形式）

展开全文 >>

全排列II

title: 全排列II
categories: 数据结构与算法

1
2
3
4
5
6
7
8
9
10
11
给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]
输出:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

主要思路:整体思路和全排列是大致相同的，本题的难点在于如何剪枝，如何去重

如图所示，当我们把nums数组排好序后，我们思考一个问题，什么时候会产生重复的组合，红色框内标注的情况是和1是一样的，所以当num[i-1]==nums[i]时，可能会发生重复，当我们是要判断层重复，而不是枝重复，如果仅仅只有这个条件那么最左边一条路径在选取第二个i时，也无法选择
所以我们还需要另一个判重条件
我们在深入分析可以发现，其实我们要剪枝的部分是满足上述条件且刚刚撤销选择的部分，当我们撤销选择时，在重新选取下一个数时，如果num[i-1]==num[i]说明下面的情况都相同
剩下的代码和全排列相同 

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
public class PermuteUnique {
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int [] nums = {1};
		List<List<Integer>> permuteUnique = permuteUnique(nums);
		for(List list:permuteUnique)
			System.out.println(list.toString());
	}
	public static List<List<Integer>> permuteUnique(int[] nums) {
		if(nums.length == 0)
			return null;
		Arrays.sort(nums);
		boolean []used = new boolean[nums.length];
		//推荐使用Deque来创建stack类
		Deque<Integer> path = new ArrayDeque();
		List<List<Integer>> res = new ArrayList<>();
		dfs(0, nums,used,path,res);
		return res;
    }
	public static void dfs(int depth,int[] nums,boolean[] used,Deque<Integer> path,List<List<Integer>> res) {
		if(depth==nums.length) {
			res.add(new ArrayList<>(path));
			return;
		}
		for(int i = 0;i<nums.length;i++) {
		//剪枝条件
			if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false)
				continue;
	    //普通全排列保证这个数没有选过
			if(used[i])
				continue;
			path.addLast(nums[i]);
			used[i] = true;
			dfs(depth+1, nums, used,path,res);
			used[i] = false;
			path.removeLast();
		}
	}

}

展开全文 >>

TomCat服务器

一、如何下载安装TomCat，安装及配置
1.下载：https://tomcat.apache.org/ 官方网址，一般下载Tom9，64位，下载后直接安装
2.配置TomCat环境变量
①.配置JAVA_HOME，将jdk的路径配置到环境变量中C:\Program Files\Java\jdk-14.0.1
②.配置CATALINA_HOME，将TomCat的路径加入到环境变量中 D:\apache-tomcat-9.0.37-windows-x64\apache-tomcat-9.0.37
二、如何启动和关闭TomCat服务器
1.进入tomCat，bin目录下的startup和shutdown的exe后缀文件，或是在bin目录下使用cmd输入startup和shutdown。
注意事项
一般在开启服务前，先关闭服务，防止忘记关闭服务再次打开失败
当成功启动tomCat服务器后，localhost:8080访问后出现连接成功的页面则表示连接成功
三、如何利用idea启动TomCat服务器
1.File（文件）->setting(设置)->构建、执行、部署->application service->点击+号，tomCat service设置tomCat的路径
2.准备开关：运行->编辑配置->+tomCat service->默认选项
3.当运行按钮后弹出页面，在地址后加上想要访问的目录既可运行成功
四、idea创建网站
1.创建modea文件，Java Enterprise下Web Application此处位网站起名时可以添加中文
2.创建myWeb后下的文件结构：
①.src放置作为动态文件资源的Java文件
②.web文件架存放作为静态资源文件例如:图片，html，css，js
 –web下的WEB_INF中存放网站的核心配置文件(web.xml)
  –WEB-INF下的lib文件夹存放网站运行的核心配置文件时依赖的jar文件
3.为开关设置发布行为，运行->编辑配置->选到相应开关->deployment->+artifat->为网站起英文别名
4.运行即可

展开全文 >>

解数独

title: 解数独
categories: 数据结构与算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
编写一个程序，通过已填充的空格来解决数独问题。

一个数独的解法需遵循如下规则：

数字1-9在每一行只能出现一次。
数字1-9在每一列只能出现一次。
数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。
空白格用'.'表示。


一个数独。

答案被标成红色。
Note:
给定的数独序列只包含数字1-9和字符'.'。
你可以假设给定的数独只有唯一解。
给定数独永远是9x9形式的。

主要思路：
1.首先这里用到了几个技巧，首先是visited数组的设置来标记行使用，列使用，和3*3的方格内的使用情况
2.关于返回值为booelan型的递归时，如何确定返回条件

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
42
43
44
45
46
47
class Solution {
     boolean [][] lineUsed;
	 boolean [][] colUsed;
	 boolean [][][] boardUsed;
    public void solveSudoku(char[][] board) {
        lineUsed = new boolean[9][10];//记录行使用情况
		colUsed = new boolean[9][10];//列使用情况
		boardUsed = new boolean[9][9][10];//3*3方格内的使用情况
		for(int i = 0;i<9;i++) {
			for(int j = 0;j<9;j++) {
				if(board[i][j]!='.') {
					int num = board[i][j]-'0';
					lineUsed[i][num] = true;
					colUsed[j][num] = true;
					boardUsed[i/3][j/3][num] = true;
				}
			}
		}//先将已经填好的给标记
		recursion(board,0,0);//递归填剩下的空白处
    }
    public  boolean recursion(char[][] board,int i,int j) {
		if(j==9) {
			j = 0;
			i++;
			if(i==9) {
				return true;
			}
		}
		if(board[i][j]!='.') return recursion(board,i,j+1);//不是空白直接递归下一个位置
		for(int k= 1;k<=9;k++) { //尝试填入1-9
			if(lineUsed[i][k]||colUsed[j][k]||boardUsed[i/3][j/3][k])
				continue;//用过了就跳过
			board[i][j] = (char)(k+'0');
			lineUsed[i][k] = true;
			colUsed[j][k] = true;
			boardUsed[i/3][j/3][k] = true;
			if(recursion(board, i, j+1))return true;
			//回溯，状态重置
			board[i][j] = '.';
			lineUsed[i][k] = false;
			colUsed[j][k] = false;
			boardUsed[i/3][j/3][k] = false;
		}
		//如果1-9填入都不行那就return false
		return false;
	}
}

展开全文 >>

只出现一次 的数字 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例2:

输入: [4,1,2,1,2]
输出: 4

这道题如果不限制时间和空间的复杂度其实有很多种解法，接下来我们着重讲三种做法，不在于结果而在于解决这个问题过程种的分析
一、利用hashMap对应存储每个数字的次数，最后取出次数为1的数字，但时间复杂度为o（n） 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    public int singleNumber(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer i : nums) {
            Integer count = map.get(i);
            count = count == null ? 1 : ++count;
            map.put(i, count);
        }
        for (Integer i : map.keySet()) {
            Integer count = map.get(i);
            if (count == 1) {
                return i;
            }
        }
        return -1; 
    }
}

二、我们如果利用暴力方法对每一个数组在后面的集合中查找时间复杂度为o(n^2),但我们思索一下，如果我们将数组排序一下，就可以讲复杂度降到o(n),且是线性复杂度 

1
2
3
4
5
6
7
8
9
public static int singleNumber(int[] nums) {
		Arrays.sort(nums);
		int i;
		for( i = 0;i+1<nums.length;i=i+2) {
			if(nums[i]!=nums[i+1])
				return nums[i];
		}
		return nums[i];
    }

三、接下来的方法非常牛，利用位运算来解决问题，接下来就来分析一下位运算，以及如何利用位运算来解决这个问题,由于输入问题我们用#代替^符号
首先我们来理解一下或与运算符的规则，位运算有以下三种性质
即根据操作数的二级制数来运算，对应位相同则为0，不同则为1，利用这个衍生处三个性质
1.任何与0做位运算的数字结果都为数字本身：0#a=a
2.任何数于本事做位运算结果都为0:a#a=0
3.位运算满足交换律和结合律即:a#b=b#a,a#b#c#d=(a#b)#(c#d)
所以我们利用上述的结论，对数组进行分析，我们假设该数组有2*m+1个数字，其中m组数组均为出现2次，剩余一个数字出现1次，那么我们总可以将这个数组化成下列形式
(a1#a1)#(a2#a2)……(am#am)#am+1,其中成对的结果都为0最终就是0#am+1就是只出现了一次的数字

1
2
3
4
5
6
7
public static int singleNumber2(int [] nums) {
		int res = 0;
		for(int num:nums) {
			res^=num;
		}
		return res;
	}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

蛙广志<br><br>总要变强<br>