基于Java實現(xiàn)中文分詞系統(tǒng)的示例代碼
更新時間：2022年07月08日 10:22:58 作者：biyezuopinvip
這篇文章主要為大家詳細介紹了如何利用Java語言實現(xiàn)一個簡易的中文分詞系統(tǒng)，文中的示例代碼講解詳細，感興趣的小伙伴可以嘗試一下
1.問題描述
中文分詞 (Chinese Word Segmentation) 指的是將一個漢字序列切分成一個一個單獨的詞。分詞就是將連續(xù)的字序列按照一定的規(guī)范重新組合成詞序列的過程。我們知道，在英文的行文中，單詞之間是以空格作為自然分界符的，而中文只是字、句和段能通過明顯的分界符來簡單劃界，唯獨詞沒有一個形式上的分界符，雖然英文也同樣存在短語的劃分問題，不過在詞這一層上，中文比之英文要復雜的多、困難的多。
而對于中文分詞也有很多種算法，基本算法主要分為基于詞典的方法、基于統(tǒng)計的方法和基于規(guī)則的方法。
基于詞典的方法是指按照一定策略將待分析的漢字串與一個“大機器詞典”中的詞條進行匹配，若在詞典中找到某個字符串，則匹配成功。按照掃描方向的不同包括正向匹配和逆向匹配，按照長度的不同分為最大匹配和最小匹配。在基于詞典的方法中，我們采用了正向最大匹配和逆向最大匹配的方法進行分詞。
而基于統(tǒng)計的分詞方法，沒有詞典，主要思想是在上下文中，相鄰的字同時出現(xiàn)的次數(shù)越多，就越可能構成一個詞，因此字與字相鄰出現(xiàn)的概率或頻率能較好的反映詞的可信度。主要的統(tǒng)計模型包括N元文法模型(N-gram)，隱馬爾科夫模型(Hidden Markov Model, HMM)。在基于統(tǒng)計的分詞方法中，我們使用了隱馬爾科夫模型來進行分詞。
基于規(guī)則的方法，主要思想就是通過模擬人對句子的理解，達到識別詞的效果，基本思想是語義分析，句法分析，利用句法信息和語義信息對文本進行分詞。自動推理，并完成對未登錄詞的補充是其優(yōu)點。但是這種方法現(xiàn)在發(fā)展還不成熟，需要繼續(xù)發(fā)展和研究。
因此在我們的中文分詞系統(tǒng)中，采用了基于詞典的方法：正向最大匹配和逆向最大匹配，以及基于統(tǒng)計的方法中的隱馬爾科夫(HMM)模型。
2.相關工作
現(xiàn)如今已經(jīng)有很多的開源中分分詞系統(tǒng)，而且效果都還不錯。下面介紹幾種比較常見的中文分詞項目。
SCWS，Hightman開發(fā)的一套基于詞頻詞典的機械中文分詞引擎，它能將一整段的漢字基本正確的切分成詞。采用的是采集的詞頻詞典，并輔以一定的專有名稱，人名，地名，數(shù)字年代等規(guī)則識別來達到基本分詞，經(jīng)小范圍測試大概準確率在 90% ~ 95% 之間，已能基本滿足一些小型搜索引擎、關鍵字提取等場合運用。45Kb左右的文本切詞時間是0.026秒，大概是1.5MB文本/秒，支持PHP4和PHP 5。
ICTCLAS，這是最早的中文開源分詞項目之一，ICTCLAS在國內(nèi)973專家組組織的評測中活動獲得了第一名，在第一屆國際中文處理研究機構SigHan組織的評測中都獲得了多項第一名。ICTCLAS3.0分詞速度單機996KB/s，分詞精度98.45%，API不超過200KB，各種詞典數(shù)據(jù)壓縮后不到3M。ICTCLAS全部采用C/C++編寫，支持Linux、FreeBSD及Windows系列操作系統(tǒng)，支持C/C++、C#、Delphi、Java等主流的開發(fā)語言。
HTTPCWS，是一款基于HTTP協(xié)議的開源中文分詞系統(tǒng)，目前僅支持Linux系統(tǒng)。HTTPCWS 使用“ICTCLAS 3.0 2009共享版中文分詞算法”的API進行分詞處理，得出分詞結果。HTTPCWS 將取代之前的 PHPCWS 中文分詞擴展。
3.系統(tǒng)框架和算法設計
3.1系統(tǒng)整體框架
系統(tǒng)主要包括選擇分詞算法和進行數(shù)據(jù)的測試。首先需要選擇進行分詞的算法，包括基于HMM模型的分詞算法，正向最大匹配分詞算法和逆向最大匹配分詞算法。選擇了分詞算法之后即可進行分詞操作。
若選擇的是基于HMM模型的分詞算法，需要先進行訓練集的訓練，得到訓練的統(tǒng)計數(shù)據(jù)，然后再進行數(shù)據(jù)測試。數(shù)據(jù)測試包括了文件輸入測試，進行大規(guī)模數(shù)據(jù)的測試，也包括了直接輸入測試，測試一句話或多句話進行簡單測試。
對于正向最大匹配和逆向最大匹配則不需要進行訓練集的訓練，因為其是基于詞典的方法，需要詞典，而詞典我們已經(jīng)事先載入程序中了。正向最大匹配和逆向最大匹配也包括了文件輸入測試和直接輸入測試。
系統(tǒng)的整體框架如圖3-1所示。
部分代碼如下：
package mainframe;
import hmm.hmmmain.hmmmain;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.StringTokenizer;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.EtchedBorder;
import javax.swing.border.TitledBorder;
import lexicon.Segment;
@SuppressWarnings("serial")
public class CWS_frame extends JFrame{
//定義組件
JLabel label_title=new JLabel("CWJT中文分詞系統(tǒng)");
JPanel algorithm_select_panel;
JRadioButton algorithm_jrb_hmm;
JRadioButton algorithm_jrb_zhengxiang;
JRadioButton algorithm_jrb_nixiang;
ButtonGroup bg_algorithm;
JLabel label_showalgorithm=new JLabel("你選擇的算法是: 基于HMM模型");
JPanel input_panel;
JTabbedPane hmm_tabbe=new JTabbedPane();
JPanel hmm_tabbe_pane_train=new JPanel();
JPanel hmm_tabbe_pane_fileinput=new JPanel();
JPanel hmm_tabbe_pane_input=new JPanel();
JLabel label_train_title = new JLabel("選擇訓練集");
static JTextField jTextField_train=new JTextField();
JButton scan_train=new JButton("瀏覽文件");
JButton train_start=new JButton("點擊訓練");
JLabel label_test_title = new JLabel("選擇測試集");
JLabel label_result_title = new JLabel("結果集存儲目錄");
JButton scan_test=new JButton("瀏覽文件");
JButton scan_result=new JButton("瀏覽目錄");
JButton test_start = new JButton("開始分詞");
static JTextField jTextField_test=new JTextField();
static JTextField jTextField_result=new JTextField();
JLabel label_inputdata = new JLabel("輸入測試數(shù)據(jù):");
JTextArea textarea_input = new JTextArea();
JLabel label_outputdata = new JLabel("輸出結果:");
JTextArea textarea_ouptput = new JTextArea();
JButton seg_start = new JButton("開始分詞");
static JLabel label_wait ;
JLabel label_train_wait;
//定義一個定時器
Timer wait_time = null, seg_threadtime=null;
static int count_dot=0;
Timer train_wait_time=null,train_time=null;
int train_count_dot = 0;
//設置滾動條用于裝短信內(nèi)容文本域，使其產(chǎn)生滾動條效果
JScrollPane scrollPane;
JScrollPane outscrollPane;
static JPanel main_panel;
//構造函數(shù)
public CWS_frame(){
setTitle("中文分詞系統(tǒng)");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setResizable(false);
int width=550;
int height=500;
setSize(width,height);
//設置窗體在屏幕出現(xiàn)的位置
setLocation(400, 100);
//設置title
int label_title_x=200;
int label_title_y=25;
int label_title_width=250;
int label_title_height=30;
int label_train_x=60;
int label_train_y=50;
int label_train_width=80;
int label_train_height=25;
int label_test_x=50;
int label_test_y=40;
int label_test_width=100;
int label_test_height=25;
int label_result_x=50;
int label_result_y=70;
int label_result_width=100;
int label_result_height=25;
int JTextField_train_x=140;
int JTextField_train_y=50;
int JTextField_train_width=150;
int JTextField_train_height=25;
int JTextField_test_x=150;
int JTextField_test_y=40;
int JTextField_test_width=150;
int JTextField_test_height=25;
int JTextField_result_x=150;
int JTextField_result_y=70;
int JTextField_result_width=150;
int JTextField_result_height=25;
int alg_select_x=40;
int alg_select_y=60;
int alg_select_width=450;
int alg_select_height=80;
int label_showalg_x=180;
int label_showalg_y=140;
int label_showalg_width=200;
int label_showalg_height=20;
int input_x=40;
int input_y=170;
int input_width=450;
int input_height=250;
int scan_train_x=300;
int scan_train_y=50;
int scan_train_width=80;
int scan_train_height=23;
int train_start_x=180;
int train_start_y=110;
int train_start_width=90;
int train_start_height=25;
int test_start_x=180;
int test_start_y=130;
int test_start_width=90;
int test_start_height=25;
int scan_test_x=310;
int scan_test_y=40;
int scan_test_width=80;
int scan_test_height=23;
int scan_result_x=310;
int scan_result_y=70;
int scan_result_width=80;
int scan_result_height=23;
int label_inputdata_x=20;
int label_inputdata_y=10;
int label_inputdata_width=100;
int label_inputdata_height=20;
int textarea_input_x=20;
int textarea_input_y=30;
int textarea_input_width=180;
int textarea_input_height=120;
int label_outputdata_x=230;
int label_outputdata_y=10;
int label_outputdata_width=100;
int label_outputdata_height=20;
int textarea_output_x=230;
int textarea_output_y=30;
int textarea_output_width=180;
int textarea_output_height=120;
int seg_start_x=180;
int seg_start_y=160;
int seg_start_width=90;
int seg_start_height=25;
int label_wait_x=170;
int label_wait_y=160;
int label_wait_width=120;
int label_wait_height=25;
int label_train_wait_x=170;
int label_train_wait_y=150;
int label_train_wait_width=120;
int label_train_wait_height=25;
main_panel=new JPanel();
//main_panel.setLayout(new FlowLayout(FlowLayout.CENTER,10,10));
main_panel.setLayout(null);
algorithm_select_panel=new JPanel();
algorithm_select_panel.setBorder(new TitledBorder(new EtchedBorder(), "選擇分詞算法"));
bg_algorithm=new ButtonGroup();
algorithm_jrb_hmm=new JRadioButton("基于HMM模型");
algorithm_jrb_zhengxiang=new JRadioButton("正向最大匹配");
algorithm_jrb_nixiang=new JRadioButton("逆向最大匹配");
algorithm_jrb_hmm.setSelected(true);
bg_algorithm.add(algorithm_jrb_hmm);
bg_algorithm.add(algorithm_jrb_zhengxiang);
bg_algorithm.add(algorithm_jrb_nixiang);
input_panel=new JPanel();
//input_panel.setLayout(null);
input_panel.setLayout(new GridLayout(1, 1));
input_panel.setBorder(new TitledBorder(new EtchedBorder(), "輸入數(shù)據(jù)"));
scrollPane=new JScrollPane(textarea_input);
outscrollPane=new JScrollPane(textarea_ouptput);
textarea_ouptput.setEnabled(false);
hmm_tabbe_pane_train.setLayout(null);
hmm_tabbe_pane_fileinput.setLayout(null);
hmm_tabbe_pane_input.setLayout(null);
hmm_tabbe.addTab("使用訓練集訓練", hmm_tabbe_pane_train);
hmm_tabbe.addTab("文件輸入測試集", hmm_tabbe_pane_fileinput);
hmm_tabbe.addTab("直接輸入測試數(shù)據(jù)", hmm_tabbe_pane_input);
//hmm_tabbe.setTabPlacement(LEFT_ALIGNMENT);
label_title.setFont(new Font("",Font.BOLD,15));
label_wait = new JLabel("");
label_train_wait=new JLabel("");
//定位
label_title.setBounds(label_title_x, label_title_y, label_title_width, label_title_height);
algorithm_select_panel.setBounds(alg_select_x, alg_select_y, alg_select_width, alg_select_height);
label_showalgorithm.setBounds(label_showalg_x, label_showalg_y, label_showalg_width, label_showalg_height);
input_panel.setBounds(input_x, input_y, input_width, input_height);
//algorithm_jrb_hmm.setLocation(alg_hmm_x, alg_hmm_y);
// algorithm_jrb_hmm.setBounds(alg_hmm_x, alg_hmm_y, alg_hmm_width, alg_hmm_height);
// algorithm_jrb_zhengxiang.setBounds(alg_zhengxiang_x, alg_zhengxiang_y, alg_zhengxiang_width, alg_zhengxiang_height);
label_train_title.setBounds(label_train_x, label_train_y, label_train_width, label_train_height);
label_test_title.setBounds(label_test_x, label_test_y, label_test_width, label_test_height);
label_result_title.setBounds(label_result_x, label_result_y, label_result_width, label_result_height);
jTextField_train.setBounds(JTextField_train_x, JTextField_train_y, JTextField_train_width, JTextField_train_height);
jTextField_test.setBounds(JTextField_test_x, JTextField_test_y, JTextField_test_width, JTextField_test_height);
jTextField_result.setBounds(JTextField_result_x, JTextField_result_y, JTextField_result_width, JTextField_result_height);
scan_train.setBounds(scan_train_x, scan_train_y, scan_train_width, scan_train_height);
train_start.setBounds(train_start_x, train_start_y, train_start_width, train_start_height);
scan_result.setBounds(scan_result_x, scan_result_y, scan_result_width, scan_result_height);
scan_test.setBounds(scan_test_x, scan_test_y, scan_test_width, scan_test_height);
test_start.setBounds(test_start_x, test_start_y, test_start_width, test_start_height);
label_inputdata.setBounds(label_inputdata_x, label_inputdata_y, label_inputdata_width, label_inputdata_height);
scrollPane.setBounds(textarea_input_x, textarea_input_y, textarea_input_width, textarea_input_height);
label_outputdata.setBounds(label_outputdata_x, label_outputdata_y, label_outputdata_width, label_outputdata_height);
outscrollPane.setBounds(textarea_output_x, textarea_output_y, textarea_output_width, textarea_output_height);
seg_start.setBounds(seg_start_x, seg_start_y, seg_start_width, seg_start_height);
label_wait.setBounds(label_wait_x, label_wait_y, label_wait_width, label_wait_height);
label_train_wait.setBounds(label_train_wait_x, label_train_wait_y, label_train_wait_width, label_train_wait_height);
//將組件加入到容器中
main_panel.add(label_title);
main_panel.add(algorithm_select_panel);
main_panel.add(input_panel);
algorithm_select_panel.add(algorithm_jrb_hmm);
algorithm_select_panel.add(algorithm_jrb_zhengxiang);
algorithm_select_panel.add(algorithm_jrb_nixiang);
input_panel.add(hmm_tabbe);
hmm_tabbe_pane_train.add(label_train_title);
hmm_tabbe_pane_train.add(jTextField_train);
hmm_tabbe_pane_train.add(scan_train);
hmm_tabbe_pane_train.add(train_start);
hmm_tabbe_pane_train.add(label_train_wait);
hmm_tabbe_pane_fileinput.add(label_test_title);
hmm_tabbe_pane_fileinput.add(label_result_title);
hmm_tabbe_pane_fileinput.add(test_start);
hmm_tabbe_pane_fileinput.add(scan_test);
hmm_tabbe_pane_fileinput.add(scan_result);
hmm_tabbe_pane_fileinput.add(jTextField_test);
hmm_tabbe_pane_fileinput.add(jTextField_result);
hmm_tabbe_pane_fileinput.add(label_wait);
hmm_tabbe_pane_input.add(label_inputdata);
hmm_tabbe_pane_input.add(scrollPane);
hmm_tabbe_pane_input.add(label_outputdata);
hmm_tabbe_pane_input.add(outscrollPane);
hmm_tabbe_pane_input.add(seg_start);
main_panel.add(label_showalgorithm);
//將容器加入到窗體中
add(main_panel);
/* wait_time = new Timer(500,new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(count_dot==0)
label_wait.setText("正在分詞，請稍等");
else if(count_dot==1)
label_wait.setText("正在分詞，請稍等.");
else if(count_dot==2)
label_wait.setText("正在分詞，請稍等. .");
else if(count_dot==3)
label_wait.setText("正在分詞，請稍等. . .");
JOptionPane.showMessageDialog(null,
"test","提示",
JOptionPane.INFORMATION_MESSAGE);
//count_dot=(count_dot+1)%4;
// System.out.println(count_dot);
}
});*/
algorithm_jrb_hmm.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(algorithm_jrb_hmm.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 基于HMM模型");
hmm_tabbe.removeAll();
hmm_tabbe.addTab("使用訓練集訓練", hmm_tabbe_pane_train);
hmm_tabbe.addTab("文件輸入測試集", hmm_tabbe_pane_fileinput);
hmm_tabbe.addTab("直接輸入測試數(shù)據(jù)", hmm_tabbe_pane_input);
hmm_tabbe.revalidate();
hmm_tabbe.repaint();
}
if(algorithm_jrb_zhengxiang.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 正向最大匹配");
}
if(algorithm_jrb_nixiang.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 逆向最大匹配");
}
}
});
algorithm_jrb_zhengxiang.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(algorithm_jrb_hmm.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 基于HMM模型");
}
if(algorithm_jrb_zhengxiang.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 正向最大匹配");
hmm_tabbe.removeAll();
//hmm_tabbe.addTab("使用訓練集訓練", hmm_tabbe_pane_train);
hmm_tabbe.addTab("文件輸入測試集", hmm_tabbe_pane_fileinput);
hmm_tabbe.addTab("直接輸入測試數(shù)據(jù)", hmm_tabbe_pane_input);
hmm_tabbe.revalidate();
hmm_tabbe.repaint();
}
if(algorithm_jrb_nixiang.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 逆向最大匹配");
}
}
});
algorithm_jrb_nixiang.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(algorithm_jrb_hmm.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 基于HMM模型");
}
if(algorithm_jrb_zhengxiang.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 正向最大匹配");
}
if(algorithm_jrb_nixiang.isSelected()){
label_showalgorithm.setText("你選擇的算法是: 逆向最大匹配");
hmm_tabbe.removeAll();
//hmm_tabbe.addTab("使用訓練集訓練", hmm_tabbe_pane_train);
hmm_tabbe.addTab("文件輸入測試集", hmm_tabbe_pane_fileinput);
hmm_tabbe.addTab("直接輸入測試數(shù)據(jù)", hmm_tabbe_pane_input);
hmm_tabbe.revalidate();
hmm_tabbe.repaint();
}
}
});
//輸入hmm模型的訓練集文件進行訓練
scan_train.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
File dicFile = openFile();
if(dicFile == null)
return;
jTextField_train.setText(dicFile.getAbsolutePath());
//寫要執(zhí)行的操作
//loadDic(dicFile);
return;
}
});
//輸入測試集文件
scan_test.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
File dicFile = openFile();
if(dicFile == null)
return;
jTextField_test.setText(dicFile.getAbsolutePath());
}
});
//輸入存儲結果集目錄
scan_result.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
File dicDir = openDir();
if(dicDir == null)
return;
jTextField_result.setText(dicDir.getAbsolutePath());
}
});
//點擊通過選擇輸入文件進行分詞的按鈕，通過載入測試集文件進行大規(guī)模數(shù)據(jù)的分詞
test_start.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
String temp_test_str = jTextField_test.getText();
if(temp_test_str.equals("")){
JOptionPane.showMessageDialog(null,
"請選擇測試集文件！","提示",
JOptionPane.INFORMATION_MESSAGE);
return ;
}
String temp_result_str = jTextField_result.getText();
if(temp_result_str.equals("")){
JOptionPane.showMessageDialog(null,
"請選擇存儲結果集目錄！","提示",
JOptionPane.INFORMATION_MESSAGE);
return ;
}
count_dot = 0;
//有兩種定義定時器的方法，分別在不同的java包內(nèi)
//定義等待提示的定時器
wait_time=new Timer(true);
TimerTask task=new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
label_wait.setText(wait_seg());
// System.out.println(wait_seg());
}
};
wait_time.schedule(task, 0, 1000);
//再定義個定時器，相當于再開一個線程
seg_threadtime = new Timer(true);
TimerTask task2 = new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
//進行分詞
Segmentation();
}
};
seg_threadtime.schedule(task2, 0);
}
});
//通過直接輸入數(shù)據(jù)進行分詞
seg_start.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
String jtextarea_str = textarea_input.getText();
if(jtextarea_str.equals("")){
JOptionPane.showMessageDialog(null,
"請輸入要測試的數(shù)據(jù)！","提示",
JOptionPane.INFORMATION_MESSAGE);
return ;
}
if(algorithm_jrb_zhengxiang.isSelected()||algorithm_jrb_nixiang.isSelected()){
//token，沒有指定分隔符默認情況下是空格換行等
StringTokenizer tokens = new StringTokenizer(jtextarea_str);
//創(chuàng)建分詞類的對象
Segment seg=new Segment();
String output_str="";
while(tokens.hasMoreElements()){
//System.out.println(tokens.nextToken());
String temp_str=tokens.nextToken();
String temp_seg="";
//如果選中的是最大正向匹配
if(algorithm_jrb_zhengxiang.isSelected()){
temp_seg=seg.forwardSegment(temp_str);
}
//如果選中的是最大逆向匹配
if(algorithm_jrb_nixiang.isSelected()){
temp_seg=seg.backwardSegment(temp_str);
}
output_str += temp_seg;
output_str += "\n";
}
textarea_ouptput.setText(output_str);
}
//使用hmm模型進行分詞
if(algorithm_jrb_hmm.isSelected()){
// String jtextarea_str = textarea_input.getText();
//System.out.println(testfile);
String output="";
hmmmain hmmmodel = new hmmmain();
output = hmmmodel.Inputtest(jtextarea_str);
textarea_ouptput.setText(output);
}
}
});
//hmm模型訓練
train_start.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
String temp_train_str = jTextField_train.getText();
if(temp_train_str.equals("")){
JOptionPane.showMessageDialog(null,
"請選擇訓練集文件！","提示",
JOptionPane.INFORMATION_MESSAGE);
return ;
}
train_count_dot = 0;
//定義等待提示的定時器
train_wait_time=new Timer(true);
TimerTask task=new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
label_train_wait.setText(train_wait());
// System.out.println(wait_seg());
}
};
train_wait_time.schedule(task, 0, 500);
//再定義個定時器，相當于再開一個線程
train_time = new Timer(true);
TimerTask task2 = new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
//進行訓練
hmmmain hmmmodel = new hmmmain();
String train_str = jTextField_train.getText();
hmmmodel.Trainset(train_str);
JOptionPane.showMessageDialog(null,
"訓練結束，可進行分詞","提示",
JOptionPane.INFORMATION_MESSAGE);
label_train_wait.setText("");
train_wait_time.cancel();
}
};
train_time.schedule(task2, 0);
return ;
}
});
}
//同步
public static synchronized String wait_seg(){
String show_wait = "";
if(count_dot==0)
show_wait = "正在分詞，請稍等";
// label_wait.setText("正在分詞，請稍等");
else if(count_dot==1)
show_wait = "正在分詞，請稍等.";
// label_wait.setText("正在分詞，請稍等.");
else if(count_dot==2)
show_wait = "正在分詞，請稍等. .";
// label_wait.setText("正在分詞，請稍等. .");
else if(count_dot==3)
show_wait = "正在分詞，請稍等. . .";
// label_wait.setText("正在分詞，請稍等. . .");
count_dot = (count_dot+1)%4;
// System.out.println(count_dot);
return show_wait;
//repaint();
//revalidate();
// JOptionPane.showMessageDialog(null,
// "test","提示",
// JOptionPane.INFORMATION_MESSAGE);
}
public synchronized String train_wait(){
String show_wait = "";
if(train_count_dot==0)
show_wait = "正在訓練，請稍等";
else if(train_count_dot==1)
show_wait = "正在訓練，請稍等.";
else if(train_count_dot==2)
show_wait = "正在訓練，請稍等. .";
else if(train_count_dot==3)
show_wait = "正在訓練，請稍等. . .";
train_count_dot = (train_count_dot+1)%4;
return show_wait;
}
//通過輸入測試集文件進行大規(guī)模數(shù)據(jù)的分詞
private void Segmentation(){
if(algorithm_jrb_zhengxiang.isSelected()||algorithm_jrb_nixiang.isSelected()){
//創(chuàng)建分詞類的對象
Segment seg=new Segment();
InputStreamReader inputdata;
BufferedReader in;
String str;
String testfile=jTextField_test.getText();
System.out.println(testfile);
String resultdir=jTextField_result.getText();
try {
inputdata = new InputStreamReader (new FileInputStream(testfile),"UTF-8");
in = new BufferedReader(inputdata);
FileOutputStream out = null;
resultdir += "\\CWS_truth_utf8";
out = new FileOutputStream(new File(resultdir));
while((str=in.readLine())!= null){
String temp_seg="";
if(algorithm_jrb_zhengxiang.isSelected()){
temp_seg=seg.forwardSegment(str);
}
if(algorithm_jrb_nixiang.isSelected()){
temp_seg=seg.backwardSegment(str);
}
out.write(temp_seg.getBytes("UTF-8"));
out.write("\r\n".getBytes("UTF-8"));
}
//關閉定時器
// wait_time.stop();
inputdata.close();
out.close();
JOptionPane.showMessageDialog(null,
"分詞結束，請在"+resultdir+"查找","提示",
JOptionPane.INFORMATION_MESSAGE);
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
//使用hmm模型進行分詞
if(algorithm_jrb_hmm.isSelected()){
String testfile=jTextField_test.getText();
//System.out.println(testfile);
String resultdir=jTextField_result.getText();
resultdir += "\\CWS_truth_utf8";
hmmmain hmmmodel = new hmmmain();
hmmmodel.Testset(testfile, resultdir);
JOptionPane.showMessageDialog(null,
"分詞結束，請在"+resultdir+"查找","提示",
JOptionPane.INFORMATION_MESSAGE);
}
//
label_wait.setText("");
wait_time.cancel();
}
//打開文件（數(shù)據(jù)、詞典或者語料庫）
private File openFile(){
JFileChooser chooser = new JFileChooser();//文件選擇對話框
int ret = chooser.showOpenDialog(this);
if (ret != JFileChooser.APPROVE_OPTION) {
return null;
}
File f = chooser.getSelectedFile();
if (f.isFile() && f.canRead())
{
return f;
}
else
{
JOptionPane.showMessageDialog(this,
"Could not open file: " + f,
"Error opening file",
JOptionPane.ERROR_MESSAGE);
return null;
}
}
//打開目錄
private File openDir(){
JFileChooser parseDir = new JFileChooser();
parseDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int ret = parseDir.showOpenDialog(this);
if(ret !=JFileChooser.APPROVE_OPTION)
return null;
File f=parseDir.getSelectedFile();
if(f.exists())
return f;
else{
JOptionPane.showMessageDialog(this,
"Could not open directory: " + f,
"Error opening directory",
JOptionPane.ERROR_MESSAGE);
return null;
}
}
//重寫JPanel容器添加背景圖片
class MainPanel extends JPanel{
ImageIcon background = new ImageIcon("images\\backimg.jpg");//加載圖片
Image im=Toolkit.getDefaultToolkit().getImage("images\\backimg.jpg");
public void paintComponent(Graphics g) {
g.drawImage(im, 0, 0, this);
}
}
}效果圖展示
到此這篇關于基于Java實現(xiàn)中文分詞系統(tǒng)的示例代碼的文章就介紹到這了,更多相關Java中文分詞系統(tǒng)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了Java ThreadPool的使用解析，幫助大家更好的理解和使用Java，感興趣的朋友可以了解下2020-10-10
這篇文章主要為大家詳細介紹了Java中finalize方法的作用和底層原理，文中的示例代碼講解詳細，具有一定的學習價值，需要的可以參考一下2022-12-12
Java中forEach使用lambda表達式,數(shù)組和集合的區(qū)別說明
這篇文章主要介紹了Java中forEach使用lambda表達式,數(shù)組和集合的區(qū)別說明，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-07-07
這篇文章主要為大家詳細介紹了java實現(xiàn)銀行家算法，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-12-12
Java訪問WebService返回XML數(shù)據(jù)的方法
這篇文章主要介紹了Java訪問WebService返回XML數(shù)據(jù)的方法,涉及java操作WebService的相關技巧,需要的朋友可以參考下2015-06-06
Java內(nèi)存溢出的幾個區(qū)域總結(注意避坑!)
內(nèi)存溢出是指應用系統(tǒng)中存在無法回收的內(nèi)存或使用的內(nèi)存過多,最終使得程序運行要用到的內(nèi)存大于虛擬機能提供的最大內(nèi)存,下面這篇文章主要給大家介紹了關于Java內(nèi)存溢出的幾個區(qū)域，總結出來給大家提醒注意避坑,需要的朋友可以參考下2022-11-11
這篇文章主要介紹了Spring中Bean掃描原理詳情，文章為榮啊主題展開詳細的內(nèi)容介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-07-07
下面小編就為大家?guī)硪黄猺edis 在java中的使用(實例講解)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-08-08
在Java集合中，HashMap的重要性不言而喻，作為一種存儲鍵值對的數(shù)據(jù)結構，它在日常開發(fā)中有著非常多的應用場景，也是面試中的高頻考點，本篇文章就來分析一下HashMap集合中的put方法2021-12-12
這篇文章主要為大家詳細介紹了java實現(xiàn)動態(tài)時鐘并設置鬧鐘功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-01-01