构架即未来
计算机编译原理
感觉还是要好好补全知识体系，为以后向业务架构师努力。
不过也发现以前要是大学时候能看到一些书就好了，比如微积分和当代通信的关系，他们之间是如何连接在一起的。大学都只会傻乎乎的人云亦云的说某某某没有用不用学。可惜老师也说不清学了有什么用，人总是功利的=。=只能说我只是一个俗人咯，该好好学的时候没有好好的学。。。
作者： Michaelssss
大学期间一直想干的事情。。终于现在写出来了。。四则运算带括号随便干。。。
import java.util.Stack;
public class RPN
{
public Long Cal(String s){
Stack a = this.Expression2Stack(s);
Stack rpnstack = this.Turn2RPN(a);
return this.Eval(rpnstack);
}
public Long Eval(Stack rpnStack){
Stack<Long> num = new Stack();
for(Object o:rpnStack){
if(o instanceof Operate)
{
Operate tmp = (Operate)o;
Long num1 = num.pop();
Long num2 = num.pop();
switch (tmp){
case PLUS:{
num.push(num2+num1);
break;
}
case MINUS:{
num.push(num2-num1);
break;
}
case MUTIPLE:{
num.push(num1*num2);
break;
}
case DIVIE:{
num.push(num2/num1);
break;
}
case POWERDE:{
num.push((long)(Math.pow(num2.doubleValue(),num1.doubleValue())));
break;
}
}
}
else{
String tmp = (String) o;
if(this.isNumberic(tmp))
num.push(Long.valueOf((String)o));
}
}
return num.pop();
}
private boolean isNumberic(String s){
for(char c:s.toCharArray()){
if(!Character.isDigit(c))return false;
}
return true;
}
private Stack Turn2RPN(Stack Expression)
{
Stack s1 = new Stack();
s1.push(Operate.NONE);
Stack s2 = new Stack();
for (Object x : Expression)
{
if (x instanceof Operate)
{
if (x == Operate.LEFTPARENTHESE)
{
s1.push(x);
}
else if (x == (Operate.RIGHTPARENTHESE))
{
while (true)
{
if (s1.lastElement() == Operate.LEFTPARENTHESE)
{
s1.pop();
break;
}
else
{
s2.push(s1.pop());
}
}
}
else if (x instanceof Operate && s1.lastElement().equals(Operate.LEFTPARENTHESE))
{
s1.push(x);
}
else if (x instanceof Operate && !s1.lastElement().equals(Operate.LEFTPARENTHESE))
{
if (((Operate)s1.lastElement()).getPiority() < ((Operate)x).getPiority())
{
s1.push(x);
}
else
{
while (true)
{
if (((Operate)s1.lastElement()).getPiority() < ((Operate)x).getPiority())
{
break;
}
if (s1.lastElement().equals(Operate.LEFTPARENTHESE))
{
break;
}
s2.push(s1.pop());
}
s1.push(x);
}
}
}
else
{
s2.push(x);
}
}
while (!s1.empty())
{
s2.push(s1.pop());
}
s2.pop();
return s2;
}
private Stack Expression2Stack(String Expression)
{
Stack expression = new Stack();
StringBuffer numString = new StringBuffer();
for (char charater : Expression.toCharArray())
{
switch (charater)
{
case '+':
{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.PLUS);
break;
}
case '-':
{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.MINUS);
break;
}
case '*':
{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.MUTIPLE);
break;
}
case '/':
{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.DIVIE);
break;
}
case '^':{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.POWERDE);
break;
}
case '(':
{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.LEFTPARENTHESE);
break;
}
case ')':
{
if (numString.length() != 0)
expression.push(numString.toString());
numString = new StringBuffer();
expression.push(Operate.RIGHTPARENTHESE);
break;
}
default:
{
numString.append(charater);
}
}
}
if(numString.length()>0)expression.push(numString.toString());
return expression;
}
}
enum Operate
{
NONE("#", 0),
PLUS("PLUS", 1),
MINUS("MINUS", 1),
MUTIPLE("MUTIPLE", 2),
DIVIE("DIVIE", 2),
POWERDE("POWDE",3),
LEFTPARENTHESE("LEFTPARENTHESE", 4),
RIGHTPARENTHESE("RIGHTPARENTHESE", 4);
private int piority;
private String operate;
Operate(String operate, int i)
{
this.piority = i;
this.operate = operate;
}
public int getPiority()
{
return piority;
}
}
EffectiveJava(一)
第十三条：
应使得类对外暴露的接口最小化，能private就private，能final就final。
十四条：
应该提供访问方法而不应该公有域。
理由：可以在内部改变的时候外部调用可以不改变
十五条：
除非必要，尽量使用非可变对象。
理由：非可变对象的状态是可以预测的，如果一定是要可变的，要减少可变对象的状态。
List的可协变性疑问（二）
昨天心有不甘，觉得Java的开发人员不可能出现这种错误的，所以又继续的看资料。
其实容器是分为元类型和和泛型（可能我扯中文太蛋疼了）。。实际意思就是对于编译器来说List<Object>和List不是一个事情，但是最终编译器会替我们将List<Type>的类型擦除，最终JVM看到的其实还是List而不是List<Object>然后做强制转换的。我们反编译一下这个java文件的class看看就清晰了。
List的可协变性疑问
package com.company;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<A> a = Arrays.asList(new A(), new B(), new C());
for (A aa : a) {
System.out.println(aa instanceof C);
}
}
}
class A {
public A() {
System.out.println("new A");
}
@Override
public String toString() {
return "I'm A";
}
}
class B extends A {
public B() {
System.out.println("new B");
}
@Override
public String toString() {
return "I'm B";
}
}
class C extends B {
public C() {
System.out.println("new C");
}
@Override
public String toString() {
return "I'm C";
}
}
在1.8以前的版本这个代码是无法运行的，原因是List<>具有不可协变性，可是在1.8这个版本之后，这是可以运行的。而且里面的内容也的确是实例化了子类。然后我就蒙逼了。说好的Collettion的不可协变性完蛋了。。。。
Linux定时备份任务
在当前用户目录下新建一个sh
按照我的备份方式就是
tar -jPcf BackupPath.tar.gztoBackupPath
然后运行crontab -e写入
* * * * 1 sh {你sh所在的目录位置}+{你的sh文件名字全称}
保存，然后这个sh文件就会每周一执行一次
略方便
Static关键字
Java里面Static关键字不仅可以修饰变量，函数，类，甚至修饰一段代码。
Static关键字在虚拟机加载class阶段就会运行，所以运行等级高于Construct函数。
我是如何为我的博客添加SSL加密的
关于Let’s Encrypt参考：letsencrypt官网
在前辈们的辛勤劳作下，我们这些小白用户终于能够快速的自动化的申请SSL证书了。
所以申请证书只需要以下几个步骤，这里我们采用的是官方提供的sh脚本，据某些大牛说还有个更小巧的py脚本，但是我是aliyun，对这种基本都是坑：
- su
- git clone https://github.com/letsencrypt/letsencrypt
- cd letsencrypt
- ./letsencrypt-auto
如何新建一个Spring MVC+DAO层的项目（一）
如何开始：
整个项目建立好了的结构在这里可以看到：
https://github.com/michaelssss/MealControlSystem
首先这是基于IDEA的一个示例（我表示Eclipse实在不讨喜，Eclispse自己也发现这个问题已经有新的产品了）。
我们选择通过IDEA的模板新建一个Maven工程
高精度加法
两数相加，保证为正整数。一定会超过long long。所以有如下程序。。。同时这也是某次面试的错。。。
思路如下：
两个字符串去做反转，然后从0为开始相加，遇到满十做进位记号。
记得为了最后有可能的进位，要将数组多申请一个位置（这里是个坑）
最后再反转数组然后转换成字符串返回即可
public static String Bigcamladd(String a, String b) {
char[] A = new StringBuffer(a).reverse().toString().toCharArray();
char[] B = new StringBuffer(b).reverse().toString().toCharArray();
boolean isOver10 = false;
int resultLength = A.length > B.length ? A.length : B.length;
int shortOne = A.length < B.length ? A.length : B.length;
int[] result = new int[resultLength + 1];
for (int i = 0; i <= resultLength - 1; ) {
if (i < shortOne) {
int tmp = A[i] + B[i] - 2 * '0';
if (isOver10) tmp += 1;
if (tmp >= 10) isOver10 = true;
else isOver10 = false;
result[i] = tmp % 10;
} else {
result[i] = A.length > B.length ? A[i] - '0' : B[i] - '0';
}
i++;
}
if (isOver10) result[resultLength] = 1;
StringBuffer buffer = new StringBuffer();
for (int i : result) {
buffer.append(i);
}
return buffer.reverse().toString();
}
不得不再感叹一次，Java的String类真特么的好用阿。。。。