public class RegexHarnessTest
{
public static void main(String args[])
{
String[] regex = {"([\u4E00-\u9FA5]+,?)+",
"\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}",
"\\d{4}[A-Z]{2}",
"[0-9]{1.3}"};
String[] input = {"开发高手,程序员的朋友,开发者的助手",
"IP:71.42.164.8,192.168.1.1,7.78.3.221",
"美国汽车牌照:3456MW,12345M,6789NY",
"数字:345,678"};
RegexHarness rh = new RegexHarness();
for(int i=0;i<regex.length;i++)
{
rh.setRegex(regex[i]);
rh.setInput(input[i]);
if(rh.initialize())
{
System.out.println("\n-----匹配方式：全文匹配，方法：matches调用开始-----\n");
rh.validateEntireText();
System.out.println(rh.getResults());
System.out.println("\n-----匹配方式：全文匹配，方法：matches调用结束-----\n");
System.out.println("\n-----匹配方式：部分匹配，方法：find调用开始-----\n");
rh.validatePartText();
System.out.println(rh.getResults());
System.out.println("\n-----匹配方式：部分匹配，方法：find调用结束-----\n");
}
else
{
System.out.println(rh.getRegexError());
}
}
System.exit(0);
}
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
public class RegexHarness
{
/**regex表示正则表达式，input表示要匹配或验证的文本或字符串*/
private String regex="",input="";
/**regexError表示当正则表达式出现语法错误时，相关的错误信息
* results表示匹配后的结果*/
private String regexError="",results="";
private Pattern pattern;
private Matcher matcher;
public RegexHarness()
{
this("","");
}
public RegexHarness(String regex,String input)
{
setRegex(regex);
setInput(input);
}
/**
* 初始化
* @return
*/
public boolean initialize()
{
try
{
/*
* 使用Pattern类的静态compile方法，接收一个代表正则
* 表达式的字符串(变量:regex)的参数，并返回一个指定的
* 正则表达式的Pattern对象的pattern
*/
pattern = Pattern.compile(regex);
/*
* 利用刚刚返回的Pattern类的实例pattern，并调用pattern
* 的matcher方法。该方法接收一个用于匹配的实现了CharSequence
* 接口的对象input，并将返回一个Matcher对象赋值给变量matcher。
*/
matcher = pattern.matcher(input);
return true;
}
catch (PatternSyntaxException pse) {
regexError = "\n正则表达式语法错误！错误的相关信息如下：" +
"\n当前的正则表达式是：" + pse.getPattern() +
"\n错误描述：" + pse.getDescription() +
"\n错误信息：" + pse.getMessage() +
"\n错误索引：" + pse.getIndex();
return false;
}
}
/**
* 根据正则表达式来匹配输入的整个文本，并得到匹配结果<br>
* 本方法不返回任何数据，先调用matcher的方法matches，
* matches方法根据给定的正则表达式来匹配的整个文本。
* 如果整个文本都匹配给定的正则表达式，就调用matcher的
* group方法，该方法返回与查找模式相匹配的查找对象的字符
* 串，并将得到的匹配文本再赋值给字符串变量results，返回
* 真值。
*/
public void validateEntireText()
{
boolean findMathText = false;
results = "当前的正则表达式是：" + regex +
"\n当前匹配的文本是：" + input + "\n\n";
if(matcher.matches())
{
results += "找到全文匹配的文本\"" + matcher.group() + "\"。\n";
findMathText = true;
}
if(!findMathText)
{
results += "没有发现全文匹配的文本。\n";
}
}
/**
* 根据正则表达式来匹配输入的部分文本，并得到匹配结果<br>
* 本方法不返回任何数据，但是调用的是matcher的方法find,
* find方法根据给定的正则表达式来匹配的文本中的子字符串。
* 和matches方法不同之处在于，只有被匹配的文本中的部分内容
* 符合给定的正则表达式时，find方法才返回真值。
*/
public void validatePartText()
{
boolean findMathText = false;
results = "当前的正则表达式是：" + regex +
"\n当前匹配的文本是：" + input + "\n\n";
while(matcher.find())
{
results += "找到部分匹配的文本\"" + matcher.group()+
"\"\t起始索引：" + matcher.start() +
"\t结束索引：" + matcher.end() + "。\n";
findMathText = true;
}
if(!findMathText)
{
results += "没有发现部分匹配的文本。\n";
}
}
public String getResults()
{
return this.results;
}
public String getRegexError()
{
return this.regexError;
}
public void setRegex(String regex)
{
this.regex = regex;
}
public void setInput(String input)
{
this.input = input;
}
}
import javax.swing.JOptionPane;
public class RegexStringReplace
{
public static void main(String args[])
{
String originalString = "This is 哈哈 JAVA code* * * * *";
String output = "原始字符串："+ originalString;
//替换'*' 为 '^'
originalString = originalString.replaceAll("\\*", "^ ");
output+="\n*被替换成^ 后的字符串："+originalString;
//替换'哈哈'为'HaHa's'
originalString = originalString.replaceAll("哈哈", "HaHa's");
output+="\n\"哈哈\"替换成\"HaHa's\":"+originalString;
//将字符串中的每个单词都替换成"word"
output+="\n每个单词都替换成\"word\":"+originalString.replaceAll("\\w+", "word");
JOptionPane.showMessageDialog(null, output,"Java正则表达式例子",JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
import javax.swing.JOptionPane;
public class RegexStringReplaceFirstAndSplit
{
public static void main(String args[])
{
String originalString="1, one, 2, two, 3, three, 4, four, 5, five";
String output = "原始字符串：\n" + originalString;
//迭代3次，将字符串中第一次出现的数字替换成字符串'dight'
for(int i=0;i<3;i++)
{
originalString = originalString.replaceFirst("\\d", "digit");
}
output += "\n头三个数字被替换成\"digit\"后的字符串：\n" + originalString;
//分隔出现逗号的子字符串，逗号后面可以匹配任意的空白字符
String[] result = originalString.split(",\\s*");
output +="\n字符串依据逗号来分割后的结果";
for(int i=0;i<result.length;i++)
{
output+="\n"+result[i];
}
JOptionPane.showMessageDialog(null, output,"java正则表达式",JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
import java.awt.Container;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class RegexStringTest extends JFrame
{
private static final long serialVersionUID = -1564020173888781534L;
private JTextField phoneTextField;
private JTextField zipTextField;
private JTextField addressTextField;
private JTextField firstTextField;
private JTextField lastTextField;
private JTextField chineseTextField;
private Font songTi = new Font("宋体",Font.PLAIN,12);
public RegexStringTest()
{
super("基于字符串的正则表达式");
//创建图形界面
JLabel phoneLabel = new JLabel("电话");
phoneLabel.setFont(songTi);
JLabel zipLabel = new JLabel("邮政编码");
zipLabel.setFont(songTi);
JLabel addressLabel = new JLabel("通信地址");
addressLabel.setFont(songTi);
JLabel firstLabel = new JLabel("First Name:(英文,第一个字母必须大写)");
firstLabel.setFont(songTi);
JLabel lastLabel = new JLabel("Last Name:(英文,第一个字母必须大写)");
lastLabel.setFont(songTi);
JLabel chineseLabel = new JLabel("中文");
chineseLabel.setFont(songTi);
JButton okButton = new JButton("验证");
okButton.setFont(songTi);
okButton.addActionListener(new ActionListener()
{
//内部类开始
public void actionPerformed(ActionEvent e) {
validateDate();
}//内部类结束
});//调用addActionListener结束
phoneTextField = new JTextField(15);
zipTextField = new JTextField(6);
addressTextField = new JTextField(35);
firstTextField = new JTextField(20);
lastTextField = new JTextField(20);
chineseTextField = new JTextField(30);
JPanel firstName = new JPanel();
firstName.add(firstLabel);
firstName.add(firstTextField);
JPanel lastName = new JPanel();
lastName.add(lastLabel);
lastName.add(lastTextField);
JPanel address = new JPanel();
address.add(addressLabel);
address.add(addressTextField);
JPanel zipAndPhone = new JPanel();
zipAndPhone.add(zipLabel);
zipAndPhone.add(zipTextField);
zipAndPhone.add(phoneLabel);
zipAndPhone.add(phoneTextField);
JPanel chinese = new JPanel();
chinese.add(chineseLabel);
chinese.add(chineseTextField);
JPanel ok = new JPanel();
ok.add(okButton);
//把GUI部件添加在容器中
Container container = getContentPane();
container.setLayout(new GridLayout(6,1));
container.add(firstName);
container.add(lastName);
container.add(address);
container.add(zipAndPhone);
container.add(chinese);
container.add(ok);
pack();
setVisible(true);
}//RegexStringTest构造器结束
public static void main(String args[])
{
RegexStringTest application = new RegexStringTest();
application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
/**
* 处理鼠标点击事件
*/
private void validateDate()
{
//确保每个文本框不为空
if(lastTextField.getText().equals("") ||
firstTextField.getText().equals("")||
addressTextField.getText().equals("")||
zipTextField.getText().equals("")||
phoneTextField.getText().equals("")||
chineseTextField.getText().equals(""))
{
JOptionPane.showMessageDialog(this, "每个栏目都必须填写");
}
else if(!firstTextField.getText().matches("[A-Z][a-zA-Z]*"))
{//验证First Name是不是以大写字母的一个英文单词
/*
* [A-Z]匹配单个大写字母，其后面的[a-zA-Z]*表示可以匹配任意数目的
* 字母。通常，在正则表达式中出现运算符(量词)"*"的时候，程序将匹配
* "*"前的0个或多个子表达式。同理，"A*"和"A+"都与"A"匹配，但"A*"
* 还可以匹配一个空的字符串。
*/
JOptionPane.showMessageDialog(this, "First Name非法");
}
else if(!lastTextField.getText().matches("[A-Z][a-zA-Z]*"))
{//验证Last Name是不是以大写字母开头的一个英文单词
JOptionPane.showMessageDialog(this, "Last Name非法");
}
else if(!addressTextField.getText().matches("\\d+\\s+([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)"))
{//验证地址是否为数字开始，并包含一个单词或者两个单词
/*
* 这里的地址格式是西方的格式，也就是门牌号在前，街名在后。
* \\d+\\s+([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)
* 首先是匹配任意的数字(\\d+),"\d"是表示数字字符，这里之所以要加上一个"\"
* 是因为"\"在Java中是作用转义字符的。所以这里的"\\d"就正好表示正则表达
* 式中的"\d"。然后，继续验证数字后面是否至少有一个空白字符(\\s+)。字符
* "|"将表达式与其左边或者右边的字符串相匹配。如：Hello(Tom|Rich)就和
* Hello Tom以及Hello Rich相匹配。括号用于将正则表达式的各个部分连接
* 起来。这里字符"|"左边([a-zA-Z]+)匹配一个单词，而右边
* ([a-zA-Z]+\\s[a-zA-Z]+)匹配两个单词，注意两个单词之间只能有一个空白
* 字符(\\s)。因此，这里如果用户输入"123 Main"或者"123 Main Street"
* 都是有效的。
*/
JOptionPane.showMessageDialog(this, "地址非法");
}
else if(!zipTextField.getText().matches("\\d{5}"))
{//验证邮政编码是否为一个5位数的数字
/*
* "\\d{5}"表明邮政编码匹配5个数字。另外可以用其他写法实现相同的功能
* 如："[0-9]{5}"
*/
JOptionPane.showMessageDialog(this, "邮政编码非法");
}
else if(!phoneTextField.getText().matches("[1-9]\\d{2}-[1-9]\\d{2}-\\d{4}"))
{//验证电话号码格式是否为123-456-7890并且区号和电话号码的第一位不能是数字0
/*
* [1-9]\\d{2}-[1-9]\\d{2}-\\d{4}
* 本例采用的美国的电话号码形式，如123-456-7890，即头三位数字为区号
* ，之后紧跟一个短横线，接着是电话号码的头三位，之后又是一个短横线，
* 最后是电话号码的最后四位数。注意这里"[1-9]\\d{2}"表示匹配一个3位
* 数的数字，但其第一个数字不能为0.如果希望123-4567890这种格式的电话
* 号码也合法，可以修改"[1-9]\\d{2}-[1-9]\\d{2}-?\\d{4}"
* 我们在第2个短横线后加一个"?"号，表示"-"可以出现，也可以不出现。
*/
JOptionPane.showMessageDialog(this, "非法的电话号码");
}
else if(!chineseTextField.getText().matches("[\u4E00-\u9FA5]+"))
{
/*
* [\u4E00-\u9FA5]+，验证了用户输入的数据是否全部为中文字符。
*/
JOptionPane.showMessageDialog(this, "只能输入中文");
}
else
{
JOptionPane.showMessageDialog(this, "谢谢，您输入的完全合法");
}
}
}
