实现命令行CD命令

有的面试题要求实现cd命令，实现思路如下：
扫描要cd到的目标路径，以目录分割符/作为切换扫描的分割点，如果扫描到.号则当前目录不变，如果扫描到“…“字符串，则把从当前路径从后往前找/号，当前路径就是从前面到这个/号的位置的内容。如果扫描到其他合法字符串就将当前内容拼上这个字符串。
举个例子：
当前路径是：/a/b/c
要切到…/d/e
扫描目标目录，分别要扫描到"…",“d”,“e"三个字符串
当扫描到”…“时，从”/a/b/c"后面往前扫描到第一个"/"，当前路径变为"/a/b"，
当扫描到"d"时，当前路径加上"d"，即"/a/b/d"
当扫描到"e"时，当前路径加上"e"，即"/a/b/d/e"
实现的算法过程，如果考虑空间的话，直接在源字符串上操作，如果不考虑空间则比较简单，每次切换成生成新字符串，另外还要考虑一些特殊情况如第一个字符就是"/"开始，那么路径就直接切到这个地方

public class WorkSpace3 {
    private String path;
    public WorkSpace3(String dir) {
        this.path = dir;
    }

    private char[] set(char[] arr, int index, char ch) {
        if (index >= arr.length) {
            char[] t = new char[arr.length * 2];
            for (int i = 0; i < arr.length; i++) {
                t[i] = arr[i];
            }
            t[index] = ch;
            return t;
        } else {
            arr[index] = ch;
            return arr;
        }
    }

    private boolean isValidChar(char ch) {
        if ((ch >= 'a' && ch <= 'z') || (ch == '.')) {
            return true;
        } else {
            return false;
        }
    }

    private char[] append(char[] arr, int index, String str) {
        if (index + str.length() > arr.length) {
            char[] t = new char[arr.length * 2];
            for (int i = 0; i < arr.length; i++) {
                t[i] = arr[i];
            }
            for (int i = 0; i < str.length(); i++) {
                t[index + i] = str.charAt(i);
            }
            return t;
        } else {
            for (int i = 0; i < str.length(); i++) {
                arr[index + i] = str.charAt(i);
            }
            return arr;
        }
    }

    public void changeDirectory(String target) {
        char[] arr = target.toCharArray();
        if (arr.length == 0) {
            return;
        }

        char[] temp = path.toCharArray();
        int p = temp.length;
        int l = 0;
        for (int i = 0; i <= arr.length; i++) {
            if (i < arr.length && (arr[i] == '/' || i == arr.length) {
                if (i == 0) {
                    p = 0;
                    //set(p++, '/');
                    l = i + 1;
                } else {
                    String str = new String(arr, l , i - l);
                    l = i + 1;
                    if (str.equals(".")) {
                        // current dir do nothing
                    } else if (str.equals("..")) {
                        // up parent dir
                        for (int j = p - 1; j >= 0; j--) {
                            if (temp[j] == '/') {
                                p = j;
                                break;
                            }
                        }
                    } else {
                        // append
                        temp = set(temp, p++, '/');
                        temp = append(temp, p, str);
                        p += str.length();
                    }
                }
            } else if (i < arr.length && isValidChar(arr[i])) {

            } else {
                return;
            }
        }
        this.path = new String(temp, 0, p);
    }

    public void show() {
        System.out.println(path);
    }
}

这里实现上让循环次数等于目标字符串长度+1，这样可以减少后循环后多一次的重复的逻辑判断，比如在遇到"/“或者”…“或”.","def"这种只有一个字符和没有没有路径分割符的情况。

总结

这道题个人认为还是考察对字符的操作能力，比如缓存不足，特殊情况，字符扫描等，实现方法有很多，扫描过程如果是更复杂的可以使用编译原理中的词法分析，不过实现起来也稍微复杂。