Simplify Path

描述
Given an absolute path for a file (Unix-style), simplify it.
For example,
path = "/home/", => "/home"
path = "/a/./b/../../c/", => "/c"
Corner Cases:
• Did you consider the case where path = "/../"? In this case, you should return "/".
• Another corner case is the path might contain multiple slashes '/' together, such as
"/home//foo/". In this case, you should ignore redundant slashes and return "/home/foo".
分析

这是一道简化路径的题，路径简化的依据是：

当遇到“/../"则需要返回上级目录，需检查上级目录是否为空。

当遇到"/./"则表示是本级目录，无需做任何特殊操作。 

当遇到"//"则表示是本级目录，无需做任何操作。

当遇到其他字符则表示是文件夹名，无需简化。

当字符串是空或者遇到”/../”，则需要返回一个"/"。

当遇见"/a//b"，则需要简化为"/a/b"。

根据这些要求，我需要两个栈来解决问题。

先将字符串依"/"分割出来，然后检查每个分割出来的字符串。

当字符串为空或者为"."，不做任何操作。

当字符串不为".."，则将字符串入栈。

当字符串为"..", 则弹栈（返回上级目录）。

代码

import java.util.ArrayList;

public class SimplifyPath {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String path = "/a/./b/../../c/";
//        String path = "/home/";
//        String[] strs = path.split("/");
//        if(strs[4]=="..")
//        if(strs[4].equals(".."))
//            System.out.println(true); ==比较的是2个对象的地址，而equals比较的是2个对象的内容。
        System.out.println(simplifyPath(path));
    }

    public static String simplifyPath(String path) {
        ArrayList<String> dirs = new ArrayList<String>(); // 当做栈
        String[] strs = path.split("/");
        for (int i = 0; i < strs.length; i++) {
            // dirs.add(strs[i]);
            if (!strs[i].equals("") && !strs[i].equals(".")) {// 当有连续 '///' 时，dir 为空
                if (strs[i] .equals("..")) {
                    if (dirs.size()!=0)
                        dirs.remove(dirs.size() - 1);
                } else {
                    dirs.add(strs[i]);
                }
            }

        }
        StringBuffer out = new StringBuffer();
        if (dirs.size()==0) {
            out.append("/");

        } else {
            for (String dir : dirs)
                out.append("/").append(dir);
        }
        return out.toString();
    }

}

栈操作方法（转）：

public String simplifyPath(String path) {
        if(path == null||path.length()==0)
            return path;
        
        Stack<String> stack = new Stack<String>();
        String[] list = path.split("/");
        
        for(int i=0; i<list.length; i++){
            if(list[i].equals(".")||list[i].length()==0)
                continue;
            else if(!list[i].equals(".."))
                stack.push(list[i]);
            else{
                if(!stack.isEmpty())
                    stack.pop();
            }
        }
        
        StringBuilder res = new StringBuilder();
        
        Stack<String> temp = new Stack<String>();
        while(!stack.isEmpty())  
            temp.push(stack.pop());
        
        while(!temp.isEmpty())
            res.append("/"+temp.pop());
        
        if(res.length()==0)
            res.append("/");
        
        return res.toString();
    }

注意：

判断字符串相等与否要用.equals()，因为是引用类型。

要注意split函数是可以split出空字符的，例如：//b/ 会被split结果为["","b"]。

最后使用StringBuilder进行拼接，由于String在每次对字符串修改时候均会生成一个新的String，效率较低，一般会采用StringBuilder或者StringBuffer来进行字符串修改的操作，StringBuilder是StringBuffer的简易替换，是非线程安全的，而StringBuffer是线程安全的。

在网上还看到有人写的最后还原path没用到第二个栈，是因为可以利用Java中LinkedList 数据类型来表示第一个栈。LinkedList数据类型很强大，包含了栈和队列的实现。所以最后还原时调用removeLast()函数就可以解决顺序问题。