正文之前
因為不斷的擴充了輔助類，所以改進了下腳本，沒有原先那么巨細，但是感覺好了不少。我在想要不要下次直接開一個文件來記錄上次更新的文件以及時間。然后再寫一個Java或者Python的程序來自動輸出要上傳的文件名字？感覺是個大工程。現在還可以，以后再說吧！
正文
echo "OK!NOW I WILL UPLOAD YOUR CHANGE TO GITHUB!"
time=$(date "+%Y-%m-%d %H:%M")
echo "${time}"
cd /Users/zhangzhaobo/Documents/Graduation-Design/
sudo cp -a /Users/zhangzhaobo/IdeaProjects/Graduation_Design/src/ReadData.* /Users/zhangzhaobo/Documents/Graduation-Design/
sudo cp -a /Users/zhangzhaobo/IdeaProjects/Graduation_Design/src/ZZB_JCS.* /Users/zhangzhaobo/Documents/Graduation-Design/
sudo cp -a /Users/zhangzhaobo/IdeaProjects/Graduation_Design/src/data.txt /Users/zhangzhaobo/Documents/Graduation-Design/data.txt
sudo cp -a /Users/zhangzhaobo/IdeaProjects/Graduation_Design/src/Mysql* /Users/zhangzhaobo/Documents/Graduation-Design/
sudo cp -a /Users/zhangzhaobo/IdeaProjects/Graduation_Design/mysql* /Users/zhangzhaobo/Documents/Graduation-Design/
sudo javac /Users/zhangzhaobo/Documents/Graduation-Design/ReadData.java
sudo javac /Users/zhangzhaobo/Documents/Graduation-Design/ZZB_JCS.java
git add ReadData.* ZZB_JCS.* data.txt Mysql*
git commit -m "$time $1"
git push origin master
別的就不說了，先把數據讀寫的程序丟出來。這個數據讀寫其實我是想要到時候如果有人給我一個文本，那就GG，所以還要看看讀文本存進數據庫咋搞！另外！有沒有人能告訴我！去哪兒找機械設備的運行數據啊！！！我很苦惱啊啊！
數據庫連接程序
//*************************** 數據庫連接程序 ***************************
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Mysql_Connect {
//此處查看網絡才知道。要求SSL，所以就醬紫咯：https://zhidao.baidu.com/question/2056521203295428667.html
private static String url = "jdbc:mysql://127.0.0.1:3306/Graduation_Design?useUnicode=true&characterEncoding=GBK&useSSL=true";
private static String user = "root";
private static String password = "zzb1184827350";
private static String Database="192.168.2.127:3306/Graduation_Design";
private Statement statement;
private Connection conn;
public void setUser(String user){
this.user=user;
}
public void setPassword(String p){
this.password=p;
}
public void setDatabase(String database){
this.Database=database;
this.url="jdbc:mysql:/"+Database+"?useUnicode=true&characterEncoding=GBK&useSSL=true";
}
public void setDatabase(){
this.url="jdbc:mysql:/192.168.2.127:3306/Shop_User?useUnicode=true&characterEncoding=GBK&useSSL=true";
}
public Statement getStatement() {
return this.statement;
}
public void Connect() {
try {
String driver = "com.mysql.jdbc.Driver";
Class.forName(driver);
conn = DriverManager.getConnection(url, user, password);
if (!conn.isClosed()){
}
else {
System.out.println("\n\nFailed to connect to the Database!");
}
this.statement = conn.createStatement();
} catch (ClassNotFoundException e) {
System.out.println("Sorry,can`t find the Driver!");
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public void Dis_Connect() throws SQLException {
try {
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
數據庫讀寫程序！
//*************************** 數據庫讀寫程序 ***************************
/* *********************
* Author : HustWolf --- 張照博
* Time : 2018.3-2018.5
* Address : HUST
* Version : 3.0
********************* */
/* *******************
* 這是從數據庫或者是文本文件讀取數據的時候用的
* 其實我覺得如果可以每一次讀一條數據，然后處理一條會比較好
* 但是算了，數據量不大的話，這個樣子也不會增加太多時間的！
******************* */
import java.io.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ReadData {
protected Mysql_Connect mysql=new Mysql_Connect();
public void writeToDatabase(int id,Object[] data_array) {
try {
mysql.Connect();
Statement statement=mysql.getStatement();
String INSERT = "INSERT INTO watermelon(id,色澤,根蒂,敲聲,紋理,臍部,觸感,category) VALUES( " + id + " , ' " + data_array[0] + "' , ' " + data_array[1] + "' , ' " + data_array[2] + "' , ' " + data_array[3] + "' , ' " + data_array[4] + "' , ' " + data_array[5] + " ', ' " + data_array[6] + "' )";
boolean insert_ok = statement.execute(INSERT);
if (insert_ok) {
System.out.println("Insert Success!");
}
statement.close();
mysql.Dis_Connect();
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public Object[] readFromDatabase(int id) {
Object[] DataToOut = new Object[7];
try {
mysql.Connect();
Statement statement=mysql.getStatement();
String GETDATA = "SELECT 色澤,根蒂,敲聲,紋理,臍部,觸感,category FROM watermelon WHERE id="+id;
ResultSet select_ok = statement.executeQuery(GETDATA);
if(select_ok.next()) {
DataToOut[0]=select_ok.getObject("色澤");
DataToOut[1]=select_ok.getObject("根蒂");
DataToOut[2]=select_ok.getObject("敲聲");
DataToOut[3]=select_ok.getObject("紋理");
DataToOut[4]=select_ok.getObject("臍部");
DataToOut[5]=select_ok.getObject("觸感");
DataToOut[6]=select_ok.getObject("category");
}
statement.close();
mysql.Dis_Connect();
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return DataToOut;
}
public Object[][] ReadData() throws IOException {
Object[][] rawData = new Object [][]{
{"青綠","蜷縮","濁響","清晰","凹陷","硬滑","是"},
{"烏黑","蜷縮","沉悶","清晰","凹陷","硬滑","是"},
{"烏黑","蜷縮","濁響","清晰","凹陷","硬滑","是"},
{"青綠","蜷縮","沉悶","清晰","凹陷","硬滑","是"},
{"淺白","蜷縮","濁響","清晰","凹陷","硬滑","是"},
{"青綠","稍蜷","濁響","清晰","稍凹","軟粘","是"},
{"烏黑","稍蜷","濁響","稍糊","稍凹","軟粘","是"},
{"烏黑","稍蜷","濁響","清晰","稍凹","硬滑","是"},
{"烏黑","稍蜷","沉悶","稍糊","稍凹","硬滑","否"},
{"青綠","硬挺","清脆","清晰","平坦","軟粘","否"},
{"淺白","硬挺","清脆","模糊","平坦","硬滑","否"},
{"淺白","蜷縮","濁響","模糊","平坦","軟粘","否"},
{"青綠","稍蜷","濁響","稍糊","凹陷","硬滑","否"},
{"淺白","稍蜷","沉悶","稍糊","凹陷","硬滑","否"},
{"烏黑","稍蜷","濁響","清晰","稍凹","軟粘","否"},
{"淺白","蜷縮","濁響","模糊","平坦","硬滑","否"},
{"青綠","蜷縮","沉悶","稍糊","稍凹","硬滑","否"},
// { "<30 ", "High ", "No ", "Fair ", "0" },
// { "<30 ", "High ", "No ", "Excellent", "0" },
// { "30-40", "High ", "No ", "Fair ", "1" },
// { ">40 ", "Medium", "No ", "Fair ", "1" },
// { ">40 ", "Low ", "Yes", "Fair ", "1" },
// { ">40 ", "Low ", "Yes", "Excellent", "0" },
// { "30-40", "Low ", "Yes", "Excellent", "1" },
// { "<30 ", "Medium", "No ", "Fair ", "0" },
// { "<30 ", "Low ", "Yes", "Fair ", "1" },
// { ">40 ", "Medium", "Yes", "Fair ", "1" },
// { "<30 ", "Medium", "Yes", "Excellent", "1" },
// { "30-40", "Medium", "No ", "Excellent", "1" },
// { "30-40", "High ", "Yes", "Fair ", "1" },
// { "<30 " , "Medium", "No ", "Excellent", "1" },
// { ">40 ", "Medium", "No ", "Excellent", "0" }
};
// ***************** 寫入文件式 **************
// File file = new File("data.txt"); //存放數組數據的文件
//
// FileWriter DataToTXT = new FileWriter(file); //文件寫入流
// int row=0;
// //將數組中的數據寫入到文件中。每行各數據之間TAB間隔
// for(int i=0;i<rawData.length;i++){
// for(int j=0;j<rawData[0].length;j++){
// DataToTXT.write(rawData[i][j]+"\t");
// }
// row++;
// DataToTXT.write("\r\n");
// }
// DataToTXT.close();
//
// BufferedReader in = new BufferedReader(new FileReader(file));
// String line; //一行數據
// //逐行讀取，并將每個數組放入到數組中
// Object[][] DataToOut = new Object[row][7];
// int readrow=0;
// while((line = in.readLine()) != null){
// String[] temp = line.split("\t");
// for(int j=0;j<temp.length;j++){
// DataToOut[readrow][j] = temp[j];
// }
// readrow++;
// }
// in.close();
//顯示讀取出的數組
// for(int i=0;i<DataToOut.length;i++){
// for(int j=0;j<DataToOut[0].length;j++){
// System.out.print(DataToOut[i][j]+"\t");
// }
// System.out.println();
// }
// ***************** 寫入文件式 **************
// ***************** 數據庫讀寫式 **************
int row=0;
try {
mysql.Connect();
Statement statement=mysql.getStatement();
String DELETE="delete from watermelon where id<1000";
boolean delete_ok=statement.execute(DELETE);
if (delete_ok){
System.out.println("Have Fun! Boys!\n\n");
}
statement.close();
mysql.Dis_Connect();
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
for(int i=0;i<rawData.length;i++){
writeToDatabase(row,rawData[i]);
row++;
}
Object[][] DataToOut = new Object[row][7];
for (int i=0;i<DataToOut.length;++i){
DataToOut[i]=readFromDatabase(i);
}
// ***************** 數據庫讀寫式 **************
return DataToOut;
}
}
最大頭！決策樹生成程序！
主要是照搬的網上的啦！后面再自己慢慢適合的吧！大神寫的很棒啊啊！
/* *********************
* Author : HustWolf --- 張照博
* Time : 2018.3-2018.5
* Address : HUST
* Version : 1.0
********************* */
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
//最外層類名
public class ZZB_JCS{
/* *********************
* Define the Class of Sample
* it is about its nature and function
********************* */
static class Sample{
//attributes means 屬性
private Map<String,Object> attributes = new HashMap<String,Object>();
//category means 類別
private Object category;
public Object getAttribute(String name){
return attributes.get(name);
}
public void setAttribute(String name,Object value){
attributes.put(name,value);
}
public void setCategory(Object category){
this.category=category;
}
public String toString(){
return attributes.toString();
}
}
/* *********************
* this is the function to read the sample
* just like decoding the data
********************* */
// 此處需要改造為讀取外部數據！并且能夠進行分解，改造為可讀取的形式
static Map<Object,List<Sample>> readSample(String[] attribute_Names) throws IOException {
//樣本屬性及其分類，暫時先在代碼里面寫了。后面需要數據庫或者是文件讀取
ReadData data = new ReadData();
Object[][] rawData = data.ReadData();
//最終組合出一個包含所有的樣本的Map
Map<Object,List<Sample>> sample_set = new HashMap<Object,List<Sample>>();
//讀取每一排的數據
//分解后讀取樣本屬性及其分類，然后利用這些數據構造一個Sample對象
//然后按照樣本最后的0，1進行二分類劃分樣本集，
for (Object[] row:rawData) {
//新建一個Sample對象，沒處理一次加入Map中，最后一起返回
Sample sample = new Sample();
int i=0;
//每次處理一排數據，構成一個樣本中各項屬性的值
for (int n=row.length-1; i<n; ++i) {
sample.setAttribute(attribute_Names[i],row[i]);
}
//為處理完的一個樣本進行分類，根據0，1來，此時i已經在最后一位
sample.setCategory(row[i]);
//將解析出來的一排加入整體分類后的樣本中，row[i]此刻是指分類后的集合
List<Sample> samples = sample_set.get(row[i]);
//現在整體樣本集中查詢，有的話就返回value，而如果這個類別還沒有樣本，那么就添加一下
if(samples == null){
samples = new LinkedList<Sample>();
sample_set.put(row[i],samples);
}
//不管是當前分類的樣本集中是否為空，都要加上把現在分離出來的樣本丟進去。
//此處基本只有前幾次分類沒有完畢的時候才會進入if，后面各個分類都有了樣本就不會為空了。
samples.add(sample);
}
//最后返回的是一個每一個類別一個鏈表的Map，串著該類別的所有樣本 (類別 --> 此類樣本)
return sample_set;
}
/* *********************
* this is the class of the decision-tree
* 決策樹（非葉結點），決策樹中的每個非葉結點都引導了一棵決策樹
* 每個非葉結點包含一個分支屬性和多個分支，分支屬性的每個值對應一個分支，該分支引導了一棵子決策樹
********************* */
static class Tree{
private String attribute;
private Map<Object,Object> children = new HashMap<Object,Object>();
public Tree(String attribute){
this.attribute=attribute;
}
public String getAttribute(){
return attribute;
}
public Object getChild(Object attrValue){
return children.get(attrValue);
}
public void setChild(Object attrValue,Object child){
children.put(attrValue,child);
}
public Set<Object> getAttributeValues(){
return children.keySet();
}
}
/* *********************
* this is the function to choose the Best Test Attribute
* it will be used in the generateDecisionTree()
* 選取最優測試屬性。最優是指如果根據選取的測試屬性分支，則從各分支確定新樣本
* 的分類需要的信息熵之和最小，這等價于確定新樣本的測試屬性獲得的信息增益最大
* 返回數組：選取的屬性下標、信息熵之和、Map(屬性值->(分類->樣本列表))
********************* */
static Object[] chooseBestTestAttribute(Map<Object,List<Sample>> categoryToSamples,String[] attribute_Names){
//最優的屬性的下標！
int minIndex = -1;
//最小的信息熵
double minValue = Double.MAX_VALUE;
//最優的分支方案！
Map<Object,Map<Object,List<Sample>>> minSplit = null;
//對每一個屬性，都要計算信息熵，選區最小的為最優，Ent(D)
for (int attrIndex = 0;attrIndex<attribute_Names.length;++attrIndex) {
//統計樣本總數的計數器
int allCount = 0;
//按照當前屬性構建Map，這個Map的層級關系根據下面的層次劃分：屬性值[Key]->(分類[Key]->樣本列表[Value]) [Value]
// curSplits就是一個某一個在當前屬性下某一種選擇值 所對應的所有樣本集！ 所有的Dv的集合是也？？待定！
Map<Object,Map<Object,List<Sample>>> curSplits = new HashMap<Object,Map<Object,List<Sample>>>();
/* 這兒的整個流程畫個圖哈~下面是對某一個屬性進行信息增益的計算了！
拿到一個數據對，【所屬類別-->樣本集】
|
V
解析數據對，分解出key和value
其中key為類別，value為此類別所有的樣本
|
V
對于Value里邊讀出來的每個樣本，分別：
讀取當前屬性下的值，然后建立起來當前屬性值相同的所有樣本的樣本集；
|
V
此處還要將每個樣本集拆分為分類樣本集！
|
V
這一輪下來，就得到關于這個屬性的不同屬性值對應的樣本集合
而在這些集合集合中又有分類樣本集！
就好比，這一輪對年齡下手，最終得到了40歲以上的好人、壞人
30-40歲之間的好人、壞人集合
30歲以下的好人、壞人的集合
最后一共得到了6個樣本集？
只不過是已Map中鍵值對的形式存在，二層包裝而已！
--正分類--> 一個Map
---屬性值1，比如是學生 ->分類兩類 |
某一屬性（這個就是curSplits這個Map的本體） --負分類--> 一個Map（此處畫圖方便重用了！）
---屬性值2，比如不是學生->分類兩類 |
--正分類--> 一個Map
*/
/*
* Set<Map.Entry<K,V>> entrySet?()
* Returns: A set view of the mappings contained in this map
* Entry 這個數據類型大致等于C++中的pair，也就是數據打包的意思
*/
for (Entry<Object,List<Sample>> entry : categoryToSamples.entrySet()) {
//先拿到數據的分類的名稱，我們這兒就0，1
Object category = entry.getKey();
//再拿到這個類別！注意是類別，不是屬性值！類別所對應的所有樣本！
List<Sample> samples = entry.getValue();
//然后再慢慢的對每個樣本進行操作，將其分為按照屬性值劃分的各種Dv，然后返回到curSplits
for (Sample sample : samples ) {
// 根據當前要計算的屬性，得到當前樣本的關于這個屬性的值
Object attrValue = sample.getAttribute(attribute_Names[attrIndex]);
// 根據前面當前樣本getAttribute()所獲得的屬性值，來獲取這個屬性的值相同的所有的樣本的樣本集
Map<Object,List<Sample>> split = curSplits.get(attrValue);
// 考慮到一開始肯定沒法得到一個完整的Map,所以需要從無到有建立起來！
if (split == null) {
//建立一個關于這個屬性值的Map，層次關系為：屬性值->(All Sample) 見Line156
split = new HashMap<Object,List<Sample>>();
curSplits.put(attrValue,split);
}
//建立起來之后，就可以讀取這個屬性值等于某個值時對應的分類樣本集合了。
List<Sample> splitSamples = split.get(category);
// 如果讀不到當前屬性對應這個值的分類的話，那就要建立一個屬性值等于當前樣本的屬性值，且分類相同的樣本集。
if (splitSamples == null) {
splitSamples = new LinkedList<Sample>();
// 結合當前這個屬性值，組成一個集合，放到Map--split里面去。
split.put(category,splitSamples);
}
// 最后再把當前的這個樣本放到這個樣本集中？？？！！可以直接這么搞的？%%%%%% 難道是引用傳遞？
// 是的！沒有用new自然就是一個引用傳遞！臥槽！這都給忘了！？
splitSamples.add(sample);
}
//統計樣本總數的計數器需要對當前屬性下的樣本的數量進行統計。
allCount += samples.size();
}
// 當前屬性值的信息增益寄存器
double curValue = 0.0;
//讀取當前屬性下的每一種屬性值對應的樣本集
for (Map<Object,List<Sample>> splits : curSplits.values()) {
double perSplitCount = 0;
//讀取每個屬性值的樣本集Dv的size，得到所有該屬性為此值的樣本總數，不論類別如何
for (List<Sample> list : splits.values()) {
//累計當前樣本的分支總數
perSplitCount += list.size();
}
//計數器，當前分支的信息熵和信息增益，這兒是按出現頻率在算呢！
double perSplitValue = 0.0;
//計算每個屬性值對應的信息熵
for (List<Sample> list : splits.values() ) {
//此處完全就是ID3算法的信息熵的計算公式！也就是ENT(D) = -Sum(Pk*log2(Pk))見《機器學習》 P75
double p = list.size() / perSplitCount;
//貌似是因為p無論如何都是小于1的，所以采用p -= 實際上是加了？
perSplitValue -= p*(Math.log(p)/Math.log(2));
}
//這應該還算不上不是信息增益吧！只能算是信息熵之和了。
curValue += (perSplitCount / allCount) * perSplitValue;
}
//選擇最小的信息熵為最優！？
if (minValue > curValue){
minIndex = attrIndex;
minValue = curValue;
minSplit = curSplits;
}
}
//所以最終返回的就是一個信息熵之和 最小的屬性的列表索引 + 最小的信息熵之和 + 最小的信息熵之和所對應的子樹！
return new Object[] {minIndex,minValue,minSplit};
}
/* *********************
* this is the function to output the Decision Tree to the Dashboard
********************* */
static void outputDecisionTree(Object obj,int level, Object from){
//這個到后面決定輸出多少個|----- 也就是說是決定層級的
for (int i=0; i < level ;++i){
System.out.print("|-----");
}
// 所有子節點專用？除了根節點都要吧！
if (from != null){
System.out.printf("(%s):",from);
}
//大概是說，如果這個東西還有子節點，那就繼續遞歸
if (obj instanceof Tree){
Tree tree = (Tree) obj;
String attribute_Name = tree.getAttribute();
System.out.printf("[%s = ?]\n",attribute_Name);
for (Object attrValue : tree.getAttributeValues()){
Object child =tree.getChild(attrValue);
outputDecisionTree(child,level+1,attribute_Name + " = " + attrValue);
}
}else {
System.out.printf("【* CATEGORY = %s *】\n", obj);
}
}
/* *********************
* this is the function to generate the DecisionTree
* use the data which read from the files to get the Decisiontree
* the most important part I think!
********************* */
static Object generateDecisionTree(Map<Object,List<Sample>> categoryToSamples,String[] attribute_Names){
//如果只有一個樣本，那么該樣本所屬分類作為新樣本的分類
if(categoryToSamples.size() == 1)
return categoryToSamples.keySet().iterator().next();
//如果沒有提供決策的屬性（也就是沒有給你屬性名字清單），那么樣本集中具有最多樣本的分類作為新樣本的分類，也就是投票選舉出新的分類
if (attribute_Names.length == 0) {
int max = 0;
Object maxCategory = null;
// 如果沒有屬性列表的話，那就直接按照分類作為K個樣本集，取數量較大的那個樣本集的類別作為本分類。
for (Entry<Object,List<Sample>> entry : categoryToSamples.entrySet() ) {
int cur = entry.getValue().size();
if (cur > max) {
max = cur;
maxCategory = entry.getKey();
}
}
return maxCategory;
}
//如果有屬性清單的話，那么就選擇測試所用的屬性了。
Object[] rst = chooseBestTestAttribute(categoryToSamples,attribute_Names);
//決策樹的根節點選取，分支的屬性為選取的測試屬性
Tree tree = new Tree(attribute_Names[(Integer)rst[0]]);
//已用過的測試屬性不能再次被選擇為測試屬性
String[] Attr_Find_Already = new String[attribute_Names.length-1];
for (int i=0,j=0;i<attribute_Names.length ;++i ) {
if (i != (Integer)rst[0]) {
Attr_Find_Already[j++] = attribute_Names[i];
}
}
//根據分支的屬性生成新的分支
@SuppressWarnings("unchecked")
Map<Object,Map<Object,List<Sample>>> splits = (Map<Object,Map<Object,List<Sample>>>) rst[2];
for (Entry<Object,Map<Object,List<Sample>>> entry : splits.entrySet()) {
Object attrValue = entry.getKey();
Map<Object,List<Sample>> split = entry.getValue();
//又是遞歸調用？那我豈不是玩完？層數不能超過二十層！這是底線！
Object child = generateDecisionTree(split,Attr_Find_Already);
tree.setChild(attrValue,child);
}
return tree;
}
public static void main(String[] args) throws Exception{
// String[] attribute_Names = new String[] {"AGE","INCOME","STUDENT","CREDIT_RATING"};
String[] attribute_Names = new String[] {"色澤","根蒂","敲聲","紋理","臍部","觸感"};
//讀取樣本集
Map<Object,List<Sample>> samples = readSample(attribute_Names);
//生成決策樹
Object decisionTree = generateDecisionTree(samples,attribute_Names);
//輸出決策樹
outputDecisionTree(decisionTree,0,null);
}
}
另外要注意，這個因為用到了數據庫，所以需要加載依賴文件包！具體看這兒：
解決方案！ https://blog.csdn.net/sakura_yuan/article/details/51730493
最后的結果簡直是美到爆炸！好么？？爆炸！！
/Library/Java/JavaVirtualMachines/jdk-9.0.1.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=57631:/Applications/IntelliJ IDEA.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /Users/zhangzhaobo/IdeaProjects/Graduation_Design/out/production/Graduation_Design:/Users/zhangzhaobo/IdeaProjects/Graduation_Design/mysql-connector-java-5.1.44-bin.jar ZZB_JCS
[紋理 = ?]
|-----(紋理 = 稍糊):[觸感 = ?]
|-----|-----(觸感 = 硬滑 ):【* CATEGORY = 否 *】
|-----|-----(觸感 = 軟粘 ):【* CATEGORY = 是 *】
|-----(紋理 = 模糊):【* CATEGORY = 否 *】
|-----(紋理 = 清晰):[根蒂 = ?]
|-----|-----(根蒂 = 硬挺):【* CATEGORY = 否 *】
|-----|-----(根蒂 = 蜷縮):【* CATEGORY = 是 *】
|-----|-----(根蒂 = 稍蜷):[色澤 = ?]
|-----|-----|-----(色澤 = 青綠):【* CATEGORY = 是 *】
|-----|-----|-----(色澤 = 烏黑):[觸感 = ?]
|-----|-----|-----|-----(觸感 = 硬滑 ):【* CATEGORY = 是 *】
|-----|-----|-----|-----(觸感 = 軟粘 ):【* CATEGORY = 否 *】
Process finished with exit code 0
正文之后
今天早起（八點半？）吃到了西邊百景園的早飯，油條和湯包，雖然貴了點，但是好吃啊！希望以后天天有早飯吃！阿西吧！整完了，吃午飯去！
