发表于

URL

URL
1、URL(Uniform Resource Locator)统一资源定位符，表示Internet上某一资源的地址，协议名：资源名称

TCP

1、TCP协议是面向连接的、可靠的、有序的、以字节流的方式发送数据，通过三次握手方式建立连接，形成传输数据的通道，在连接中进行大量数据的传输，效率会稍低

2、Java中基于TCP协议实现网络通信的类
​ 客户端的Socket类
​ 服务器端的ServerSocket类
Socket通信模型
3、Socket通信的步骤
​ ① 创建ServerSocket和Socket
​ ② 打开连接到Socket的输入/输出流
​ ③ 按照协议对Socket进行读/写操作
​ ④ 关闭输入输出流、关闭Socket
4、服务器端：
​ ① 创建ServerSocket对象，绑定监听端口
​ ② 通过accept()方法监听客户端请求
​ ③ 连接建立后，通过输入流读取客户端发送的请求信息
​ ④ 通过输出流向客户端发送乡音信息
​ ⑤ 关闭相关资源
5、客户端：
​ ① 创建Socket对象，指明需要连接的服务器的地址和端口号
​ ② 连接建立后，通过输出流想服务器端发送请求信息
​ ③ 通过输入流获取服务器响应的信息
​ ④ 关闭响应资源
6、应用多线程实现服务器与多客户端之间的通信
​ ①服务器端创建ServerSocket，循环调用accept()等待客户端连接
​ ② 客户端创建一个socket并请求和服务器端连接
​ ③ 服务器端接受苦读段请求，创建socket与该客户建立专线连接
​ ④ 建立连接的两个socket在一个单独的线程上对话
​ ⑤ 服务器端继续等待新的连接

发表于

分箱

参考文章：

