GgGg Decode

import java.nio.file.*;
import java.util.List;
import java.util.regex.*;

class GGgg{
    public static void main(String[] args){
        List<String> in=null;

        try{in=Files.readAllLines(Paths.get("decode3.txt"));}
        catch(java.io.IOException e){e.printStackTrace();System.exit(-1);}

        if(in.size()==2){
            System.out.println(in.get(0)+"\n");
            System.out.println(in.get(1)+"\n");
            System.out.println(decode(in.get(0),in.get(1)));
        }
        else
            System.out.print("oops!");
    }

    private static String decode(String key,String message){
        Matcher m=Pattern.compile("\\w\\u0020[gG]+").matcher(key);
        GGTree dict=new GGTree();
        StringBuilder out=new StringBuilder();

        while(m.find()){
            int s=m.start();
            int e=m.end();
            dict.build(key.substring(s,s+1).charAt(0),key.substring(s+2,e));
        }
        for(int i=0;i<message.length();i++){
            char currChar=message.charAt(i);
            if(currChar=='g'||currChar=='G'){
                dict.appendToQuery(currChar);
                if(dict.containData()){
                    out.append(dict.getData());
                    dict.resetQuery();
                }
            }
            else{
                out.append(currChar);
            }
        }
        return out.toString();
    }
}
class GGTree{
    private GGNode root;
    private GGNode currQueryNode;
    private StringBuilder query;
    GGTree(){
        root=new GGNode(NodeType.ROOT,GGNode.NO_VALUE);
        currQueryNode=root;
        query=new StringBuilder();
        }
    public void appendToQuery(char g){
        assert g=='g'||g=='G';

        query.append(g);
        if(g=='g'&&currQueryNode.childg_lower!=null){
            currQueryNode=currQueryNode.childg_lower;
        }
        else if(g=='G'&&currQueryNode.childg_upper!=null){
            currQueryNode=currQueryNode.childg_upper;
        }
        else{
            System.out.println("Error in append to query");
        }
    }
    public void resetQuery(){
        this.currQueryNode=root;
        this.query.delete(0,query.length());
    }
    public char getData(){
        return currQueryNode.data;
    }
    public boolean containData(){
        return currQueryNode.data!=GGNode.NO_DATA;
    }
    public void build(char data,String path){
        GGNode currNode=root;
        for(int i=0;i<path.length();i++){
            switch(path.charAt(i)){
                case 'g':
                        if(currNode.childg_lower!=null)
                            currNode=currNode.childg_lower;
                        else{
                            currNode.childg_lower=new GGNode(NodeType.NODE,'g');
                            currNode=currNode.childg_lower;
                        }
                        break;
                case 'G':
                        if(currNode.childg_upper!=null)
                            currNode=currNode.childg_upper;
                        else{
                            currNode.childg_upper=new GGNode(NodeType.NODE,'G');
                            currNode=currNode.childg_upper;
                        }
                        break;
                default:
                        System.out.println("error in build tree");
            }
        }
        currNode.setData(data);
    }
    private enum NodeType{ROOT,NODE}

    private class GGNode{
        private  static final char NO_DATA='\u0000';
        private  static final char NO_VALUE='\uFFFF';
        private NodeType type;
        GGNode childg_lower;
        GGNode childg_upper;
        private char value;
        private char data;

        GGNode(NodeType type,char value){
            this.type=type;
            this.value=value;
            this.data=NO_DATA;
        }
        GGNode(NodeType type,char value,char data){
            this.type=type;
            this.value=value;
            this.data=data;
        }
        private void setData(char data){
            this.data=data;
        }
    }
}