如何使用迭代器编写令牌 [已关闭]

HasNext（）

public boolean hasNext() {
    return !this.buffer.isEmpty();
}


public MDToken next() {
    // TODO - Your Code Starts Here
    if (buffer.isEmpty())
        return current=null;

    String[] aa=buffer.split("\n");
    String check=aa[0];

    System.out.println(check);
}

public class MDTokenizer {
String buffer;
MDToken current;

public MDTokenizer(String mdContent) {
    this.buffer = mdContent.trim();


}

public boolean hasNext() {
    return !this.buffer.isEmpty();
}

public MDToken next() {
    // TODO - Your Code Starts Here
    if (buffer.isEmpty())
        return current=null;

    String[] aa=buffer.split("\n");
    String check=aa[0];
    
    if(String.valueOf(check.charAt(0)).equals("-")){
        String value=check.trim().substring(2,check.length()).trim();
        MDTokenType type =MDTokenType.UNORDERED_ITEM;
        current=new MDToken(type,value,-1);
    }

    if(check.contains(".")){
        String value=check.substring(check.indexOf(".")+1).trim();
        MDTokenType type =MDTokenType.ORDERED_ITEM;
        int level=Integer.parseInt(String.valueOf(check.charAt(0)));
        System.out.println(11);
        current=new MDToken(type,value,level);

    }
    buffer=buffer.substring(check.length()).trim();
    return current;      // You may make changes to this line
    // TODO - Your Code Ends Here
}

工厂方法：

public interface Notification { void notifyUser();
  }
public class SMSNotification implements Notification{ @Override
    public void notifyUser() {
        System.out.println("Sending an SMS Notification!"); }
    }
public class PushNotification implements Notification{ @Override
    public void notifyUser() {
        System.out.println("Sending a Push Notification!"); }
    }
public class EmailNotification implements Notification{ @Override
    public void notifyUser() {
        System.out.println("Sending an E-Mail Notification!"); }
    }

public class NotificationFactory {
    public Notification createNotification(String msg, String c) {
        String channel = c;
    
        if (channel == null || channel.isEmpty()) {
            List<String> l = Arrays.asList("SMS", "EMAIL", "PUSH");
            Random rand = new Random();
            channel = l.get(rand.nextInt(l.size()));
    }
     if ("SMS".equalsIgnoreCase(channel)) { 
         return new       SMSNotification();
      }
    else if ("EMAIL".equalsIgnoreCase(channel)) {
         return new EmailNotification(); }
    else if ("PUSH".equalsIgnoreCase(channel)) {
         return new           PushNotification();
    }
        return null; }
  }

单身 人士：

public class SingletonConnection {
//note that the constructor and instance variable are private
private static SingletonConnection instance = null;
private     SingletonConnection(){};
    //Note that this is the only method that can be accessed
    public static SingletonConnection getInstance(){ 
        if(instance == null) {
            System.out.println("Instance created!!!!");
            instance = new SingletonConnection(); 
        }else
            System.out.println("Instance has et");
        }
    }return instance
}

观察者：

public interface Subject {
//interface Subject 
   public void   attach(Observer observer); 
   public void   detach(Observer observer); 
   public void   notifyAllObservers();
}
public class Place implements Subject{
//class Place
    private ArrayList<Observer> observers; 
    private String name;
    public Place(String name) {
        this.name = name;
        observers = new ArrayList<Observer>();
     }
    public void setCorona() {
    //you can add some conditions here (boolean corona)
        notifyAllObservers(); 
    }

    @Override
    public void attach(Observer observer) {
         observers.add(observer);
    }
    @Override
    public void detach(Observer observer)
    {     observers.remove(observer);
    }
    @Override
    public void notifyAllObservers() {
         for(Observer obs :     this.observers)
             obs.update(this.name + " has a confirmed case. "); }
         }
    }


