Skip to content

Commit e0e4246

Browse files
gitkinggitking
committed
ss
1 parent 1977dac commit e0e4246

File tree

6 files changed

+166
-0
lines changed

6 files changed

+166
-0
lines changed

‎src/com/yale/test/junit/Calculator.java

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
package com.yale.test.junit;
2+
3+
public class Calculator {
4+
private long n = 0;
5+
6+
public long add(long x) {
7+
n = n + x;
8+
return n;
9+
}
10+
11+
public long sub(long x) {
12+
n = n - x;
13+
return n;
14+
}
15+
}

‎src/com/yale/test/junit/Config.java

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
package com.yale.test.junit;
2+
3+
public class Config {
4+
public static String getConfigFile(String filename) {
5+
String os = System.getProperty("os.name").toLowerCase();
6+
if (os.contains("win")) {
7+
return "C:\\" + filename;
8+
}
9+
if (os.contains("mac") || os.contains("linux") || os.contains("unix")) {
10+
return "/usr/local/" + filename;
11+
}
12+
throw new UnsupportedOperationException();
13+
}
14+
}

‎src/com/yale/test/leetcode/Factorial.java

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,9 @@ public static void main(String[] args) {
1414
}
1515

1616
public static long factorial(long number) {
17+
if (number < 0) {//为了junit测试才加的这行代码
18+
throw new IllegalArgumentException();
19+
}
1720
if (number<=1) {
1821
return 1;
1922
} else {

‎src/com/yale/test/ps/Base64Test.java

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,16 @@
22

33
import java.util.Base64;
44

5+
/*
6+
* 在计算机系统中，什么是加密与安全呢？
7+
* 我们举个栗子：假设Bob要给Alice发一封邮件，在邮件传送的过程中，黑客可能会窃取到邮件的内容，所以需要防窃听。黑客还可能会篡改邮件的内容，Alice必须有能力识别出邮件有没有被篡改。最后，黑客可能假冒Bob给Alice发邮件，Alice必须有能力识别出伪造的邮件。
8+
* 所以，应对潜在的安全威胁，需要做到三防：1,防窃听2,防篡改3,防伪造
9+
* 计算机加密技术就是为了实现上述目标，而现代计算机密码学理论是建立在严格的数学理论基础上的，密码学已经逐渐发展成一门科学。
10+
* 对于绝大多数开发者来说，设计一个安全的加密算法非常困难，验证一个加密算法是否安全更加困难，当前被认为安全的加密算法仅仅是迄今为止尚未被攻破。因此，要编写安全的计算机程序，我们要做到：
11+
* 不要自己设计山寨的加密算法；
12+
* 不要自己实现已有的加密算法；
13+
* 不要自己修改已有的加密算法。
14+
*/
515
public class Base64Test {
616

717
public static void main(String[] args) {

‎src/com/yale/test/regex/RegexTest.java

Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
package com.yale.test.regex;
22

3+
import java.util.regex.Matcher;
4+
import java.util.regex.Pattern;
5+
36
public class RegexTest {
47
public static void main(String[] args) {
58
System.out.println("abc是数字吗? == " + isNumber("abc"));
@@ -9,7 +12,114 @@ public static void main(String[] args) {
912
System.out.println("abc".matches("\\d+"));
1013
System.out.println("1230".matches("\\d+"));
1114

15+
String regex = "20\\d\\d";
16+
//年份是否是20##年
17+
System.out.println("2019".matches(regex)); // true
18+
System.out.println("2100".matches(regex)); // false
19+
1220
System.out.println("java.util是JAVA的一个工具包,可以研究一下");
21+
22+
/*
23+
* -这个字符在正则表达式里面也是一个特殊字符,所以需要转义,但其实这里不转义也行
24+
*/
25+
Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
26+
Matcher m = p.matcher("010-12345678");
27+
if (m.matches()) {
28+
String g0 = m.group(0);
29+
System.out.println("整个字符串:" + g0);
30+
String g1 = m.group(1);
31+
String g2 = m.group(2);
32+
System.out.println(g1);
33+
System.out.println(g2);
34+
} else {
35+
System.out.println("匹配失败!");
36+
}
37+
38+
/*
39+
* 在介绍非贪婪匹配前，我们先看一个简单的问题：
40+
* 给定一个字符串表示的数字，判断该数字末尾0的个数。例如：
41+
* "123000"：3个0
42+
* "10100"：2个0
43+
* "1001"：0个0
44+
* 可以很容易地写出该正则表达式：(\d+)(0*)，Java代码如下：
45+
*/
46+
Pattern pattern = Pattern.compile("(\\d+)(0*)");
47+
Matcher matcher = pattern.matcher("1230000");
48+
if (matcher.matches()) {
49+
System.out.println("group1=" + matcher.group(1)); // "1230000"
50+
System.out.println("group2=" + matcher.group(2)); // ""
51+
52+
System.out.println("仔细观察上述实际匹配结果，实际上它是完全合理的，因为\\d+确实可以匹配后面任意个0。");
53+
System.out.println("这是因为正则表达式默认使用贪婪匹配：任何一个规则，它总是尽可能多地向后匹配，因此，\\d+总是会把后面的0包含进来。");
54+
System.out.println("要让\\d+尽量少匹配，让0*尽量多匹配，我们就必须让\\d+使用非贪婪匹配。在规则\\d+后面加个?即可表示非贪婪匹配。我们改写正则表达式如下：");
55+
}
56+
57+
58+
Pattern pattern1 = Pattern.compile("(\\d+?)(0*)");//因此，给定一个匹配规则，加上?后就变成了非贪婪匹配。
59+
Matcher matcher1 = pattern1.matcher("1230000");
60+
if (matcher1.matches()) {
61+
System.out.println("group1=" + matcher1.group(1)); // "1230000"
62+
System.out.println("group2=" + matcher1.group(2)); // ""
63+
64+
System.out.println("仔细观察上述实际匹配结果，实际上它是完全合理的，因为\\d+确实可以匹配后面任意个0。");
65+
System.out.println("这是因为正则表达式默认使用贪婪匹配：任何一个规则，它总是尽可能多地向后匹配，因此，\\d+总是会把后面的0包含进来。");
66+
System.out.println("要让\\d+尽量少匹配，让0*尽量多匹配，我们就必须让\\d+使用非贪婪匹配。在规则\\d+后面加个?即可表示非贪婪匹配。我们改写正则表达式如下：");
67+
}
68+
69+
/*
70+
* 我们再来看这个正则表达式(\d??)(9*)，注意\d?表示匹配0个或1个数字，后面第二个?表示非贪婪匹配，因此，给定字符串"9999"，匹配到的两个子串分别是""和"9999"，
71+
* 因为对于\d?来说，可以匹配1个9，也可以匹配0个9，但是因为后面的?表示非贪婪匹配，它就会尽可能少的匹配，结果是匹配了0个9。
72+
*/
73+
Pattern pattern2 = Pattern.compile("(\\d??)(9*)");
74+
Matcher matcher2 = pattern2.matcher("9999");
75+
if (matcher2.matches()) {
76+
System.out.println("group1=" + matcher2.group(1)); // "1230000"
77+
System.out.println("group2=" + matcher2.group(2)); // ""
78+
}
79+
80+
/*
81+
* 搜索和替换
82+
* 分割字符串
83+
* 使用正则表达式分割字符串可以实现更加灵活的功能。String.split()方法传入的正是正则表达式。我们来看下面的代码：
84+
*/
85+
86+
System.out.println("a b c".split("\\s").toString()); // { "a", "b", "c" });
87+
System.out.println("a b c".split("\\s").toString()); // { "a", "b", "", "c" }
88+
System.out.println("a, b ;; c".split("[\\,\\;\\s]+").toString()); // { "a", "b", "c" }
89+
90+
91+
/**
92+
* 如果我们想让用户输入一组标签，然后把标签提取出来，因为用户的输入往往是不规范的，这时，使用合适的正则表达式，就可以消除多个空格、混合,和;这些不规范的输入，直接提取出规范的字符串。
93+
* 搜索字符串
94+
* 使用正则表达式还可以搜索字符串，我们来看例子：
95+
* 我们获取到Matcher对象后，不需要调用matches()方法（因为匹配整个串肯定返回false），而是反复调用find()方法，在整个串中搜索能匹配上\\wo\\w规则的子串，并打印出来。
96+
* 这种方式比String.indexOf()要灵活得多，因为我们搜索的规则是3个字符：中间必须是o，前后两个必须是字符[A-Za-z0-9_]。
97+
*/
98+
String s = "the quick brown fox jumps over the lazy dog.";
99+
Pattern pp = Pattern.compile("\\wo\\w");
100+
Matcher mf = pp.matcher(s);
101+
while (mf.find()) {
102+
String sub = s.substring(mf.start(), mf.end());
103+
System.out.println(sub);
104+
}
105+
106+
/*
107+
* 替换字符串
108+
* 使用正则表达式替换字符串可以直接调用String.replaceAll()，它的第一个参数是正则表达式，第二个参数是待替换的字符串。我们还是来看例子：
109+
* 下面的代码把不规范的连续空格分隔的句子变成了规范的句子。可见，灵活使用正则表达式可以大大降低代码量。
110+
*/
111+
String sr = "The quick\t\t brown fox jumps over the lazy dog.";
112+
String r = sr.replaceAll("\\s+", " ");
113+
System.out.println(r); // "The quick brown fox jumps over the lazy dog."
114+
System.out.println("#############反向引用###########");
115+
/*
116+
* 反向引用
117+
* 如果我们要把搜索到的指定字符串按规则替换，比如前后各加一个<b>xxxx</b>，这个时候，使用replaceAll()的时候，
118+
* 我们传入的第二个参数可以使用$1、$2来反向引用匹配到的子串。例如：
119+
*/
120+
String ssr = "the quick brown fox jumps over the lazy dog.";
121+
String rss = ssr.replaceAll("\\s([a-z]{4})\\s", " <b>$1</b> ");
122+
System.out.println(rss);
13123
}
14124

15125
public static boolean isNumber (String str) {

‎src/com/yale/test/regex/RegexTestEg.java

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,11 @@
1010
* https://www.cnblogs.com/deerchao/archive/2006/08/24/zhengzhe30fengzhongjiaocheng.html
1111
* 【强制】在使用正则表达式时，利用好其预编译功能，可以有效加快正则匹配速度。
1212
* 说明：不要在方法体内定义：Pattern pattern = Pattern.compile(“规则”);《阿里巴巴Java开发手册（泰山版）.
13+
* 正则表达式的匹配规则是从左到右按规则匹配。我们首先来看如何使用正则表达式来做精确匹配。
14+
* 如果正则表达式有特殊字符，那就需要用\转义。例如，正则表达式a\&c，其中\&是用来匹配特殊字符&的，它能精确匹配字符串"a&c"，但不能匹配"ac"、"a-c"、"a&&c"等。
15+
* 要注意正则表达式在Java代码中也是一个字符串，所以，对于正则表达式a\&c来说，对应的Java字符串是"a\\&c"，因为\也是Java字符串的转义字符，两个\\实际上表示的是一个\：
16+
* 如果想匹配非ASCII字符，例如中文，那就用\\u####的十六进制表示，例如：a\u548cc匹配字符串"a和c"，中文字符和的Unicode编码是548c。
17+
* 精确匹配实际上用处不大，因为我们直接用String.equals()就可以做到。大多数情况下，我们想要的匹配规则更多的是模糊匹配。我们可以用.匹配一个任意字符。
1318
* @author lenovo
1419
*/
1520
public class RegexTestEg {
@@ -112,6 +117,12 @@ public static void main(String[] args) throws ParseException {
112117
}
113118
System.out.println("对开发者而言,正则的重大意义在于字符串的组成验证处理上");
114119

120+
/*
121+
* 我们在前面的代码中用到的正则表达式代码是String.matches()方法，而我们在分组提取的代码中用的是java.util.regex包里面的Pattern类和Matcher类。
122+
* 实际上这两种代码本质上是一样的，因为String.matches()方法内部调用的就是Pattern和Matcher类的方法。
123+
* 但是反复使用String.matches()对同一个正则表达式进行多次匹配效率较低，因为每次都会创建出一样的Pattern对象。
124+
* 完全可以先创建出一个Pattern对象，然后反复使用，就可以实现编译一次，多次匹配：
125+
*/
115126
System.out.println("JDK1.4里面增加了一个开发包java.uti.regex,但是在这个包里面只有俩个类:Pattern类,Matcher类.Pattern类负责编译正则,"
116127
+ "而Matcher负责进行正则匹配.如果要做一般的处理,使用String类即可.");
117128

@@ -138,5 +149,8 @@ public static void main(String[] args) throws ParseException {
138149
while (matcher.find()) {
139150
System.out.println(matcher.group(0));
140151
}
152+
153+
System.out.println("正则表达式匹配中文:");
154+
System.out.println("a\u548cc".equals("a和c"));
141155
}
142156
}

0 commit comments

Comments
 (0)