[集合排序]（https://blog.csdn.net/hu_shengyang/article/details/6249309)
离群点分析
异常点/离群点检测算法-Lof
整个分箱法的算法没有什么难度，重点在于离群点分析，这里对离群点的分析采用局部异常因子算法(Lof),具体代码参考参考文献。

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package data_mining;
import java.util.ArrayList;
import java.util.Collections;
/*文中不包含离群点分析*/
//import java.util.Scanner;
public class Fenxiang {
	private ArrayList<Integer> data;
	private ArrayList<Integer> box;
	private ArrayList<Integer> border;
	public Fenxiang(ArrayList<Integer> d) {
		
		this.data=sort(d);
	}
	public Fenxiang() {
		
	}
	
public ArrayList<Integer> sort(ArrayList<Integer> al) {//分箱法中data集合赋值后直接进行排序
//    int[] arr1={1,3,5,7,9};
//    int[] arr2={2,4,6,8,10};
////    List<Comparable> al = new ArrayList<Comparable>();
//    ArrayList<Integer> al = new ArrayList<Integer>();
//    for(int i=0;i<arr1.length;i++){
//        al.add(arr1[i]);
//    }
//    System.out.println(al);
//    for(int j=0;j<arr2.length;j++){
//        al.add(arr2[j]);
//    }
//    System.out.println(al);
/*  Iterator<Comparable> it=al.iterator();
    Integer obj = null;
    while(it.hasNext()){
        obj=(Integer)it.next();    
        al.add(obj.intValue());
    }
    */
    Collections.sort(al);//对数组排序
    //Arrays.sort(al.toArray());//对list排序
//    System.out.println(al);
    return al;
}
//	public void scan(Scanner s) {
//		data.add(s.nextInt());
//	}
	public void setData(ArrayList<Integer> d) {
		this.data=sort(d);
	}
	public ArrayList<Integer> average(int n) {//向下取整average,箱深度为n
		ArrayList<Integer> box1=new ArrayList<Integer>();
		for(int i=0;i<data.size();i=i+n) {
			int ave=0;
			if(data.size()-i<n) {
				for(int j=0;j<data.size()-i;j++) {
					ave+=data.get(i+j);
				}
				ave=ave/(data.size()-i);
				box1.add(ave);
			}else {
				for(int j=0;j<n;j++) {
					ave+=data.get(i+j);
				}
				ave=ave/(n);
//				System.out.println(ave);
				box1.add(ave);
			}
		}
		setBox(box1);
		return box1;
	}
	public void showBorder(int n) {
		for(int i=0;i<border.size();i+=n) {
			System.out.print("箱"+((i/n)+1)+": ");
			for(int j=0;j<n;j++) {
				System.out.print(border.get(i+j)+" ");
			}
			System.out.println();
		}
	}
	public ArrayList<Integer> border(int n){
		ArrayList<Integer> bo=new ArrayList<Integer>();
		for(int i=0;i<data.size();i=i+n) {
			bo.add(data.get(i));
			for(int j=1;j<n-1;j++) {
				if((data.get(i+j)-data.get(i))<(data.get(i+n-1)-data.get(i+j))) {
					bo.add(data.get(i));
				}else {
					bo.add(data.get(i+n-1));
				}
			}
			bo.add(data.get(i+n-1));
		}
		this.border=bo;
		return bo;
	}
	public ArrayList<Integer> Mediam(int n) {//取中位数,箱深度为n
		ArrayList<Integer> box1=new ArrayList<Integer>();
		for(int i=0;i<data.size();i=i+n) {
			int med=0;
			if(data.size()-i<n) {
				if((data.size()-i)/2==0) {
					med=(data.get(i+(data.size()-i)/2)+data.get(i+(data.size()-i)/2-1))/2;
				}else {
				med=(data.get(i+(data.size()-i)/2));}
				med=med/(data.size()-i);
				box1.add(med);
			}else {
				if(n/2==0) {
					med=(data.get(i+n/2)+data.get(i+n/2-1))/2;
				}else {
				med=(data.get(i+n/2));}
//				System.out.println(ave);
				box1.add(med);
			}
		}
		setBox(box1);
		return box1;
	}
	public ArrayList<Integer> getBox() {
		return box;
	}
	public void setBox(ArrayList<Integer> box) {
		this.box = box;
	}
	public void showData(){
		for(int i=0;i<data.size();i++) {
			if(i==10) System.out.println(" ");
			System.out.print(data.get(i)+"  ");
		}
	}
	public void showBox(){
		for(int i=0;i<box.size();i++) {
			if(i==10) System.out.println(" ");
			System.out.print(box.get(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
package data_mining;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
	public static void main(String args[]) {
		ArrayList<Integer> ar=new ArrayList<Integer>();
		Scanner sc=new Scanner(System.in);	
		int n=3;
//		int n=sc.nextInt();
		while(sc.hasNextInt()) {
			ar.add(sc.nextInt());
		}
		Fenxiang fx=new Fenxiang(ar);
		fx.showData();
		System.out.println("");
		System.out.println("平均值平滑");
		fx.average(n);
		fx.showBox();
		System.out.println("");
		System.out.println("中值平滑");
		 fx.Mediam(n);
		 fx.showBox();
		 System.out.println("");
		 System.out.println("边界值平滑");
		
		fx.border(n);
		fx.showBorder(n);
		
		
//		test();
	}

}

发表于

poj 1001题

OUTPUT：

输入值为 R n
输出值为 R^n的具体数值

这个题在网上看见了一个很神奇的java代码，很清新，而且抱着试一试的心态通过了poj的text

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.math.*;
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            BigDecimal val=in.nextBigDecimal();
            int n=in.nextInt();
            BigDecimal ret=val.pow(n).stripTrailingZeros();
            System.out.println( ret.toPlainString().replaceAll("^0", "") );
        }
    }
}

其中toPlanString(),返回不带指数字段的字符串，replaceAll(“^0”,””),。这篇文章的作者有很强编程能力，现在用C语言去完成这个高精度计算。

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
48
49
50
51
52
53
54
55
56
  #include<iostream>
  #include<stdlib.h>
  #include<cstring>
  #define BUFSIZ 200
  using namespace std; 
  char * bigmul(char *m,int lena,char *f,int lenb){  //乘法运算函数。
     int i,j,k,lensum,tmp_result,carry,num='0';
     lensum=lena+lenb;                               //确定结果数组的长度。
     for(i=0;i<lena;i++){                            //将ASCII码转为对应的数字存储。
       m[i]=m[i]-num;
    }
    for(i=0;i<lenb;i++){
       f[i]=f[i]-num;
    }
    char *result,final[BUFSIZ];
    result=(char*)calloc(lensum,1);
    for(i=0;i<lenb;i++){
       //为被乘数作一趟乘法。
       for(j=0;j<lena;j++){
          tmp_result=f[lenb-i-1]*m[lena-j-1];
          result[j+i]+=tmp_result;
       }
       for(k=0;k<=j+i-1;k++){
       //每作一趟乘法整理一次结果数组。
          if(result[k]>9){
             carry=result[k]/10;
             result[k]=result[k]%10;
             result[k+1] += carry;
          }
       }
    }
    j=0;
    if(result[lensum-1]!=0){                  //去除前导零将结果整理到final数组中。
       final[j]=result[lensum-1]+num;
       j++;
    }
    for(i=lensum-2;i>=0;i--){
       final[j++]=result[i]+num;
    }
    result=final;                             //将指针指向final数组并返回该指针。      
    return result;
 }
 int main(){                                                 //利用main测试方法，用puts打印结果。               
    int lena,lenb;
    char *result,r[BUFSIZ];
    int n;
    while(cin>>r>>n){
    lena=strlen(r);
    lenb=strlen(r);
    result=r;
    for(int i=0;i<n;i++){
    result=bigmul(result,lenb,r,lena);
    }
    puts(result);
}
 }

关于大数运算，某朋友给我提供了一个代码，不过在我阅读代码后没有发现有小数位的计算。

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
string strMultiply(string str1 , string str2)  
{  
    string strResult = "";  
    int len1 = str1.length();   
    int len2 = str2.length();  
    int num[500] = {0};  
    int i = 0, j = 0;     
    for(i = 0; i < len1; i++)  
    {  
        for(j = 0; j < len2; j++)  
        {  
            num[len1-1 - i + len2-1 - j] += (str1[i] - '0')*(str2[j] - '0');   
        }  
    }  
    for(i = 0; i < len1 + len2; i++)  
    {  
        num[i+1] += num[i] / 10;  
        num[i] = num[i] % 10;  
    }  
    for(i = len1 + len2 - 1; i >= 0 ; i--)  
    {  
        if(0 != num[i]) break;  
    }  
    for(j = i; j >= 0; j--)  
    {  
        strResult += num[j] + '0';  
    }  
    return strResult;  
}

发表于

窗口

问题描述

　　在某图形操作系统中,有 N 个窗口,每个窗口都是一个两边与坐标轴分别平行的矩形区域。窗口的边界上的点也属于该窗口。窗口之间有层次的区别,在多于一个窗口重叠的区域里,只会显示位于顶层的窗口里的内容。
　　当你点击屏幕上一个点的时候,你就选择了处于被点击位置的最顶层窗口,并且这个窗口就会被移到所有窗口的最顶层,而剩余的窗口的层次顺序不变。如果你点击的位置不属于任何窗口,则系统会忽略你这次点击。
　　现在我们希望你写一个程序模拟点击窗口的过程。

输入格式

　　输入的第一行有两个正整数,即 N 和 M。(1 ≤ N ≤ 10,1 ≤ M ≤ 10)
　　接下来 N 行按照从最下层到最顶层的顺序给出 N 个窗口的位置。 每行包含四个非负整数 x1, y1, x2, y2,表示该窗口的一对顶点坐标分别为 (x1, y1) 和 (x2, y2)。保证 x1 < x2,y1 2。
　　接下来 M 行每行包含两个非负整数 x, y,表示一次鼠标点击的坐标。
　　题目中涉及到的所有点和矩形的顶点的 x, y 坐标分别不超过 2559 和　　1439。

输出格式

　　输出包括 M 行,每一行表示一次鼠标点击的结果。如果该次鼠标点击选择了一个窗口,则输出这个窗口的编号(窗口按照输入中的顺序从 1 编号到 N);如果没有,则输出”IGNORED”(不含双引号)。

样例输入

3 4
0 0 4 4
1 1 5 5
2 2 6 6
1 1
0 0
4 4
0 5

样例输出

2
1
1
IGNORED

样例说明

　　第一次点击的位置同时属于第 1 和第 2 个窗口,但是由于第 2 个窗口在上面,它被选择并且被置于顶层。
　　第二次点击的位置只属于第 1 个窗口,因此该次点击选择了此窗口并将其置于顶层。现在的三个窗口的层次关系与初始状态恰好相反了。
　　第三次点击的位置同时属于三个窗口的范围,但是由于现在第 1 个窗口处于顶层,它被选择。

　　最后点击的 (0, 5) 不属于任何窗口。

提交上去90分的代码，暂时不想改了，现在也蛮晚的。

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import java.util.Scanner;
/**
 * 201403-2
 * */
class window{
	int x1,y1,x2,y2;
	int level;
	int next;
	int beyond;	
}
class point{
	int x,y;
}
public class ccf005 {
public static void main(String args[]){
	Scanner s=new Scanner(System.in);
	window[] wins=new window[10];
	point[] p=new point[10];
	int n=s.nextInt();
	int m=s.nextInt();
	int head=n-1;
	for(int i=0;i<n;i++) {
		wins[i]=new window();
		wins[i].x1=s.nextInt();
		wins[i].y1=s.nextInt();
		wins[i].x2=s.nextInt();
		wins[i].y2=s.nextInt();
		wins[i].next=i-1;//next=-1时invilid
		wins[i].beyond=i+1;//beyond=+n时invilid
	}
	for(int i=0;i<m;i++) {
		p[i]=new point();
		p[i].x=s.nextInt();
		p[i].y=s.nextInt();
	}
	 for(int i=0;i<m;i++) {
		 int j=head;
//		 for(;wins[j].next>-1;j=wins[j].next) {
		 for(;;j=wins[j].next) {
			 if(j==-1)  {System.out.println("IGNORED");
			 break;}
			 if(p[i].x>=wins[j].x1&&p[i].x<=wins[j].x2&&p[i].y>=wins[j].y1&&p[i].y<=wins[j].y2)
			 {
				 if(wins[j].next==-1) {//最后一个页面
					 System.out.println(j+1);
					 wins[wins[j].beyond].next=-1;
					 wins[head].beyond=j;
					 wins[j].next=head;
					 wins[j].beyond=n;
					 head=j;
					 break;		 
				 }else if(wins[j].beyond==n) {//第一个页面
					 System.out.println(j+1);
					 break;
				 }else {
					 System.out.println(j+1);
					 wins[wins[j].beyond].next=wins[j].next;
					 wins[wins[j].next].beyond=wins[j].beyond;
					 wins[j].beyond=n;
					 wins[j].next=head;
					 wins[head].beyond=j;
					 head=j;
					 break;
				 }
			 }	
		 }
//		 if(wins[j].next==-1) {
//			 System.out.println("IGNORED");
//		 }
	 }
}
}

初次总结吧，这类问题真的要好好考虑边界值的问题。

在算法中模拟了双向链表的使用，然而结果并不能如我所愿，只有90分，认真思考过后没有发现那里出现问题。于是准备使用已经封装好的数组。

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
48
49
50
51
52
import java.awt.List;
import java.util.ArrayList;
import java.util.Scanner;
/**
 * 201403-2
 * */
class window{
	int x1,y1,x2,y2;
	int id;
	public boolean inside(int x,int y) {
		if(x>=this.x1&&x<=this.x2&&y>=this.y1&&y<=this.y2) {
			return true;
		}else {
			return false;
		}
	}
}
public class ccf005 {
public static void main(String args[]){
	Scanner s=new Scanner(System.in);
	ArrayList<window> w=new ArrayList<window>();
	int n=s.nextInt();
	int m=s.nextInt();
	int[] result=new int[10];
	for(int i=0;i<n;i++) {
		window wins=new window();
		wins.x1=s.nextInt();
		wins.y1=s.nextInt();
		wins.x2=s.nextInt();
		wins.y2=s.nextInt();
		wins.id=i+1;
		w.add(wins);
	}
	for(int i=0;i<m;i++) {
		int x=s.nextInt();
		int y=s.nextInt();
		for(int j=w.size()-1;j>=0;j--) {
			if(w.get(j).inside(x, y)) {
				result[i]=w.get(j).id;
				w.add(w.get(j));
				w.remove(j);
				break;
			}
		}
	}
	for(int i=0;i<m;i++) {
		if(result[i]==0)
			System.out.println("IGNORED");
		else System.out.println(result[i]);
	}
	 }
}

这份代码看起来效率是不如之前的代码好，但是相对来说结果正确，而且思路清晰，同样在评测的时候也是100分。

发表于

JAVA OJ中的常用算法总结（慢慢更）

参考博客：

Java在ACM算法竞赛编程中的易错点
[集合排序]（https://blog.csdn.net/hu_shengyang/article/details/6249309)

知识点总结

###声明一下这里的问题并不是很全