public interface Observer { 
    public void update(String msg);
}
    public class Customer implements Observer{ 
        private String name;
    public Customer(String name) { 
        this.name = name;
    }
@Override
public void update(String msg) {
    System.out.println("Hey " + this.name + "! Message for you: " +      msg );
} 

测试：

@Test（timeout = 1000，expected = ComponentOutOfRangeException.class） public void testtest （） throws ComponentOutOfRangeException{ this.calculator.calculateMark（-1，-1，-1，-1，false，false）;

1. 参与

   公共类 MDTokenizer { 字符串缓冲区; MDToken 电流;

   公共 MDTokenizer（String mdContent） { this.buffer = mdContent.trim（）;

   }

   公共布尔值 hasNext（） { 返回 ！this.buffer.isEmpty（）; }

   public MDToken next（） { TODO - 您的代码从这里开始 如果 （buffer.isEmpty（）） 返回 current=null;

    String[] aa=buffer.split("\n");
    String check=aa[0];
   
    if(String.valueOf(check.charAt(0)).equals("-")){
        String value=check.trim().substring(2,check.length()).trim();
        MDTokenType type =MDTokenType.UNORDERED_ITEM;
        current=new MDToken(type,value,-1);
    }
   
    if(check.contains(".")){
        String value=check.substring(check.indexOf(".")+1).trim();
        MDTokenType type =MDTokenType.ORDERED_ITEM;
        int level=Integer.parseInt(String.valueOf(check.charAt(0)));
        System.out.println(11);
        current=new MDToken(type,value,level);
   
    }
    buffer=buffer.substring(check.length()).trim();
    return current;      // You may make changes to this line
    // TODO - Your Code Ends Here
   

   }

接口：

public interface ParticipantState {
ParticipantState solveRiddle(String input, Riddle[] riddleList, int whichRiddle) throws RiddleException;

}

public class InProgressState implements ParticipantState{

@Override
public ParticipantState solveRiddle(String input, Riddle[] riddleList, int whichRiddle) throws RiddleException {

    if (riddleList[whichRiddle].checkAnswer(input) && whichRiddle == riddleList.length-1){

        riddleList[whichRiddle].setSolved();
        return new EscapedState();
    }else if (riddleList[whichRiddle].checkAnswer(input)){

        riddleList[whichRiddle].setSolved();
        return this;
    }
    return this;
}

}

public class HelpState implements ParticipantState{


@Override
public ParticipantState solveRiddle(String input, Riddle[] riddleList, int whichRiddle) throws RiddleException {
    if (riddleList[whichRiddle].checkAnswer(input) && whichRiddle == riddleList.length-1) {
        riddleList[whichRiddle].setSolved();
        return new EscapedState();
    }
    riddleList[whichRiddle].setSolved();
    return new InProgressState();
}

}

public class EscapedState implements ParticipantState {


@Override
public ParticipantState solveRiddle(String input, Riddle[] riddleList, int whichRiddle) throws RiddleException {
    throw  new RiddleException("No more riddles");
}

}

观察者：

public interface Observer {
void updateHelp(Participant p);
void updateEscape(Participant p);
boolean hasAskedForHelp(Participant p);
boolean hasEscaped(Participant p);
}

import java.util.ArrayList;

导入 java.util.Arrays; 导入 java.util.List;

public 类 GameMaster 实现 Observer{ 公共列表 helpedParticipants = new ArrayList<>（）;

public List<Participant> escapedParticipants = new ArrayList<>();

@Override
public void updateHelp(Participant p) {

    helpedParticipants.add(p);

}

@Override
public void updateEscape(Participant p) {
    escapedParticipants.add(p);
}

@Override
public boolean hasAskedForHelp(Participant p) {

    if (helpedParticipants.contains(p)){
        return true;
    }
    return false;
}

@Override
public boolean hasEscaped(Participant p) {

    if (escapedParticipants.contains(p)){
        return true;
    }
    return false;
}

}

保存：

public void save(String tableName, List<Customer> customers) {

    File f = new File(FileUtil.getTableFileName(tableName));

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    try {
        // make the xml tree
        // use factory to get the instance of document builder
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document doc = db.newDocument();
        // Root element <customers>
        Element rootElem = doc.createElement(Customer.KEY_ROOT);
        doc.appendChild(rootElem);

        for (Customer customer : customers) {
            Element customerElem = doc.createElement(Customer.KEY_ELEMENT);
            rootElem.appendChild(customerElem);

            // child element <ID> under <customer>
            Element cid = doc.createElement(Customer.KEY_ID);
            cid.appendChild(doc.createTextNode(Integer.toString(customer.getId())));
            customerElem.appendChild(cid);

            if (customer.getName() != null) {
                Element name = doc.createElement(Customer.KEY_NAME);
                name.appendChild(doc.createTextNode(customer.getName()));
                customerElem.appendChild(name);
            }

            if (customer.getAddress() != null) {
                Element address = doc.createElement(Customer.KEY_ADDRESS);
                address.appendChild(doc.createTextNode(customer.getAddress()));
                customerElem.appendChild(address);
            }

            if (customer.getCity() != null) {
                Element city = doc.createElement(Customer.KEY_CITY);
                city.appendChild(doc.createTextNode(customer.getCity()));
                customerElem.appendChild(city);
            }

            if (customer.getPostCode() != null) {
                Element postCode = doc.createElement(Customer.KEY_POSTCODE);
                postCode.appendChild(doc.createTextNode(customer.getPostCode()));
                customerElem.appendChild(postCode);
            }

            if (customer.getCountry() != null) {
                Element country = doc.createElement(Customer.KEY_COUNTRY);
                country.appendChild(doc.createTextNode(customer.getCountry()));
                customerElem.appendChild(country);
            }
        }
        // save the xml file
        // Transformer is for process XML from a variety of sources and write the
        // transformation
        // output to a variety of sinks
        Transformer transformer = TransformerFactory.newInstance().newTransformer();

        // set xml encoding to utf-8
        transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
        // pretty print
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");

        DOMSource source = new DOMSource(doc);
        StreamResult result = new StreamResult(f);
        transformer.transform(source, result);

    } catch (Exception e) {
        e.printStackTrace();
    }
}

对于负载：

public List<Customer> load(String tableName) {
    
    List<Customer> customers = new ArrayList<>();

    File f = new File(FileUtil.getTableFileName(tableName));
    if (!f.exists()) {
        return customers;
    }



    try {
        // 创建 DocumentBuilderFactory 和 DocumentBuilder 来解析 XML 文件
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();

        // 解析 XML 文件并获取 Document 对象
        Document doc = db.parse(f);

        // 获取所有客户元素
        NodeList customerElements = doc.getElementsByTagName(Customer.KEY_ELEMENT);

        for (int i = 0; i < customerElements.getLength(); i++) {
            Element customerElem = (Element) customerElements.item(i);

            // 从 XML 中提取客户信息
            int id = Integer.parseInt(customerElem.getElementsByTagName(Customer.KEY_ID).item(0).getTextContent());
            String name = null;
            String address = null;
            String city = null;
            String postCode = null;
            String country = null;

            // 检查是否存在 Name 元素，如果存在则提取值
            if (customerElem.getElementsByTagName(Customer.KEY_NAME).getLength() > 0) {
                name = customerElem.getElementsByTagName(Customer.KEY_NAME).item(0).getTextContent();
            }

            // 检查是否存在 Address 元素，如果存在则提取值
            if (customerElem.getElementsByTagName(Customer.KEY_ADDRESS).getLength() > 0) {
                address = customerElem.getElementsByTagName(Customer.KEY_ADDRESS).item(0).getTextContent();
            }

            // 检查是否存在 City 元素，如果存在则提取值
            if (customerElem.getElementsByTagName(Customer.KEY_CITY).getLength() > 0) {
                city = customerElem.getElementsByTagName(Customer.KEY_CITY).item(0).getTextContent();
            }

            // 检查是否存在 Postcode 元素，如果存在则提取值
            if (customerElem.getElementsByTagName(Customer.KEY_POSTCODE).getLength() > 0) {
                postCode = customerElem.getElementsByTagName(Customer.KEY_POSTCODE).item(0).getTextContent();
            }

            // 检查是否存在 Country 元素，如果存在则提取值
            if (customerElem.getElementsByTagName(Customer.KEY_COUNTRY).getLength() > 0) {
                country = customerElem.getElementsByTagName(Customer.KEY_COUNTRY).item(0).getTextContent();
            }

            // 创建 Customer 对象并添加到列表
            Customer customer = new Customer();
            customer.setId(id);
            customer.setName(name);
            customer.setAddress(address);
            customer.setCity(city);
            customer.setPostCode(postCode);
            customer.setCountry(country);

            customers.add(customer);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }


    // END YOUR CODE

    return customers;
}

对于令牌：

private String _buffer;

public Tokeniser(String buffer) {
    this._buffer = buffer;
    int idx = this._buffer.indexOf(";");
    if (idx > 0) {
        this._buffer = this._buffer.substring(0, idx);
    }
}
public Token next() {
    if (_buffer.isEmpty())
        return null;

    // TODO: Complete this method
    // START YOUR CODE
    
    int indexV= _buffer.indexOf("V");

    String[] test=_buffer.trim().split(" ");

    if(test[0].contains("INSERT")){
        String test1=_buffer.substring(0,indexV);
        if(!test1.contains("(") || !test1.contains(")")){
            return null;
        }else{
            return new Token(Token.Type.INSERT_INTO,test1.substring(test1.indexOf("O")+1).trim(),test1.trim());
        }
    }else if (test[0].contains("VALUES")) {
        String test1 = _buffer.substring(0, _buffer.indexOf(")")+1);
        if (!test1.contains("(") || !test1.contains(")")) {
            return null;
        } else {
            return new Token(Token.Type.VALUES, test1.substring(test1.indexOf("(")), test1.trim());
        }

    }
    // You are allowed to remove the following 'return null' if necessary
    return null;

    // END YOUR CODE
}

public Token takeNext() {
    Token nextToken = next();
    if (nextToken == null)
        return null;

    if (nextToken.originalTokenStr.length() < _buffer.length()) {
        _buffer = _buffer.substring(nextToken.originalTokenStr.length()).trim();
    } else {
        _buffer = "";
    }

    return nextToken;
}

public boolean hasNext() {
    return next() != null;
}

对于解析：

while (tokeniser.hasNext()){
        Token aa=tokeniser.takeNext();
        if(aa.type== Token.Type.INSERT_INTO){
            String[] 
check=aa.value.substring(aa.value.indexOf("(")+1,aa.value.indexOf(")")).split(",");
            for(String cc:check){
                if(!cc.equals("ID") && !cc.equals("Name") && !cc.equals("Address")&& !cc.equals("City") && !cc.equals("Postcode") && !cc.equals("Country")){
                    write=false;
                }
            }
    }
}

RB树：

public Node<T> root; // The root node of the tree

/**
 * Implement this method to check the property1. You may define additional
 * helper methods to complete the task
 * Each node is either PINK, PURPLE or MAGENTA.
 * @return
 */
public Boolean testProp1() {
    //START YOUR CODE
    
    return testProphelp1(root);
    
    //END YOUR CODE
}

public Boolean testProphelp1( Node root) {
    //START YOUR CODE

    if(root==null){
        return true;
    }

    if(root.colour !=Colour.PINK && root.colour !=Colour.PURPLE && root.colour !=Colour.MAGENTA){
        return false;
    }

    return testProphelp1(root.left) && testProphelp1(root.right);

    //END YOUR CODE
}



/**
 * Implement this method to check the property2. You may define additional
 * helper methods to complete the task
 * Root and every leaf (NULL pointer) are PINK.
 * @return
 */
public Boolean testProp2() {
    //START YOUR CODE
    
    return testPropHelp2(root) && root.colour==Colour.PINK;
    
    //END YOUR CODE
}
public Boolean testPropHelp2(Node root) {
    //START YOUR CODE

    if(root==null){
        return true;
    }

    if(root.value==null){
        if(root.colour!=Colour.PINK){
            return false;
        }
    }

    return testPropHelp2(root.right) &&testPropHelp2(root.left);

    //END YOUR CODE
}

/**
 * Implement this method to check the property3. You may define additional
 * helper methods to complete the task
 * Each path from Root-to-Leaf has the same number of PINK nodes.
 * @return
 */
public Boolean testProp3() {
    //START YOUR CODE
    
    return testPropHelp3(root)!=-1;
    
    //END YOUR CODE
}

public int testPropHelp3( Node root) {
    //START YOUR CODE

    if(root==null){
        return 0;
    }

    int leftCount=testPropHelp3(root.left);
    int rightCount=testPropHelp3(root.right);


    if(leftCount==-1|| rightCount==-1 || leftCount!=rightCount){
        return -1;
    }

    if(root.colour==Colour.PINK){
        return rightCount+=1;
    }


    return rightCount;

    //END YOUR CODE
}

另一个令牌：

private String buffer;      //save text
private Token currentToken; //save token extracted from next()
public MyTokenizer(String text) {
    buffer = text;      // save input text (string)
    next();     // extracts the first token.
}
public void next() {
    
    buffer = buffer.trim(); // remove whitespace

     if(buffer.isEmpty()) {
        currentToken = null;    // if there's no string left, set currentToken null and return
        return;
     }

    // ########## YOUR CODE STARTS HERE ##########

     String mytext=buffer;
    for(int i=0;i<mytext.length();i++){
        if(String.valueOf(mytext.charAt(i)).equals(" ")){
            if(i>0){
                mytext=buffer.substring(0,i);
            }else{
                mytext=buffer;
            }
            break;
        }if(!Character.isLetter(mytext.charAt(i)) && !Character.isDigit(mytext.charAt(i)) && !String.valueOf(mytext.charAt(i)).equals(" ")){
            if(i>0){
                mytext=buffer.substring(0,i);
            }else{
                if(mytext.length()==1){
                    mytext=buffer;
                }else{
                    mytext=buffer.substring(0,i+1);
                }
            }
            break;
        }
    }

    int upper=0;
    int lower=0;
    int number=0;


    for(int i=0;i<mytext.length();i++){
        if(Character.isDigit (mytext.charAt(i))){
            number+=1;
        }else if( (Character.isDigit(mytext.charAt(i)) || Character.isLetter(mytext.charAt(i))) && String.valueOf(mytext.charAt(i)).equals(String.valueOf(mytext.charAt(i)).toUpperCase())){
            upper+=1;
        }else if( (Character.isDigit(mytext.charAt(i)) || Character.isLetter(mytext.charAt(i)) )&&String.valueOf(mytext.charAt(i)).equals(String.valueOf(mytext.charAt(i)).toLowerCase())){
            lower+=1;
        }
    }


    if(upper==0 &&lower>0){
        currentToken=new Token(mytext, Token.Type.LOWER_CASE_WORD);

    }else if(lower==0 && upper>0){
        currentToken=new Token(mytext, Token.Type.UPPER_CASE_WORD);

    }else if(lower>0 && upper>0 &&lower+upper<4){
        currentToken=new Token(mytext, Token.Type.SHORT_CAMEL_CASE_WORD);

    }else if(lower>0 && upper>0 &&lower+upper>4){
        currentToken=new Token(mytext, Token.Type.LONG_CAMEL_CASE_WORD);

    }else if(lower==0 && upper==0 &&number>0){
        currentToken=new Token(mytext, Token.Type.INTEGER_NUMBER);

    }else {
        currentToken=new Token(mytext, Token.Type.NON_ALPHANUMERIC);
    }
   
    // ########## YOUR CODE ENDS HERE ##########
    
    // Remove the extracted token from buffer
    int tokenLen = currentToken.getValue().length();
    buffer = buffer.substring(tokenLen);
}
 public Token current() {
    return currentToken;
}
public boolean hasNext() {
    return currentToken != null;
}

MyTokenizer myTokenizer = new MyTokenizer(text);
    
    while (myTokenizer.hasNext()){
        if(myTokenizer.current().getType().equals(Token.Type.UPPER_CASE_WORD)){
            List<String> aaa=new ArrayList<>();
            int number=myTokenizer.current().getLength();
            MyTokenizer test=new MyTokenizer(text);
            while (test.hasNext()){
                if(test.current().getType().equals(Token.Type.UPPER_CASE_WORD)&&test.current().getLength()==number ){
                    aaa.add(test.current().getValue());
                }
                test.next();
            }
            aa.insert(number,aaa);
        }
        myTokenizer.next();
    }
    return aa; // change the return
    // ########## YOUR CODE ENDS HERE ##########
}


                        33
                      /    \
                    11      88
                   / \    /    \
                  10  16  43   100
                     \          \
                      18        120

上一页：33,11,10,16,18,88,43,100,123

// Pre-Order traversal
// Node.Left Subtree.Right Subtree
public List<Node> preorder() {
    List<Node> list = new ArrayList<>();
    preOrderHelper(this.root, list);
    return list;
}
private void preOrderHelper(Node node, List<Node> list) {
    if (node != null && node.key != null) {
        list.add(node);
        preOrderHelper(node.left, list);
        preOrderHelper(node.right, list);
    }
}

依次：10,11,16,18,33,43,88,100,120

// In-Order traversal
// Left Subtree . Node . Right Subtree
public List<Node> inorder() {
    List<Node> list = new ArrayList<>();
    inOrderHelper(this.root, list);
    return list;
}
private void inOrderHelper(Node node, List<Node> list) {
    if (node != null && node.key != null) {
        inOrderHelper(node.left, list);
        list.add(node);
        inOrderHelper(node.right, list);
    }
}

邮：10,18,16,11,43,120,100,88,33

// Post-Order traversal
// Left Subtree . Right Subtree . Node
public List<Node> postorder() {
    List<Node> list = new ArrayList<>();
    postOrderHelper(this.root, list);
    return list;
}


private void postOrderHelper(Node node, List<Node> list) {
    if (node != null && node.key != null) {
        postOrderHelper(node.left, list);
        postOrderHelper(node.right, list);
        list.add(node);
    }
}

水平：

public List<Node> levelTraversal() {

    List<Node> ret = new ArrayList<>();

    Queue<Node> aa= new LinkedList<>();
    aa.offer(root);

    Stack<Node> bb=new Stack<>();

    while (!aa.isEmpty()){
        int size=aa.size();

        for(int i=0;i<size;i++){

            Node current=aa.poll();

            bb.push(current);

            if(current.left!=null && current.left.key!=null){
                aa.offer(current.left);
            }
            if(current.right!=null && current.right.key!=null){
                aa.offer(current.right);
            }
        }

        while (!bb.isEmpty()){
            ret.add(bb.pop());
        }

    }
    return ret;
}

读取 CSV：

public List<Person> readCsv(String fileName) {

    List<Person> list = new LinkedList<>();

    try{
        FileInputStream aa=new FileInputStream(fileName);
        InputStreamReader bb=new InputStreamReader(aa);
        BufferedReader cc=new BufferedReader(bb);
        String line;
        boolean firstline=true;

        while ((line= cc.readLine())!=null){
            if(firstline){
                firstline=false;
                continue;
            }
            String[] kk=line.split(";");
            list.add(new Person(Integer.parseInt(kk[0]),kk[1],Integer.parseInt(kk[2]),kk[3]));

        }


    }catch (Exception o){
        o.printStackTrace();
    }

    // ########## YOUR CODE ENDS HERE ##########

    return list;
}

编写 xml：

    public void saveXML(RBTree<Integer, Person> tree) {

    if (tree == null) {
        return;
    }


    List<Node> list = tree.levelTraversal();


    // ########## YOUR CODE STARTS HERE ##########
List<Person> aa=new ArrayList<>();

    for(Node bb:list){
    aa.add((Person) bb.getData());
}

File f=new File("people.xml");
    try{
    DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
    DocumentBuilder builder= factory.newDocumentBuilder();
    Document document= builder.newDocument();

    Element TITLE= document.createElement("people");
    document.appendChild(TITLE);

    for(Person person:aa){
        Element element= document.createElement("person");

        if(person.getId()!=null){
            Element addd= document.createElement("id");
            addd.setTextContent(person.getId().toString());
            element.appendChild(addd);
        }

        if(person.getName()!=null){
            Element addd= document.createElement("name");
            addd.setTextContent(person.getName().toString());
            element.appendChild(addd);
        }

        if(person.getAge()!=null){
            Element addd= document.createElement("age");
            addd.setTextContent(person.getAge().toString());
            element.appendChild(addd);
        }

        if(person.getOccupation()!=null){
            Element addd= document.createElement("occupation");
            addd.setTextContent(person.getOccupation().toString());
            element.appendChild(addd);
        }
        TITLE.appendChild(element);

    }

    Transformer transformer= TransformerFactory.newInstance().newTransformer();
    transformer.setOutputProperty(OutputKeys.INDENT,"yes");
    DOMSource source=new DOMSource(document);
    StreamResult result=new StreamResult(f);
    transformer.transform(source,result);

}catch (Exception o){
    o.printStackTrace();
}






    // ########## YOUR CODE ENDS HERE ##########
}

包裹：

    public List<T> inOrder() {
    return this.treeToListInOrder(this);
}

/**
 * Converts tree to list in-order. Helper method of inOrder.
 * @param tree to convert to list.
 * @return in-order list of tree values.
 */
private List<T> treeToListInOrder(Tree<T> tree) {
    List<T> list = new LinkedList<>();

    // Recurse through left subtree.
    if (tree.leftNode.value != null) {
        list.addAll(treeToListInOrder(tree.leftNode));
    }

    // Add current node's value
    list.add(tree.value);

    // Recurse through left subtree.
    if (tree.rightNode.value != null) {
        list.addAll(treeToListInOrder(tree.rightNode));
    }

    return list;
}


public List<T> preOrder() {
    return this.treeToListpreOrder(this);
}

/**
 * Converts tree to list in-order. Helper method of inOrder.
 * @param tree to convert to list.
 * @return in-order list of tree values.
 */
private List<T> treeToListpreOrder(Tree<T> tree) {
    List<T> list = new LinkedList<>();
    list.add(tree.value);
    // Recurse through left subtree.
    if (tree.leftNode.value != null) {
        list.addAll(treeToListpreOrder(tree.leftNode));
    }
    // Add current node's value
    // Recurse through left subtree.
    if (tree.rightNode.value != null) {
        list.addAll(treeToListpreOrder(tree.rightNode));
    }
    return list;
}

 Stack<Parcel> aa=new Stack<>();

    // You may add methods and variables here if you wish

    public IteratorPreOrder() {
        // You may add code here if you wish



        List<Parcel> dd=rightNode.preOrder();
        for(int i=dd.size()-1; i>=0;i--){
            aa.push(dd.get(i));
            System.out.println(dd.get(i).getId()+"ri");

        }

        List<Parcel> bb=leftNode.preOrder();
        for(int i=bb.size()-1; i>=0;i--){
            aa.push(bb.get(i));
            System.out.println(bb.get(i).getId()+"le");
        }

        aa.push(value);


    }

令 牌：

public void next() {

    buffer = buffer.trim(); // remove whitespace
    if (buffer.isEmpty()) {
        currentToken = null; // if there's no string left, set currentToken null and return
        return;
    }

    // ########## YOUR CODE STARTS HERE ##########

将人员保存为人员.xml;从 persons.xml 加载人员;” 字符串[] aa=buffer.trim（）.split（“ ”）;

    if(aa[0].toUpperCase().equals("LOAD")){
        currentToken=new Token(Token.Type.LOAD,aa[0]);
    }else if(!aa[0].contains("xml") && !aa[0].toUpperCase().contains("LOAD") && !aa[0].toUpperCase().contains("SAVE") && !aa[0].toUpperCase().contains("FROM") && !aa[0].toUpperCase().contains("TO") && !aa[0].contains(";")){
        currentToken=new Token(Token.Type.PARAMETER,aa[0]);
        System.out.println(1);

    }else if(aa[0].toUpperCase().equals("FROM") ){
        currentToken=new Token(Token.Type.FROM,aa[0]);
    }else if(aa[0].contains("xml") && !aa[0].contains(";")){
        currentToken=new Token(Token.Type.PARAMETER,aa[0]);
    }else if(aa[0].contains("xml") && aa[0].contains(";") ){
        currentToken=new Token(Token.Type.PARAMETER,aa[0].substring(0,aa[0].indexOf(";")));
    }else if(aa[0].equals(";")){
        currentToken=new Token(Token.Type.TERMINATOR,aa[0]);
    }else if(aa[0].toUpperCase().equals("SAVE")){
        currentToken=new Token(Token.Type.SAVE,aa[0]);
    }else if(aa[0].toUpperCase().equals("TO")){
        currentToken=new Token(Token.Type.TO,aa[0]);
    }else if(aa[0].contains(";") && aa[0].length()>1){
        currentToken=new Token(Token.Type.TERMINATOR,aa[0].substring(0,aa[0].indexOf(";")+1));
    }


    // ########## YOUR CODE ENDS HERE ##########

    // Remove the extracted token from buffer
    int tokenLen = currentToken.getValue().length();
    buffer = buffer.substring(tokenLen);
}

加载和写入：

private void saveTo(SaveCommand sac) {

    List<Person> persons = this.db.load(sac.getKey());

    System.out.println(sac.getFileName());

    File f = new File(sac.getFileName());
    if (f.exists()) {
        f.delete();
    }

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    try {

        DocumentBuilder db = dbf.newDocumentBuilder();
        Document doc = db.newDocument();

        Element root= doc.createElement("persons");
        doc.appendChild(root);

        // TODO
        // ########## YOUR CODE STARTS HERE ##########
        for(Person person:persons){
            Element persondetail= doc.createElement("person");

            if(person.getName()!=null){
                Element aa=doc.createElement("name");
                aa.setTextContent(person.getName());
                persondetail.appendChild(aa);
            }

            if(person.getGender()!=null){
                Element aa=doc.createElement("gender");
                aa.setTextContent(person.getGender());
                persondetail.appendChild(aa);
            }

            if(String.valueOf(person.getAge())!=null){
                Element aa=doc.createElement("age");
                aa.setTextContent(String.valueOf(person.getAge()));
                persondetail.appendChild(aa);
            }

            if(person.getOccupation()!=null){
                Element aa=doc.createElement("occupation");
                aa.setTextContent(person.getOccupation());
                persondetail.appendChild(aa);
            }

            root.appendChild(persondetail);

        }



        // ########## YOUR CODE ENDS HERE ##########

        Transformer transformer = TransformerFactory.newInstance().newTransformer();

        transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");

        // INDENT the xml file is optional, you can
        // uncomment the following statement if you would like the xml files to be more
        // readable
        // transformer.setOutputProperty(OutputKeys.INDENT, "yes");

        DOMSource source = new DOMSource(doc);
        StreamResult result = new StreamResult(f);
        transformer.transform(source, result);

    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * load the persons from the xml file into the database
 * 
 * @param lc
 */
private void loadFrom(LoadCommand lc) {

    List<Person> persons = new LinkedList<>();

    File f = new File(lc.getFileName());
    if (!f.exists()) {
        return;
    }

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder db;
    try {
        db = dbf.newDocumentBuilder();
        Document doc = db.parse(f);

        doc.getDocumentElement().normalize();

        NodeList aa= doc.getElementsByTagName("person");

        // TODO
        // ########## YOUR CODE STARTS HERE ##########

        for(int i=0;i<aa.getLength();i++){
            Element check=(Element) aa.item(i);

            String name=null;

            String gender=null;

            int age=0;

            String occupation=null;

            if(check.getElementsByTagName("name").item(0).getTextContent()!=null){
                name=check.getElementsByTagName("name").item(0).getTextContent();
            }

            if(check.getElementsByTagName("gender").item(0).getTextContent()!=null){
                gender=check.getElementsByTagName("gender").item(0).getTextContent();
            }

            if(check.getElementsByTagName("age").item(0).getTextContent()!=null){
                age=Integer.parseInt(check.getElementsByTagName("age").item(0).getTextContent());
            }

            if(check.getElementsByTagName("occupation").item(0).getTextContent()!=null){
                occupation=check.getElementsByTagName("occupation").item(0).getTextContent();
            }

            persons.add(new Person(name,gender,age,occupation));


        }
        // ########## YOUR CODE ENDS HERE ##########

        this.db.save(lc.getKey(), persons);

    } catch (Exception e) {
        e.printStackTrace();
    }
}

对于令牌：

    public static void main(String[] args) {
    String inputString = "variable!*@#$%^";
    String result = extractLettersAndSymbol(inputString, '*');
    System.out.println(result); // 输出 "variable*"
}

public static String extractLettersAndSymbol(String input, char symbolToKeep) {
    // 构建正则表达式，保留指定符号（symbolToKeep）和英文字母
    String regex = "[^a-zA-Z" + Pattern.quote(String.valueOf(symbolToKeep)) + "]";
    // 使用正则表达式匹配并替换非英文字母和指定符号的字符为空格
    return input.replaceAll(regex, "");
}

数字：

public static void main(String[] args) {
    String inputString = "variable12!*42;@#$%^";
    char[] symbolsToKeep = {'*', ';'};
    String result = extractLettersAndSymbol(inputString, symbolsToKeep);
    System.out.println(result); // 输出 "variable*"
}

public static String extractLettersAndSymbol(String input, char[] symbolToKeep) {
    // 构建正则表达式，保留指定符号（symbolToKeep）和英文字母
    StringBuilder regexBuilder = new StringBuilder("[^a-zA-Z0-9");
    for (char symbol : symbolToKeep) {
        regexBuilder.append(Pattern.quote(String.valueOf(symbol)));
    }
    regexBuilder.append("]");       // 使用正则表达式匹配并替换非英文字母和指定符号的字符为空格
    return input.replaceAll(regexBuilder.toString(), "");
}

tREE 添加： public 节点查找（String key） {

    Node node = null;

    // TODO
    // ########## YOUR CODE STARTS HERE ##########
    node=findhelper(root,key);


    // ########## YOUR CODE ENDS HERE ##########

    return node;
}

public Node findhelper(Node node,String key) {

    if (node == null) {
        return null;
    }

    Node foundNode = null;

    if (node.key != null && node.key.equals(key)) {
        foundNode = node;
        return foundNode;
    }

    // Recursively search in the left subtree
    foundNode = findhelper(node.left, key);
    if (foundNode != null) {
        return foundNode; // Return if the key is found in the left subtree
    }

    // Recursively search in the right subtree
    foundNode = findhelper(node.right, key);
    return foundNode;
}



public List<Node> invertedPreOrder() {

    List<Node> list = new LinkedList<>();

    List<Node> checked = new LinkedList<>();


    // TODO
    // ########## YOUR CODE STARTS HERE ##########

    preOrderHelper(this.root, list);

    for(int i=list.size()-1;i>=0;i--){
        checked.add(list.get(i));
    }

    // ########## YOUR CODE ENDS HERE ##########

    return checked;
}
private void preOrderHelper(Node node, List<Node> list) {
    if (node != null && node.key != null) {
        preOrderHelper(node.left, list);
        preOrderHelper(node.right, list);
        list.add(node);
    }
}

单一职责：

// 不遵循SRP
class FileProcessor {
    public void readFile() {
    // 读取文件的代码
    }

    public void processData() {
    // 处理数据的代码
    }
}

遵循SRP

class FileReader {
    public void readFile() {
    // 读取文件的代码
    }
}

class DataProcessor {
    public void processData() {
    // 处理数据的代码
    }
}

耦合：

class ShoppingCart {
private OrderProcessor orderProcessor;
private PaymentProcessor paymentProcessor;

public void checkout() {
    Order order = orderProcessor.processOrder();
    paymentProcessor.processPayment(order);
}

}

分解：

class ShoppingCart {
    private OrderProcessor orderProcessor;
    private PaymentProcessor paymentProcessor;

    public void checkout() {
        Order order = orderProcessor.processOrder();
        paymentProcessor.processPayment(order);
    }
}

class OrderProcessor {
    public Order processOrder() {
    // 处理订单的代码
    }
}

class PaymentProcessor {
    public void processPayment(Order order) {
        // 处理支付的代码
    }
}

打开和关闭：

interface Shape {
    void draw();
}

class Circle implements Shape {
@Override
public void draw() {
    System.out.println("Draw a circle");
    }
}

如果需要添加新的图形类型，只需创建新的实现了 Shape 接口的类，并在 Drawing 类中调用新图形的 draw 方法，而不需要修改已有的代码。

Liskov 替换：子类更新父方法，不多也不少

接口隔离：大接口转换为多小接口。

依赖反转：

class WindowSensor {
    public boolean isWindowOpen() {
        // 具体实现
        return true;
    }
}

class Alarm {
    private WindowSensor windowSensor = new WindowSensor();

    public void check() {
        if (windowSensor.isWindowOpen()) {
            System.out.println("Window is open. Alert!");
        } else {
            System.out.println("Window is closed. No problem.");
        }
    }
}


interface Sensor {
    boolean isTriggered();
}

class WindowSensor implements Sensor {
@Override
    public boolean isTriggered() {
        // 具体实现
        return true;
    }
}

class Alarm {
    private Sensor sensor;

    public Alarm(Sensor sensor) {
        this.sensor = sensor;
    }

    public void check() {
        if (sensor.isTriggered()) {
            System.out.println("Alert!");
        } else {
            System.out.println("No problem.");
        }
    }
}

违反单一责任原则 （SRP）：

MDToken 类具有多个职责。它负责对 Markdown 标记进行建模、将标记格式化为字符串、根据某些属性检查相等。这违反了 SRP，因为一个类应该只有一个更改原因。如果这些职责中的任何一个发生变化，可能会影响整个班级。

假设需要更改格式逻辑（例如，更改缩进），则需要修改 toString 方法，这不是表示令牌的类的主要职责。

违反开/闭原则 （OCP）：

MDToken 类不会因修改而关闭，因为添加新类型的 Markdown 令牌需要修改现有类。在开放式/封闭式设计中，类应打开以进行扩展，但关闭以进行修改。这意味着您应该能够在不更改现有代码的情况下添加新功能。

如果需要添加新类型的 Markdown 令牌（例如 Table），则需要修改 MDToken 类以适应新的令牌类型。这违反了 OCP，因为该类应该在不改变其现有行为的情况下打开以进行扩展。

单一责任原则 （SRP）：

为了遵守 SRP，我们可以为不同的职责创建单独的类。例如，我们可以创建一个单独的类进行格式设置（MDTokenFormatter），该类采用 MDToken 并将其格式化为字符串。这样，格式设置逻辑将封装在单独的类中，并且对格式设置的更改不会影响主 MDToken 类。

public class MDTokenFormatter {
    public String format(MDToken token) {
        // Formatting logic here
    }
}

为了遵守 OCP，我们可以为 MDToken 类型使用接口，并为每个类型创建单独的类。这样，当引入新的令牌类型时，我们可以创建一个实现接口的新类，而无需修改现有类。

public interface MDToken {
    // Common methods for all token types
}

public class ListRootToken implements MDToken {
    // Implementation for LIST_ROOT type
}

public class OrderedListToken implements MDToken {
    // Implementation for ORDERED_LIST type
}