The text before
As I continued to expand the helper classes, I improved the script, which was not as detailed as before, but felt much better. I am thinking whether to directly open a file next time to record the file updated last time and the time. And then write a Java or Python program that automatically prints the name of the file to be uploaded? It feels like a big project. It’s ok for now, but maybe later!
The body of the
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
Copy the codeBut let’s just throw out the program that reads and writes data. This data read and write actually I want to when someone gives me a text, then GG, so also want to see how to read the text into the database! In addition! Can someone tell me! Where to look for the running data of mechanical equipment!! I am very distressed ah ah!
Database connection routine
/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * database connection program * * * * * * * * * * * * * * * * * * * * * * * * * * *
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Mysql_Connect {
// Check the network. Require SSL, so it: 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(a){
this.url="JDBC: mysql: / 192.168.2.127:3306 / Shop_User? useUnicode=true&characterEncoding=GBK&useSSL=true";
}
public Statement getStatement(a) {
return this.statement;
}
public void Connect(a) {
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(a) throws SQLException {
try {
conn.close();
} catch(Exception e) { e.printStackTrace(); }}}Copy the codeDatabase read and write procedures!
/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * database to read and write program * * * * * * * * * * * * * * * * * * * * * * * * * * *
/ * * * * * * * * * * * * * * * * * * * * * * * the Author: HustWolf - Zhang Zhaobo * Time: 2018.3-2018.5 * Address: HUST * Version: 3.0 * * * * * * * * * * * * * * * * * * * * * * /
/* ******************* * this is used to read data from a database or text file * in fact, I think it would be better if I could read one data at a time, and then process one data * however, if the data is not large, this will not add too much time! * * * * * * * * * * * * * * * * * * * * /
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 a ripe (ID, color, root, tempo, texture, umbilical,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 color, root, tap, texture, umbilical, touch,category FROM watermelon WHERE ID ="+id;
ResultSet select_ok = statement.executeQuery(GETDATA);
if(select_ok.next()) {
DataToOut[0]=select_ok.getObject("Color");
DataToOut[1]=select_ok.getObject("Roots");
DataToOut[2]=select_ok.getObject("Knock");
DataToOut[3]=select_ok.getObject("Texture");
DataToOut[4]=select_ok.getObject("Time");
DataToOut[5]=select_ok.getObject("Touch");
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 [][]{
{"Green"."Cowering"."Cloud ring"."Clear"."Depression"."Hard slide"."Yes"},
{"Black"."Cowering"."Boring"."Clear"."Depression"."Hard slide"."Yes"},
{"Black"."Cowering"."Cloud ring"."Clear"."Depression"."Hard slide"."Yes"},
{"Green"."Cowering"."Boring"."Clear"."Depression"."Hard slide"."Yes"},
{"Plain"."Cowering"."Cloud ring"."Clear"."Depression"."Hard slide"."Yes"},
{"Green"."Slightly curled"."Cloud ring"."Clear"."Slightly concave"."Soft glue"."Yes"},
{"Black"."Slightly curled"."Cloud ring"."A little paste"."Slightly concave"."Soft glue"."Yes"},
{"Black"."Slightly curled"."Cloud ring"."Clear"."Slightly concave"."Hard slide"."Yes"},
{"Black"."Slightly curled"."Boring"."A little paste"."Slightly concave"."Hard slide"."No." "},
{"Green"."Strong"."Clear"."Clear"."Flat"."Soft glue"."No." "},
{"Plain"."Strong"."Clear"."Fuzzy"."Flat"."Hard slide"."No." "},
{"Plain"."Cowering"."Cloud ring"."Fuzzy"."Flat"."Soft glue"."No." "},
{"Green"."Slightly curled"."Cloud ring"."A little paste"."Depression"."Hard slide"."No." "},
{"Plain"."Slightly curled"."Boring"."A little paste"."Depression"."Hard slide"."No." "},
{"Black"."Slightly curled"."Cloud ring"."Clear"."Slightly concave"."Soft glue"."No." "},
{"Plain"."Cowering"."Cloud ring"."Fuzzy"."Flat"."Hard slide"."No." "},
{"Green"."Cowering"."Boring"."A little paste"."Slightly concave"."Hard slide"."No." "},
// { "<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" }
};
// ***************** write to the file format **************
// File file = new File("data.txt"); // File to store array data
//
// FileWriter DataToTXT = new FileWriter(file); // Write the file to the stream
// int row=0;
// // writes the data from the array to a file. TAB interval between each data in each row
// for(int i=0; i
// for(int j=0; j
// DataToTXT.write(rawData[i][j]+"\t");
/ /}
// row++;
// DataToTXT.write("\r\n");
/ /}
// DataToTXT.close();
//
// BufferedReader in = new BufferedReader(new FileReader(file));
// String line; // A row of data
// // reads line by line and puts each array into the array
// Object[][] DataToOut = new Object[row][7];
// int readrow=0;
// while((line = in.readLine()) ! = null){
// String[] temp = line.split("\t");
// for(int j=0; j
// DataToOut[readrow][j] = temp[j];
/ /}
// readrow++;
/ /}
// in.close();
// Display the array read out
// for(int i=0; i
// for(int j=0; j
// System.out.print(DataToOut[i][j]+"\t");
/ /}
// System.out.println();
/ /}
// ***************** write to the file format **************
// ***************** database read-write **************
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); }// ***************** database read-write **************
returnDataToOut; }}Copy the codeThe big head! Decision tree generator!
~ basically be copy on the net! Behind again oneself slowly suit! Great writing by the Great God! ~
/ * * * * * * * * * * * * * * * * * * * * * * * the Author: HustWolf - Zhang Zhaobo * 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;
// The outermost class name
public class ZZB_JCS{
/* ********************* * Define the Class of Sample * it is about its nature and function ********************* */
static class Sample{
/ / the attributes means properties
private Map<String,Object> attributes = new HashMap<String,Object>();
/ / category means categories
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(a){
returnattributes.toString(); }}/* ********************* * this is the function to read the sample * just like decoding the data ********************* * /
// We need to read external data. And it can be broken down and transformed into a readable form
static Map<Object,List<Sample>> readSample(String[] attribute_Names) throws IOException {
// Sample attributes and their classification are written in the code for now. A database or file read is required later
ReadData data = new ReadData();
Object[][] rawData = data.ReadData();
// Create a Map that contains all the samples
Map<Object,List<Sample>> sample_set = new HashMap<Object,List<Sample>>();
// Read the data in each row
// Read the attributes of the Sample and its classification, and then construct a Sample object from these data
// then divide the sample set according to the last 0,1 of the sample.
for (Object[] row:rawData) {
// Create a Sample object, add it to the Map without processing it once, and return it together
Sample sample = new Sample();
int i=0;
// A row of data is processed at a time to form the values of each attribute in a sample
for (int n=row.length-1; i<n; ++i) {
sample.setAttribute(attribute_Names[i],row[i]);
}
// classify the processed sample according to 0,1, where I is already in the last digit
sample.setCategory(row[i]);
// Add the parsed row to the whole sorted sample. Row [I] now refers to the sorted set
List<Sample> samples = sample_set.get(row[i]);
// Return value if there is a sample, and add it if there is no sample for this category
if(samples == null){
samples = new LinkedList<Sample>();
sample_set.put(row[i],samples);
}
// Whether the sample set of the current classification is empty or not, add the separated sample to it.
// If is entered only when the first several categories are not completed.
samples.add(sample);
}
// Return a list Map for each category (category --> category sample)
return sample_set;
}
/ * * * * * * * * * * * * * * * * * * * * * * * this is the class of the decision tree * - the decision tree (non-leaf nodes), Each non-leaf node in the decision tree guides a decision tree * Each non-leaf node contains a branch attribute and multiple branches, and each value of the branch attribute corresponds to a branch that guides a sub-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(a){
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(a){
returnchildren.keySet(); }}/* ********************* * this is the function to choose the Best Test Attribute * it will be used in the GenerateDecisionTree () * Selects the best test attribute. Optimal means that if the branches of selected test attributes are selected, the sum of information entropy required to determine the classification of the new sample * from each branch is minimum, which is equivalent to the maximum information gain obtained by determining the test attributes of the new sample * return array: The properties of the subscript, the sum of the information entropy, the Map (attribute value - > (classification - > sample list)) * * * * * * * * * * * * * * * * * * * * * * /
static Object[] chooseBestTestAttribute(Map<Object,List<Sample>> categoryToSamples,String[] attribute_Names){
// The subscript of the optimal attribute!
int minIndex = -1;
// Minimum information entropy
double minValue = Double.MAX_VALUE;
// The best branching scheme!
Map<Object,Map<Object,List<Sample>>> minSplit = null;
// For each attribute, the information entropy should be calculated, and the minimum selection is the optimal, Ent(D)
for (int attrIndex = 0; attrIndex<attribute_Names.length; ++attrIndex) {// Count the total number of samples
int allCount = 0;
Attribute Value [Key]->(category [Key]-> sample list [Value]) [Value]
// The curSplits splits all the samples corresponding to one of the selected values of the current field. The set of all Dv's is also... To be determined!
Map<Object,Map<Object,List<Sample>>> curSplits = new HashMap<Object,Map<Object,List<Sample>>>();
/* The information gain of an attribute is calculated. To get a data, the category - > sample set 】 | V analytical data on, release the key and the value of which the key for the category, the value for this category of all samples | V for each sample value inside read, respectively: Read the value of the current attribute, and then build up the sample set of all the samples with the same value of the current attribute; | V here try to make each sample set into classified sample set! | V this round down and get on the property of the set of attribute values corresponding to different samples In the collection in the collection and classification of sample set! For example, this round of age, you end up with the good guys over 40, the bad guys between 30 and 40, the bad guys and the good guys under 30, the bad guys and you end up with a total of 6 samples, right? It's just a two-layer wrapper around key-value pairs already in the Map. Classification -- > - are a Map - 1 attribute values, such as students - > classified two types of | a property (this is curSplits this Map ontology) -- -- > a negative classification Map (draw conveniently reuse here!) 2 - attribute value, such as not students - > classified two classes | - are classification -- > a Map * /
/* * Set< map.entry
> entrySet () * Returns: A set view of the mappings contained in this map * Entry this data type is roughly the same as pair in C++
,v>
for (Entry<Object,List<Sample>> entry : categoryToSamples.entrySet()) {
// Get the category name of the data
Object category = entry.getKey();
// Get this category again! Note the category, not the attribute value! All samples corresponding to the category!
List<Sample> samples = entry.getValue();
// Then we will split each sample into the Dv based on the attribute value and return it to the curSplits
for (Sample sample : samples ) {
// Get the value of the current sample based on the current attribute to be calculated
Object attrValue = sample.getAttribute(attribute_Names[attrIndex]);
GetAttribute (); getAttribute(); getAttribute(); getAttribute(); getAttribute()
Map<Object,List<Sample>> split = curSplits.get(attrValue);
// Since you can't get a complete Map at first, you need to build it from scratch!
if (split == null) {
// Create a Map of the attribute values as follows: attribute values ->(All Sample) see Line156
split = new HashMap<Object,List<Sample>>();
curSplits.put(attrValue,split);
}
// When the value of this attribute is equal to a certain value, the corresponding classification sample set can be read.
List<Sample> splitSamples = split.get(category);
// If you can't read the classification of the current attribute, create a sample set with the same attribute value as the current sample.
if (splitSamples == null) {
splitSamples = new LinkedList<Sample>();
// Combine the current attribute values to form a set and put it in Map--split.
split.put(category,splitSamples);
}
// Add the current sample to the sample set. !!!!! You can just do that, right? %%%%%% is passing by reference?
/ / yes! No new is just a reference pass! Oh, my gosh! It was all forgotten! ?
splitSamples.add(sample);
}
// A counter that counts samples counts the number of samples under the current attribute.
allCount += samples.size();
}
// The information gain register for the current attribute value
double curValue = 0.0;
// Read the sample set for each attribute value under the current attribute
for (Map<Object,List<Sample>> splits : curSplits.values()) {
double perSplitCount = 0;
// Read the size of the sample set Dv for each attribute value to get the total number of samples for this attribute value, regardless of category
for (List<Sample> list : splits.values()) {
// The total number of branches in the current sample
perSplitCount += list.size();
}
// Count the information entropy and information gain of the current branch.
double perSplitValue = 0.0;
// Calculate the information entropy corresponding to each attribute value
for (List<Sample> list : splits.values() ) {
// Here is completely ID3 algorithm information entropy calculation formula! ENT(D) = -sum (Pk*log2(Pk)) see Machine Learning P75
double p = list.size() / perSplitCount;
// It looks like p is less than 1 anyway, so using p -= is actually adding?
perSplitValue -= p*(Math.log(p)/Math.log(2));
}
// This is not an information gain. It's the sum of the entropy of information.
curValue += (perSplitCount / allCount) * perSplitValue;
}
// Select the minimum information entropy is optimal! ?
if(minValue > curValue){ minIndex = attrIndex; minValue = curValue; minSplit = curSplits; }}// Return a list index of attributes with minimum sum of entropy + minimum sum of entropy + minimum sum of entropy corresponding to the subtree!
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){
/ / output behind this to determine how many | -- -- -- -- -- that is, decision level
for (int i=0; i < level ; ++i){ System.out.print("| -- -- -- -- --");
}
// Only for all child nodes? Everything except the root node.
if(from ! =null){
System.out.printf("(%s):",from);
}
// If this thing has child nodes, keep recursing
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 there is only one sample, the category of the sample is used as the category of the new sample
if(categoryToSamples.size() == 1)
return categoryToSamples.keySet().iterator().next();
// If no decision attribute is provided (i.e., no list of attribute names is given to you), then the category with the most samples in the sample set is the category for the new sample, i.e., the new category is voted for
if (attribute_Names.length == 0) {
int max = 0;
Object maxCategory = null;
// If there is no attribute list, take the category of the larger sample set as the category of this category.
for (Entry<Object,List<Sample>> entry : categoryToSamples.entrySet() ) {
int cur = entry.getValue().size();
if(cur > max) { max = cur; maxCategory = entry.getKey(); }}return maxCategory;
}
// If there is a list of properties, select the properties for the test.
Object[] rst = chooseBestTestAttribute(categoryToSamples,attribute_Names);
// The root node of the decision tree is selected, and the attributes of the branches are the selected test attributes
Tree tree = new Tree(attribute_Names[(Integer)rst[0]]);
// Used test properties cannot be selected as test properties again
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]; }}// Generate a new branch based on the properties of the branch
@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();
// Recursive call again? Would that be the end of me? No more than 20 floors! That's the bottom line!
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[] {"Color"."Roots"."Knock"."Texture"."Time"."Touch"};
// Read the sample set
Map<Object,List<Sample>> samples = readSample(attribute_Names);
// Generate a decision tree
Object decisionTree = generateDecisionTree(samples,attribute_Names);
// Outputs the decision tree
outputDecisionTree(decisionTree,0.null); }}Copy the codeAlso note that because this uses the database, so need to load the dependency file package! See here:
The solution! https://blog.csdn.net/sakura_yuan/article/details/51730493
The end result is absolutely stunning! Ok?? Bang!!!!!
/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/Gradu ation_Design/mysql-connector-java-5.1.44-bin.jar ZZB_JCS [texture =? | -- -- -- -- -- (= slightly paste texture) : / touch =? | -- - | -- -- -- -- -- (touch = hard sliding) : [* CATEGORY = n *] | -- - | -- -- -- -- -- (soft tactility = stick) : [* CATEGORY = is *] | -- -- -- -- -- (= fuzzy texture) : [* CATEGORY = n *] | -- -- -- -- -- (= texture clear) : / roots =? | -- - | -- -- -- -- -- (roots = proofed) : [* CATEGORY = n *] | -- - | -- -- -- -- -- (roots = curled up) : [* CATEGORY = is *] | -- - | -- -- -- -- -- (roots = slightly curled) : [color =?] | -- - | -- - | -- -- -- -- -- color = (green) : [* CATEGORY = is *] | -- - | -- - | -- -- -- -- -- (color = black) : / touch =? | -- - | -- - | -- - | -- -- -- -- -- (touch = hard sliding) : [* CATEGORY = is *] | -- - | -- - | -- - | -- -- -- -- -- (soft tactility = stick) : [* CATEGORY = n *] Process finished with exit code0
Copy the codeAfter the body
Get up early today (8:30?) I had breakfast at baijing Garden in the west, fried dough sticks and soup buns, although a little expensive, but delicious! I hope I can have breakfast every day! Ash!!!! That’s it! Let’s go to lunch!