  1. 有关System.nanoTime()函数的使用，该函数用来返回最准确的可用系统计时器的当前值，以毫微秒为单位。

    1
    2
    3
    long startTime = System.nanoTime();  
    // ... the code being measured ...  
    long estimatedTime = System.nanoTime() - startTime;

  2. 标准的输入函数：

    1
    Scanner sc=new Scanner(System.in);

  3. 数组与集合的排序：
    如果要对数组排序，请使用java.util.Arrays.sort()方法.
    如果对list排序，请使用java.util.Collections.sort()方法.
    举个例子： 

    1
    2
    3
    4
       public ArrayList<Integer> sort(ArrayList<Integer> al) {
       Collections.sort(al);//对数组排序
        return al;
    }

  4. java单个字符型数转换成整数

    1
    2
    3
    4
    5
    6
    7
    public class Test {
        public static void main(String[] args) {
            char c = '4';
            int t = c - '0';
            System.out.println("char转换为数字: " + t);
        }
    }

5.String拆分成一位一位的char

1
2
3
4
5
6
7
8
9
10
11
12
public class Test_2
{
public static void main(String[] args)
{
String name = "CHINA";
char[] c = name.toCharArray();
for (int i = 0;i < c.length;i ++)
{
System.out.println(c[i]);
}
}
}

发表于

##根据多年无聊的本科程序类项目发现，正则表达式对于数据的提取有不可取代的作用，当然比起很多现成的ctrl+f完成的查找替换操作来说，正则表达式还算是一种superior的方法了哈哈哈。

###关于正则表达式的学习，首先我直接来完成正则表达式的书写，毕竟这个才是重中之重。

字符 说明
\ 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，”n”匹配字符”n”。”\n”匹配换行符。序列”\\“匹配”\“，”\(“匹配”(“。
^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与”\n”或”\r”之后的位置匹配。
\$ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与”\n”或”\r”之前的位置匹配。
* 零次或多次匹配前面的字符或子表达式。例如，zo 匹配”z”和”zoo”。 等效于 {0,}。
+ 一次或多次匹配前面的字符或子表达式。例如，”zo+”与”zo”和”zoo”匹配，但与”z”不匹配。+ 等效于 {1,}。
? 零次或一次匹配前面的字符或子表达式。例如，”do(es)?”匹配”do”或”does”中的”do”。? 等效于 {0,1}。
{n} n是非负整数。正好匹配 n 次。例如，”o{2}”与”Bob”中的”o”不匹配，但与”food”中的两个”o”匹配。
{n,} n是非负整数。至少匹配 n 次。例如，”o{2,}”不匹配”Bob”中的”o”，而匹配”foooood”中的所有 o。”o{1,}”等效于”o+”。”o{0,}”等效于”o*”。
{n,m} m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，”o{1,3}”匹配”fooooood”中的头三个 o。’o{0,1}’ 等效于 ‘o?’。注意：您不能将空格插入逗号和数字之间。
? 当此字符紧随任何其他限定符（、+、?、{n}、{n,}、{n,m*}）之后时，匹配模式是”非贪心的”。”非贪心的”模式匹配搜索到的、尽可能短的字符串，而默认的”贪心的”模式匹配搜索到的、尽可能长的字符串。例如，在字符串”oooo”中，”o+?”只匹配单个”o”，而”o+”匹配所有”o”。
. 匹配除”\r\n”之外的任何单个字符。若要匹配包括”\r\n”在内的任意字符，请使用诸如”[\s\S]”之类的模式。
(pattern) 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果”匹配”集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用”(“或者”)“。
(?:pattern) 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用”or”字符 (\ ) 组合模式部件的情况很有用。例如，’industr(?:y\ ies) 是比 ‘industry\ industries’ 更经济的表达式。
(?=pattern) 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，’Windows (?=95\ 98\ NT\ 2000)’ 匹配”Windows 2000”中的”Windows”，但不匹配”Windows 3.1”中的”Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern) 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，’Windows (?!95\ 98\ NT\ 2000)’ 匹配”Windows 3.1”中的 “Windows”，但不匹配”Windows 2000”中的”Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
x\ y 匹配 x 或 y。例如，’z\ food’ 匹配”z”或”food”。’(z\ f)ood’ 匹配”zood”或”food”。
[xyz] 字符集。匹配包含的任一字符。例如，”[abc]”匹配”plain”中的”a”。
[^xyz] 反向字符集。匹配未包含的任何字符。例如，”[^abc]”匹配”plain”中”p”，”l”，”i”，”n”。
[a-z] 字符范围。匹配指定范围内的任何字符。例如，”[a-z]”匹配”a”到”z”范围内的任何小写字母。
[^a-z] 反向范围字符。匹配不在指定的范围内的任何字符。例如，”[^a-z]”匹配任何不在”a”到”z”范围内的任何字符。
\b 匹配一个字边界，即字与空格间的位置。例如，”er\b”匹配”never”中的”er”，但不匹配”verb”中的”er”。
\B 非字边界匹配。”er\B”匹配”verb”中的”er”，但不匹配”never”中的”er”。
\cx 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是”c”字符本身。
\d 数字字符匹配。等效于 [0-9]。
\D 非数字字符匹配。等效于 [^0-9]。
\f 换页符匹配。等效于 \x0c 和 \cL。
\n 换行符匹配。等效于 \x0a 和 \cJ。
\r 匹配一个回车符。等效于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\t 制表符匹配。与 \x09 和 \cI 等效。
\v 垂直制表符匹配。与 \x0b 和 \cK 等效。
\w 匹配任何字类字符，包括下划线。与”[A-Za-z0-9_]”等效。
\W 与任何非单词字符匹配。与”[^A-Za-z0-9_]”等效。
\xn 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，”\x41”匹配”A”。”\x041”与”\x04”&”1”等效。允许在正则表达式中使用 ASCII 代码。
\num 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，”(.)\1”匹配两个连续的相同字符。
\n 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
\nm 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
\nml 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
\un 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。

发表于

本博客的搭建

我写这个博客，一方面是之前写过的很多东西保存效果不好，就是很多知识点放很长时间之后就会遗忘，回过头来去寻找知识点的时候效率很低。所以希望通过博客这种方式记录下自己从今开始的点点滴滴。
为什么自己要很麻烦的去搭建博客，而不是在简书上或者CSDN等地方直接去建个账号写博客；关于这个问题，我只是想说，用HEXO搭建的博客，真的是很方便！而且通过与github相连，访问博客也异常容易！自己随时可以去参考自己写过的东西，反反复复的看效率会很高。
熟悉git操作的人都会知道git是一款很强大的工具，加上hexo，文章可以轻轻易易的书写，保存在本地仓库，只需要在cmd上运行很简单的操作，即可生成代码并且上传到github上，方便自己随时查看。
当然这个博客写完之后，我也会发现有很多不足的地方，从算法开始写起，很多地方因为是自己的原创，导致质量不高；当然除了自己之外，也希望大家可以当做参考。
搭建博客并不是一件很困难的事情，当然需要对一些工具有一定的了解，git、github,markdown，这两个是主要的，包括SSH，以及公钥和私钥的设置。以及很有耐心的慢慢去调试博客，以及设置主题。
这个博客搭建到现在有很多不完美的地方，也会慢慢去改正，以及很多页面问题，等博客质量上来之后，会去慢慢修改这些问题，完善它。
hexo+github
以上是搭建博客时我参考的文章，当然网上也有很多类似，共大家参考、
建博客不是为了暴力抄袭，关于一些不熟悉的知识，我可能会自己在博客写（抄）一遍，这样会加深我的记忆，日后也方便我去查看自己的资料。
关于域名：至今因为博客质量不高，而且并没有什么更长远的目标，所以不打算在万网租用域名，就暂时挂用github的公共域。

发表于

关于本博客声明

之前写的一些技术文章丢失，虽说语法不成熟而且很多意义上只有我自己可以看明白，因为比较讨厌从网站上直接暴力抄袭，或者因为自己的时间原因懒得去搭建图床和仔细编辑语言去写。不过，既然建了这个博客，还是慢慢去更吧。

版权声明

在文章中的引用导致版权侵犯问题以及一些其他可能会出现的问题，请将意见信息发至 markzhang4438@gmail.com，博主会马上处理问题

发表于

这个错误代码一般情况下是因为安装的jdk版本与系统位数不服。

因为我的电脑中有两个eclipse，所以在一次系统更新中，一个eclipse(neon)弹出code13，另一个eclipse(oxygen)弹出code1，两个摸不到头脑的原因，我查看了系统变量中java_home,发现java_home的路径的jdk消失了，仔细回想可能导致jdk自动消失的原因是jdk的一次更新，然后在运行界面输入

java -version，查询到jdk自动更新之后在电脑上变成32位，在网上查询资料，这种情况只能重新安装jdk。

造成原因：大多情况因为jdk自己自动更新导致，如果是第一次出现eclipse弹出错误代码，可能是安装eclipse出现问题。

解决方案：将jdk重新下载，在系统变量中重新设置java_home。