diff --git a/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java b/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java
index ebc57559c6f..1020e27178b 100644
--- a/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java
+++ b/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java
@@ -49,6 +49,7 @@
 import org.apache.zeppelin.interpreter.remote.RemoteInterpreterProcessListener;
 import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion;
 import org.apache.zeppelin.notebook.JobListenerFactory;
+import org.apache.zeppelin.notebook.Folder;
 import org.apache.zeppelin.notebook.Note;
 import org.apache.zeppelin.notebook.Notebook;
 import org.apache.zeppelin.notebook.NotebookAuthorization;
@@ -248,6 +249,9 @@ public void onMessage(NotebookSocket conn, String msg) {
           case NOTE_RENAME:
             renameNote(conn, userAndRoles, notebook, messagereceived);
             break;
+          case FOLDER_RENAME:
+            renameFolder(conn, userAndRoles, notebook, messagereceived);
+            break;
           case COMPLETION:
             completion(conn, userAndRoles, notebook, messagereceived);
             break;
@@ -635,7 +639,7 @@ void permissionError(NotebookSocket conn, String op,
             op, userAndRoles, allowed);
 
     conn.send(serializeMessage(new Message(OP.AUTH_INFO).put("info",
-            "Insufficient privileges to " + op + " notebook.\n\n" +
+            "Insufficient privileges to " + op + "note.\n\n" +
                     "Allowed users or roles: " + allowed.toString() + "\n\n" +
                     "But the user " + userName + " belongs to: " + userAndRoles.toString())));
   }
@@ -749,7 +753,7 @@ private void renameNote(NotebookSocket conn, HashSet<String> userAndRoles,
 
     NotebookAuthorization notebookAuthorization = notebook.getNotebookAuthorization();
     if (!notebookAuthorization.isOwner(noteId, userAndRoles)) {
-      permissionError(conn, "renameNote", fromMessage.principal,
+      permissionError(conn, "rename", fromMessage.principal,
               userAndRoles, notebookAuthorization.getOwners(noteId));
       return;
     }
@@ -765,6 +769,41 @@ private void renameNote(NotebookSocket conn, HashSet<String> userAndRoles,
     }
   }
 
+  private void renameFolder(NotebookSocket conn, HashSet<String> userAndRoles,
+                          Notebook notebook, Message fromMessage)
+      throws SchedulerException, IOException {
+    String oldFolderId = (String) fromMessage.get("id");
+    String newFolderId = (String) fromMessage.get("name");
+
+    if (oldFolderId == null) {
+      return;
+    }
+
+    NotebookAuthorization notebookAuthorization = notebook.getNotebookAuthorization();
+    for (Note note : notebook.getNotesUnderFolder(oldFolderId)) {
+      String noteId = note.getId();
+      if (!notebookAuthorization.isOwner(noteId, userAndRoles)) {
+        permissionError(conn, "rename folder of '" + note.getName() + "'", fromMessage.principal,
+                userAndRoles, notebookAuthorization.getOwners(noteId));
+        return;
+      }
+    }
+
+    Folder oldFolder = notebook.renameFolder(oldFolderId, newFolderId);
+
+    if (oldFolder != null) {
+      AuthenticationInfo subject = new AuthenticationInfo(fromMessage.principal);
+
+      List<Note> renamedNotes = oldFolder.getNotesRecursively();
+      for (Note note : renamedNotes) {
+        note.persist(subject);
+        broadcastNote(note);
+      }
+
+      broadcastNoteList(subject, userAndRoles);
+    }
+  }
+
   private boolean isCronUpdated(Map<String, Object> configA,
       Map<String, Object> configB) {
     boolean cronUpdated = false;
diff --git a/zeppelin-web/src/app/home/home.controller.js b/zeppelin-web/src/app/home/home.controller.js
index 839978fcedd..170a087fba5 100644
--- a/zeppelin-web/src/app/home/home.controller.js
+++ b/zeppelin-web/src/app/home/home.controller.js
@@ -92,6 +92,10 @@
       noteActionSrv.renameNote(node.id, node.path);
     };
 
+    $scope.renameFolder = function(node) {
+      noteActionSrv.renameFolder(node.id);
+    };
+
     $scope.removeNote = function(noteId) {
       noteActionSrv.removeNote(noteId, false);
     };
diff --git a/zeppelin-web/src/app/home/home.html b/zeppelin-web/src/app/home/home.html
index 0b9883e9b8c..4507c8e6863 100644
--- a/zeppelin-web/src/app/home/home.html
+++ b/zeppelin-web/src/app/home/home.html
@@ -39,9 +39,18 @@
     </a>
   </div>
   <div ng-if="node.children != null">
-    <a style="text-decoration: none; cursor: pointer;" ng-click="toggleFolderNode(node)">
-      <i style="font-size: 10px;" ng-class="node.hidden ? 'icon-folder' : 'icon-folder-alt'" /> {{noteName(node)}}
-    </a>
+    <div ng-mouseenter="showFolderButton=true"
+         ng-mouseleave="showFolderButton=false">
+      <a style="text-decoration: none; cursor: pointer;" ng-click="toggleFolderNode(node)">
+        <i style="font-size: 10px;" ng-class="node.hidden ? 'icon-folder' : 'icon-folder-alt'" /> {{noteName(node)}}
+      </a>
+      <a style="text-decoration: none;">
+        <i style="font-size: 13px; margin-left: 10px; cursor: pointer; text-decoration: none;"
+           class="fa fa-pencil" ng-show="showFolderButton" ng-click="renameFolder(node)"
+           tooltip-placement="bottom" tooltip="Rename folder">
+        </i>
+      </a>
+    </div>
     <div ng-if="!node.hidden">
       <ul style="list-style-type: none; padding-left:15px;">
         <li ng-repeat="node in node.children" ng-include="'notebook_folder_renderer.html'" />
diff --git a/zeppelin-web/src/components/noteAction/noteAction.service.js b/zeppelin-web/src/components/noteAction/noteAction.service.js
index 3630fc8e05e..ca0278256ec 100644
--- a/zeppelin-web/src/components/noteAction/noteAction.service.js
+++ b/zeppelin-web/src/components/noteAction/noteAction.service.js
@@ -16,9 +16,9 @@
 
   angular.module('zeppelinWebApp').service('noteActionSrv', noteActionSrv);
 
-  noteActionSrv.$inject = ['websocketMsgSrv', '$location', 'renameSrv'];
+  noteActionSrv.$inject = ['websocketMsgSrv', '$location', 'renameSrv', 'noteListDataFactory'];
 
-  function noteActionSrv(websocketMsgSrv, $location, renameSrv) {
+  function noteActionSrv(websocketMsgSrv, $location, renameSrv, noteListDataFactory) {
     this.removeNote = function(noteId, redirectToHome) {
       BootstrapDialog.confirm({
         closable: true,
@@ -57,5 +57,58 @@
         }
       });
     };
+
+    this.renameFolder = function(folderId) {
+      renameSrv.openRenameModal({
+        title: 'Rename folder',
+        oldName: folderId,
+        callback: function(newName) {
+          var newFolderId = normalizeFolderId(newName);
+          if (_.has(noteListDataFactory.flatFolderMap, newFolderId)) {
+            BootstrapDialog.confirm({
+              type: BootstrapDialog.TYPE_WARNING,
+              closable: true,
+              title: 'WARNING! The folder will be MERGED',
+              message: 'The folder will be merged into <strong>' + newFolderId + '</strong>. Are you sure?',
+              callback: function(result) {
+                if (result) {
+                  websocketMsgSrv.renameFolder(folderId, newFolderId);
+                }
+              }
+            });
+          } else {
+            websocketMsgSrv.renameFolder(folderId, newFolderId);
+          }
+        }
+      });
+    };
+
+    function normalizeFolderId(folderId) {
+      folderId = folderId.trim();
+
+      while (folderId.contains('\\')) {
+        folderId = folderId.replace('\\', '/');
+      }
+
+      while (folderId.contains('///')) {
+        folderId = folderId.replace('///', '/');
+      }
+
+      folderId = folderId.replace('//', '/');
+
+      if (folderId === '/') {
+        return '/';
+      }
+
+      if (folderId[0] === '/') {
+        folderId = folderId.substring(1);
+      }
+
+      if (folderId.slice(-1) === '/') {
+        folderId = folderId.slice(0, -1);
+      }
+
+      return folderId;
+    }
   }
 })();
diff --git a/zeppelin-web/src/components/noteListDataFactory/noteList.datafactory.js b/zeppelin-web/src/components/noteListDataFactory/noteList.datafactory.js
index 0f700b6cf7f..2ffb53978af 100644
--- a/zeppelin-web/src/components/noteListDataFactory/noteList.datafactory.js
+++ b/zeppelin-web/src/components/noteListDataFactory/noteList.datafactory.js
@@ -20,6 +20,7 @@
     var notes = {
       root: {children: []},
       flatList: [],
+      flatFolderMap: {},
 
       setNotes: function(notesList) {
         // a flat list to boost searching
@@ -27,6 +28,7 @@
 
         // construct the folder-based tree
         notes.root = {children: []};
+        notes.flatFolderMap = {};
         _.reduce(notesList, function(root, note) {
           var noteName = note.name || note.id;
           var nodes = noteName.match(/([^\/][^\/]*)/g);
@@ -59,6 +61,10 @@
             hidden: true,
             children: []
           };
+
+          // add the folder to flat folder map
+          notes.flatFolderMap[newDir.id] = newDir;
+
           curDir.children.push(newDir);
           addNode(newDir, nodes, noteId);
         }
diff --git a/zeppelin-web/src/components/noteName-create/note-name-dialog.html b/zeppelin-web/src/components/noteName-create/note-name-dialog.html
index fdb825a4f81..0bb599cfa26 100644
--- a/zeppelin-web/src/components/noteName-create/note-name-dialog.html
+++ b/zeppelin-web/src/components/noteName-create/note-name-dialog.html
@@ -38,7 +38,7 @@ <h4 class="modal-title" ng-show="notenamectrl.clone">Clone note</h4>
               </select>
             </div>
           </div>
-          Use '/' to create folders. Example: /NoteDirA/Notebook1
+          Use '/' to create folders. Example: /NoteDirA/Note1
         </div>
         <div class="modal-footer">
           <button type="button" id="createNoteButton"
diff --git a/zeppelin-web/src/components/websocketEvents/websocketMsg.service.js b/zeppelin-web/src/components/websocketEvents/websocketMsg.service.js
index 5ffdaf7c259..567c267cb1c 100644
--- a/zeppelin-web/src/components/websocketEvents/websocketMsg.service.js
+++ b/zeppelin-web/src/components/websocketEvents/websocketMsg.service.js
@@ -63,6 +63,10 @@
         websocketEvents.sendNewEvent({op: 'NOTE_RENAME', data: {id: noteId, name: noteName}});
       },
 
+      renameFolder: function(folderId, folderName) {
+        websocketEvents.sendNewEvent({op: 'FOLDER_RENAME', data: {id: folderId, name: folderName}});
+      },
+
       moveParagraph: function(paragraphId, newIndex) {
         websocketEvents.sendNewEvent({op: 'MOVE_PARAGRAPH', data: {id: paragraphId, index: newIndex}});
       },
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Folder.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Folder.java
new file mode 100644
index 00000000000..15b26100d55
--- /dev/null
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Folder.java
@@ -0,0 +1,224 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.notebook;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+
+/**
+ * Represents a folder of Notebook. ID of the folder is a normalized path of it.
+ * 'normalized path' means the path that removed '/' from the beginning and the end of the path.
+ * e.g. "a/b/c", but not "/a/b/c", "a/b/c/" or "/a/b/c/".
+ * One exception can be the root folder, which is '/'.
+ */
+public class Folder {
+  public static final String ROOT_FOLDER_ID = "/";
+
+  private String id;
+
+  private Folder parent;
+  private Map<String, Folder> children = new LinkedHashMap<>();
+
+  // key: noteId
+  private final Map<String, Note> notes = new LinkedHashMap<>();
+
+  private List<FolderListener> listeners = new LinkedList<>();
+
+  private static final Logger logger = LoggerFactory.getLogger(Folder.class);
+
+  public Folder(String id) {
+    this.id = id;
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public String getName() {
+    if (getId().equals(ROOT_FOLDER_ID))
+      return ROOT_FOLDER_ID;
+
+    String path = getId();
+
+    int lastSlashIndex = path.lastIndexOf("/");
+    if (lastSlashIndex < 0) {   // This folder is under the root
+      return path;
+    }
+
+    return path.substring(lastSlashIndex + 1);
+  }
+
+  public String getParentFolderId() {
+    if (getId().equals(ROOT_FOLDER_ID))
+      return ROOT_FOLDER_ID;
+
+    int lastSlashIndex = getId().lastIndexOf("/");
+    // The root folder
+    if (lastSlashIndex < 0) {
+      return Folder.ROOT_FOLDER_ID;
+    }
+
+    return getId().substring(0, lastSlashIndex);
+  }
+
+  public static String normalizeFolderId(String id) {
+    id = id.trim();
+    id = id.replace("\\", "/");
+    while (id.contains("///")) {
+      id = id.replaceAll("///", "/");
+    }
+    id = id.replaceAll("//", "/");
+
+    if (id.equals(ROOT_FOLDER_ID)) {
+      return ROOT_FOLDER_ID;
+    }
+
+    if (id.charAt(0) == '/') {
+      id = id.substring(1);
+    }
+    if (id.charAt(id.length() - 1) == '/') {
+      id = id.substring(0, id.length() - 1);
+    }
+
+    return id;
+  }
+
+  /**
+   * Rename this folder as well as the notes and the children belong to it
+   *
+   * @param newId
+   */
+  public void rename(String newId) {
+    if (getId().equals(ROOT_FOLDER_ID))   // root folder cannot be renamed
+      return;
+
+    String oldId = getId();
+    id = normalizeFolderId(newId);
+    logger.info("Rename {} to {}", oldId, getId());
+
+    synchronized (notes) {
+      for (Note note : notes.values()) {
+        String noteName = note.getNameWithoutPath();
+
+        String newNotePath;
+        if (newId.equals(ROOT_FOLDER_ID)) {
+          newNotePath = noteName;
+        } else {
+          newNotePath = newId + "/" + noteName;
+        }
+        note.setName(newNotePath);
+      }
+    }
+
+    for (Folder child : children.values()) {
+      child.rename(getId() + "/" + child.getName());
+    }
+
+    notifyRenamed(oldId);
+  }
+
+  /**
+   * Merge folder's notes and child folders
+   *
+   * @param folder
+   */
+  public void merge(Folder folder) {
+    logger.info("Merge {} into {}", folder.getId(), getId());
+    addNotes(folder.getNotes());
+  }
+
+  public void addFolderListener(FolderListener listener) {
+    listeners.add(listener);
+  }
+
+  public void notifyRenamed(String oldFolderId) {
+    for (FolderListener listener : listeners) {
+      listener.onFolderRenamed(this, oldFolderId);
+    }
+  }
+
+  public Folder getParent() {
+    return parent;
+  }
+
+  public Map<String, Folder> getChildren() {
+    return children;
+  }
+
+  public void setParent(Folder parent) {
+    logger.info("Set parent of {} to {}", getId(), parent.getId());
+    this.parent = parent;
+  }
+
+  public void addChild(Folder child) {
+    if (child == this) // prevent the root folder from setting itself as child
+      return;
+    children.put(child.getId(), child);
+  }
+
+  public void removeChild(String folderId) {
+    logger.info("Remove child {} from {}", folderId, getId());
+    children.remove(folderId);
+  }
+
+  public void addNote(Note note) {
+    logger.info("Add note {} to folder {}", note.getId(), getId());
+    synchronized (notes) {
+      notes.put(note.getId(), note);
+    }
+  }
+
+  public void addNotes(List<Note> newNotes) {
+    synchronized (notes) {
+      for (Note note : newNotes) {
+        notes.put(note.getId(), note);
+      }
+    }
+  }
+
+  public void removeNote(Note note) {
+    logger.info("Remove note {} from folder {}", note.getId(), getId());
+    synchronized (notes) {
+      notes.remove(note.getId());
+    }
+  }
+
+  public List<Note> getNotes() {
+    return new LinkedList<>(notes.values());
+  }
+
+  public List<Note> getNotesRecursively() {
+    List<Note> notes = getNotes();
+
+    for (Folder child : children.values()) {
+      notes.addAll(child.getNotesRecursively());
+    }
+
+    return notes;
+  }
+
+  public int countNotes() {
+    return notes.size();
+  }
+
+  public boolean hasChild() {
+    return children.size() > 0;
+  }
+}
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/FolderListener.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/FolderListener.java
new file mode 100644
index 00000000000..efc2f72577f
--- /dev/null
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/FolderListener.java
@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.zeppelin.notebook;
+
+/**
+ * Folder listener used by FolderView
+ */
+public interface FolderListener {
+  void onFolderRenamed(Folder folder, String oldFolderId);
+}
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/FolderView.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/FolderView.java
new file mode 100644
index 00000000000..7fc5fe61d91
--- /dev/null
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/FolderView.java
@@ -0,0 +1,237 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.notebook;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Folder view of notes of Notebook.
+ * FolderView allows you to see notes from perspective of folders.
+ */
+public class FolderView implements NoteNameListener, FolderListener {
+  // key: folderId
+  private final Map<String, Folder> folders = new LinkedHashMap<>();
+  // key: a note, value: a folder where the note belongs to
+  private final Map<Note, Folder> index = new LinkedHashMap<>();
+
+  private static final Logger logger = LoggerFactory.getLogger(FolderView.class);
+
+  public Folder getFolder(String folderId) {
+    String normalizedFolderId = Folder.normalizeFolderId(folderId);
+    return folders.get(normalizedFolderId);
+  }
+
+  /**
+   * Rename folder of which id is folderId to newFolderId
+   *
+   * @param oldFolderId folderId to rename
+   * @param newFolderId newFolderId
+   * @return `null` if folder not exists, else old Folder
+   * in order to know which notes and child folders are renamed
+   */
+  public Folder renameFolder(String oldFolderId, String newFolderId) {
+    String normOldFolderId = Folder.normalizeFolderId(oldFolderId);
+    String normNewFolderId = Folder.normalizeFolderId(newFolderId);
+
+    if (!hasFolder(normOldFolderId))
+      return null;
+
+    if (oldFolderId.equals(Folder.ROOT_FOLDER_ID))  // cannot rename the root folder
+      return null;
+
+    // check whether oldFolderId and newFolderId are same or not
+    if (normOldFolderId.equals(normNewFolderId))
+      return getFolder(normOldFolderId);
+
+    logger.info("Rename {} to {}", normOldFolderId, normNewFolderId);
+
+    Folder oldFolder = getFolder(normOldFolderId);
+    removeFolder(oldFolderId);
+
+    oldFolder.rename(normNewFolderId);
+
+    return oldFolder;
+  }
+
+  public Folder getFolderOf(Note note) {
+    return index.get(note);
+  }
+
+  public void putNote(Note note) {
+    if (note.isNameEmpty()) {
+      return;
+    }
+
+    String folderId = note.getFolderId();
+
+    Folder folder = getOrCreateFolder(folderId);
+    folder.addNote(note);
+
+    synchronized (index) {
+      index.put(note, folder);
+    }
+  }
+
+  private Folder getOrCreateFolder(String folderId) {
+    if (folders.containsKey(folderId))
+      return folders.get(folderId);
+
+    return createFolder(folderId);
+  }
+
+  private Folder createFolder(String folderId) {
+    Folder newFolder = new Folder(folderId);
+    newFolder.addFolderListener(this);
+
+    logger.info("Create folder {}", folderId);
+
+    synchronized (folders) {
+      folders.put(folderId, newFolder);
+    }
+
+    Folder parentFolder = getOrCreateFolder(newFolder.getParentFolderId());
+
+    newFolder.setParent(parentFolder);
+    parentFolder.addChild(newFolder);
+
+    return newFolder;
+  }
+
+  private void removeFolder(String folderId) {
+    Folder removedFolder;
+
+    synchronized (folders) {
+      removedFolder = folders.remove(folderId);
+    }
+
+    if (removedFolder != null) {
+      logger.info("Remove folder {}", folderId);
+      Folder parent = removedFolder.getParent();
+      parent.removeChild(folderId);
+      removeFolderIfEmpty(parent.getId());
+    }
+  }
+
+  private void removeFolderIfEmpty(String folderId) {
+    if (!hasFolder(folderId))
+      return;
+
+    Folder folder = getFolder(folderId);
+    if (folder.countNotes() == 0 && !folder.hasChild()) {
+      logger.info("Folder {} is empty", folder.getId());
+      removeFolder(folderId);
+    }
+  }
+
+  public void removeNote(Note note) {
+    if (!index.containsKey(note)) {
+      return;
+    }
+
+    Folder folder = index.get(note);
+    folder.removeNote(note);
+
+    removeFolderIfEmpty(folder.getId());
+
+    synchronized (index) {
+      index.remove(note);
+    }
+  }
+
+  public void clear() {
+    synchronized (folders) {
+      folders.clear();
+    }
+    synchronized (index) {
+      index.clear();
+    }
+  }
+
+  public boolean hasFolder(String folderId) {
+    return getFolder(folderId) != null;
+  }
+
+  public boolean hasNote(Note note) {
+    return index.containsKey(note);
+  }
+
+  public int countFolders() {
+    return folders.size();
+  }
+
+  public int countNotes() {
+    int count = 0;
+
+    for (Folder folder : folders.values()) {
+      count += folder.countNotes();
+    }
+
+    return count;
+  }
+
+  /**
+   * Fired after a note's setName() run.
+   * When the note's name changed, FolderView should check if the note is in the right folder.
+   *
+   * @param note
+   * @param oldName
+   */
+  @Override
+  public void onNoteNameChanged(Note note, String oldName) {
+    if (note.isNameEmpty()) {
+      return;
+    }
+    logger.info("Note name changed: {} -> {}", oldName, note.getName());
+    // New note
+    if (!index.containsKey(note)) {
+      putNote(note);
+    }
+    // Existing note
+    else {
+      // If the note is in the right place, just return
+      Folder folder = index.get(note);
+      if (folder.getId().equals(note.getFolderId())) {
+        return;
+      }
+      // The note's folder is changed!
+      removeNote(note);
+      putNote(note);
+    }
+  }
+
+  @Override
+  public void onFolderRenamed(Folder folder, String oldFolderId) {
+    if (getFolder(folder.getId()) == folder)  // the folder is at the right place
+      return;
+    logger.info("folder renamed: {} -> {}", oldFolderId, folder.getId());
+
+    if (getFolder(oldFolderId) == folder)
+      folders.remove(oldFolderId);
+
+    Folder newFolder = getOrCreateFolder(folder.getId());
+    newFolder.merge(folder);
+
+    for (Note note : folder.getNotes()) {
+      index.put(note, newFolder);
+    }
+  }
+}
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java
index aa08adf0f83..8ba0b8392ad 100644
--- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java
@@ -89,6 +89,7 @@ public class Note implements Serializable, ParagraphJobListener {
   private transient ScheduledFuture delayedPersist;
   private transient NoteEventListener noteEventListener;
   private transient Credentials credentials;
+  private transient NoteNameListener noteNameListener;
 
   /*
    * note configurations.
@@ -134,6 +135,43 @@ public String getName() {
     return name;
   }
 
+  public String getNameWithoutPath() {
+    String notePath = getName();
+
+    int lastSlashIndex = notePath.lastIndexOf("/");
+    // The note is in the root folder
+    if (lastSlashIndex < 0) {
+      return notePath;
+    }
+
+    return notePath.substring(lastSlashIndex + 1);
+  }
+
+  /**
+   * @return normalized folder path, which is folderId
+   */
+  public String getFolderId() {
+    String notePath = getName();
+
+    // Ignore first '/'
+    if (notePath.charAt(0) == '/')
+      notePath = notePath.substring(1);
+
+    int lastSlashIndex = notePath.lastIndexOf("/");
+    // The root folder
+    if (lastSlashIndex < 0) {
+      return Folder.ROOT_FOLDER_ID;
+    }
+
+    String folderId = notePath.substring(0, lastSlashIndex);
+
+    return folderId;
+  }
+
+  public boolean isNameEmpty() {
+    return getName().trim().isEmpty();
+  }
+
   private String normalizeNoteName(String name) {
     name = name.trim();
     name = name.replace("\\", "/");
@@ -148,10 +186,20 @@ private String normalizeNoteName(String name) {
   }
 
   public void setName(String name) {
+    String oldName = this.name;
+
     if (name.indexOf('/') >= 0 || name.indexOf('\\') >= 0) {
       name = normalizeNoteName(name);
     }
     this.name = name;
+
+    if (this.noteNameListener != null && !oldName.equals(name)) {
+      noteNameListener.onNoteNameChanged(this, oldName);
+    }
+  }
+
+  public void setNoteNameListener(NoteNameListener listener) {
+    this.noteNameListener = listener;
   }
 
   void setInterpreterFactory(InterpreterFactory factory) {
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/NoteNameListener.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/NoteNameListener.java
new file mode 100644
index 00000000000..28b53fb0406
--- /dev/null
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/NoteNameListener.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.notebook;
+
+/**
+ * NoteNameListener. It's used by FolderView.
+ */
+public interface NoteNameListener {
+  /**
+   * Fired after note name changed
+   * @param note
+   * @param oldName
+   */
+  void onNoteNameChanged(Note note, String oldName);
+}
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Notebook.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Notebook.java
index c0932569af5..532fd8fd7f7 100644
--- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Notebook.java
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Notebook.java
@@ -24,7 +24,6 @@
 import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -84,6 +83,7 @@ public class Notebook implements NoteEventListener {
    * Keep the order.
    */
   private final Map<String, Note> notes = new LinkedHashMap<>();
+  private final FolderView folders = new FolderView();
   private ZeppelinConfiguration conf;
   private StdSchedulerFactory quertzSchedFact;
   private org.quartz.Scheduler quartzSched;
@@ -129,7 +129,6 @@ public Notebook(ZeppelinConfiguration conf, NotebookRepo notebookRepo,
       logger.info("Notebook indexing finished: {} indexed in {}s", notes.size(),
           TimeUnit.NANOSECONDS.toSeconds(start - System.nanoTime()));
     }
-
   }
 
   /**
@@ -159,6 +158,8 @@ public Note createNote(List<String> interpreterIds, AuthenticationInfo subject)
     Note note =
         new Note(notebookRepo, replFactory, jobListenerFactory,
                 noteSearchService, credentials, this);
+    note.setNoteNameListener(folders);
+
     synchronized (notes) {
       notes.put(note.getId(), note);
     }
@@ -314,6 +315,7 @@ public void removeNote(String id, AuthenticationInfo subject) {
 
     synchronized (notes) {
       note = notes.remove(id);
+      folders.removeNote(note);
     }
     replFactory.removeNoteInterpreterSettingBinding(subject.getUser(), id);
     noteSearchService.deleteIndexDocs(note);
@@ -432,9 +434,11 @@ private Note loadNoteFromRepo(String id, AuthenticationInfo subject) {
     }
 
     note.setNoteEventListener(this);
+    note.setNoteNameListener(folders);
 
     synchronized (notes) {
       notes.put(note.getId(), note);
+      folders.putNote(note);
       refreshCron(note.getId());
     }
 
@@ -469,7 +473,7 @@ void loadAllNotes(AuthenticationInfo subject) throws IOException {
   }
 
   /**
-   * Reload all notes from repository after clearing `notes`
+   * Reload all notes from repository after clearing `notes` and `folders`
    * to reflect the changes of added/deleted/modified notes on file system level.
    *
    * @throws IOException
@@ -478,6 +482,9 @@ public void reloadAllNotes(AuthenticationInfo subject) throws IOException {
     synchronized (notes) {
       notes.clear();
     }
+    synchronized (folders) {
+      folders.clear();
+    }
 
     if (notebookRepo instanceof NotebookRepoSync) {
       NotebookRepoSync mainRepo = (NotebookRepoSync) notebookRepo;
@@ -518,6 +525,14 @@ Date getLastUpdate() {
     }
   }
 
+  public Folder renameFolder(String oldFolderId, String newFolderId) {
+    return folders.renameFolder(oldFolderId, newFolderId);
+  }
+
+  public List<Note> getNotesUnderFolder(String folderId) {
+    return folders.getFolder(folderId).getNotesRecursively();
+  }
+
   public List<Note> getAllNotes() {
     synchronized (notes) {
       List<Note> noteList = new ArrayList<>(notes.values());
diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/socket/Message.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/socket/Message.java
index 4f432eb1d31..f0b04182ab7 100644
--- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/socket/Message.java
+++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/socket/Message.java
@@ -55,6 +55,8 @@ public static enum OP {
 
     NOTE_RENAME,
 
+    FOLDER_RENAME,
+
     RUN_PARAGRAPH,    // [c-s] run paragraph
                       // @param id paragraph id
                       // @param paragraph paragraph content.ie. script
diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/FolderTest.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/FolderTest.java
new file mode 100644
index 00000000000..6b116a8335d
--- /dev/null
+++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/FolderTest.java
@@ -0,0 +1,189 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.notebook;
+
+import org.apache.zeppelin.interpreter.Interpreter;
+import org.apache.zeppelin.interpreter.InterpreterFactory;
+import org.apache.zeppelin.notebook.repo.NotebookRepo;
+import org.apache.zeppelin.scheduler.Scheduler;
+import org.apache.zeppelin.search.SearchService;
+import org.apache.zeppelin.user.Credentials;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(MockitoJUnitRunner.class)
+public class FolderTest {
+  @Mock
+  NotebookRepo repo;
+
+  @Mock
+  JobListenerFactory jobListenerFactory;
+
+  @Mock
+  SearchService index;
+
+  @Mock
+  Credentials credentials;
+
+  @Mock
+  Interpreter interpreter;
+
+  @Mock
+  Scheduler scheduler;
+
+  @Mock
+  NoteEventListener noteEventListener;
+
+  @Mock
+  InterpreterFactory interpreterFactory;
+
+  Folder folder;
+
+  Note note1;
+  Note note2;
+  Note note3;
+
+  @Before
+  public void createFolderAndNotes() {
+    note1 = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    note1.setName("this/is/a/folder/note1");
+
+    note2 = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    note2.setName("this/is/a/folder/note2");
+
+    note3 = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    note3.setName("this/is/a/folder/note3");
+
+    folder = new Folder("this/is/a/folder");
+    folder.addNote(note1);
+    folder.addNote(note2);
+    folder.addNote(note3);
+
+    folder.setParent(new Folder("this/is/a"));
+  }
+
+  @Test
+  public void normalizeFolderIdTest() {
+    // The root folder tests
+    assertEquals(Folder.ROOT_FOLDER_ID, Folder.normalizeFolderId("/"));
+    assertEquals(Folder.ROOT_FOLDER_ID, Folder.normalizeFolderId("//"));
+    assertEquals(Folder.ROOT_FOLDER_ID, Folder.normalizeFolderId("///"));
+    assertEquals(Folder.ROOT_FOLDER_ID, Folder.normalizeFolderId("\\\\///////////"));
+
+    // Folders under the root
+    assertEquals("a", Folder.normalizeFolderId("a"));
+    assertEquals("a", Folder.normalizeFolderId("/a"));
+    assertEquals("a", Folder.normalizeFolderId("a/"));
+    assertEquals("a", Folder.normalizeFolderId("/a/"));
+
+    // Subdirectories
+    assertEquals("a/b/c", Folder.normalizeFolderId("a/b/c"));
+    assertEquals("a/b/c", Folder.normalizeFolderId("/a/b/c"));
+    assertEquals("a/b/c", Folder.normalizeFolderId("a/b/c/"));
+    assertEquals("a/b/c", Folder.normalizeFolderId("/a/b/c/"));
+  }
+
+  @Test
+  public void folderIdTest() {
+    assertEquals(note1.getFolderId(), folder.getId());
+    assertEquals(note2.getFolderId(), folder.getId());
+    assertEquals(note3.getFolderId(), folder.getId());
+  }
+
+  @Test
+  public void addNoteTest() {
+    Note note4 = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    note4.setName("this/is/a/folder/note4");
+
+    folder.addNote(note4);
+
+    assert (folder.getNotes().contains(note4));
+  }
+
+  @Test
+  public void removeNoteTest() {
+    folder.removeNote(note3);
+
+    assert (!folder.getNotes().contains(note3));
+  }
+
+  @Test
+  public void renameTest() {
+    // Subdirectory tests
+    folder.rename("renamed/folder");
+
+    assertEquals("renamed/folder", note1.getFolderId());
+    assertEquals("renamed/folder", note2.getFolderId());
+    assertEquals("renamed/folder", note3.getFolderId());
+
+    assertEquals("renamed/folder/note1", note1.getName());
+    assertEquals("renamed/folder/note2", note2.getName());
+    assertEquals("renamed/folder/note3", note3.getName());
+
+    // Folders under the root tests
+    folder.rename("a");
+
+    assertEquals("a", note1.getFolderId());
+    assertEquals("a", note2.getFolderId());
+    assertEquals("a", note3.getFolderId());
+
+    assertEquals("a/note1", note1.getName());
+    assertEquals("a/note2", note2.getName());
+    assertEquals("a/note3", note3.getName());
+  }
+
+  @Test
+  public void renameToRootTest() {
+    folder.rename(Folder.ROOT_FOLDER_ID);
+
+    assertEquals(Folder.ROOT_FOLDER_ID, note1.getFolderId());
+    assertEquals(Folder.ROOT_FOLDER_ID, note2.getFolderId());
+    assertEquals(Folder.ROOT_FOLDER_ID, note3.getFolderId());
+
+    assertEquals("note1", note1.getName());
+    assertEquals("note2", note2.getName());
+    assertEquals("note3", note3.getName());
+  }
+
+  @Test
+  public void getParentIdTest() {
+    Folder rootFolder = new Folder("/");
+    Folder aFolder = new Folder("a");
+    Folder abFolder = new Folder("a/b");
+
+    assertEquals("/", rootFolder.getParentFolderId());
+    assertEquals("/", aFolder.getParentFolderId());
+    assertEquals("a", abFolder.getParentFolderId());
+  }
+
+  @Test
+  public void getNameTest() {
+    Folder rootFolder = new Folder("/");
+    Folder aFolder = new Folder("a");
+    Folder abFolder = new Folder("a/b");
+
+    assertEquals("/", rootFolder.getName());
+    assertEquals("a", aFolder.getName());
+    assertEquals("b", abFolder.getName());
+  }
+}
diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/FolderViewTest.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/FolderViewTest.java
new file mode 100644
index 00000000000..3ed14b6b9e5
--- /dev/null
+++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/FolderViewTest.java
@@ -0,0 +1,354 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.notebook;
+
+import org.apache.zeppelin.interpreter.Interpreter;
+import org.apache.zeppelin.interpreter.InterpreterFactory;
+import org.apache.zeppelin.notebook.repo.NotebookRepo;
+import org.apache.zeppelin.scheduler.Scheduler;
+import org.apache.zeppelin.search.SearchService;
+import org.apache.zeppelin.user.Credentials;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+@RunWith(MockitoJUnitRunner.class)
+public class FolderViewTest {
+  @Mock
+  NotebookRepo repo;
+
+  @Mock
+  JobListenerFactory jobListenerFactory;
+
+  @Mock
+  SearchService index;
+
+  @Mock
+  Credentials credentials;
+
+  @Mock
+  Interpreter interpreter;
+
+  @Mock
+  Scheduler scheduler;
+
+  @Mock
+  NoteEventListener noteEventListener;
+
+  @Mock
+  InterpreterFactory interpreterFactory;
+
+  FolderView folderView;
+
+  Note note1;
+  Note note2;
+  Note note3;
+
+  List<String> testNoteNames = Arrays.asList(
+          "note1", "/note2",
+          "a/note1", "/a/note2",
+          "a/b/note1", "/a/b/note2"
+  );
+
+  Folder rootFolder;
+  Folder aFolder;
+  Folder abFolder;
+
+  Note rootNote1;
+  Note rootNote2;
+  Note aNote1;
+  Note aNote2;
+  Note abNote1;
+  Note abNote2;
+
+  private Note createNote() {
+    Note note = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    note.setNoteNameListener(folderView);
+    return note;
+  }
+
+  @Before
+  public void createNotesAndFolderMap() {
+    folderView = new FolderView();
+
+    for (String noteName : testNoteNames) {
+      Note note = createNote();
+      note.setName(noteName);
+      folderView.putNote(note);
+    }
+
+    rootFolder = folderView.getFolder("/");
+    aFolder = folderView.getFolder("a");
+    abFolder = folderView.getFolder("a/b");
+
+    rootNote1 = rootFolder.getNotes().get(0);
+    rootNote2 = rootFolder.getNotes().get(1);
+    aNote1 = aFolder.getNotes().get(0);
+    aNote2 = aFolder.getNotes().get(1);
+    abNote1 = abFolder.getNotes().get(0);
+    abNote2 = abFolder.getNotes().get(1);
+  }
+
+  @Test
+  public void putNoteTest() {
+    assertEquals(6, folderView.countNotes());
+    assertEquals(3, folderView.countFolders());
+
+    assertEquals(2, rootFolder.countNotes());
+    assertEquals(2, aFolder.countNotes());
+    assertEquals(2, abFolder.countNotes());
+
+    assertEquals("note1", rootNote1.getName());
+    assertEquals("/note2", rootNote2.getName());
+    assertEquals("a/note1", aNote1.getName());
+    assertEquals("/a/note2", aNote2.getName());
+    assertEquals("a/b/note1", abNote1.getName());
+    assertEquals("/a/b/note2", abNote2.getName());
+  }
+
+  @Test
+  public void getTest() {
+    assertEquals(rootFolder, folderView.getFolder("/"));
+
+    assertEquals(aFolder, folderView.getFolder("a"));
+    assertEquals(aFolder, folderView.getFolder("/a"));
+    assertEquals(aFolder, folderView.getFolder("a/"));
+    assertEquals(aFolder, folderView.getFolder("/a/"));
+
+    assertEquals(abFolder, folderView.getFolder("a/b"));
+    assertEquals(abFolder, folderView.getFolder("/a/b"));
+    assertEquals(abFolder, folderView.getFolder("a/b/"));
+    assertEquals(abFolder, folderView.getFolder("/a/b/"));
+  }
+
+  @Test
+  public void removeNoteTest() {
+    Note rootNote1 = rootFolder.getNotes().get(0);
+    Note aNote1 = aFolder.getNotes().get(0);
+    Note abNote1 = abFolder.getNotes().get(0);
+
+    folderView.removeNote(rootNote1);
+    folderView.removeNote(aNote1);
+    folderView.removeNote(abNote1);
+
+    assertEquals(3, folderView.countFolders());
+    assertEquals(3, folderView.countNotes());
+    assertEquals(1, rootFolder.countNotes());
+    assertEquals(1, aFolder.countNotes());
+    assertEquals(1, abFolder.countNotes());
+  }
+
+  @Test
+  public void renameFolderOrdinaryTest() {
+    // "a/b" -> "a/c"
+    String oldName = "a/b";
+    String newName = "a/c";
+
+    Folder oldFolder = folderView.renameFolder(oldName, newName);
+    Folder newFolder = folderView.getFolder(newName);
+
+    assertNull(folderView.getFolder(oldName));
+    assertNotNull(newFolder);
+
+    assertEquals(3, folderView.countFolders());
+    assertEquals(6, folderView.countNotes());
+
+    assertEquals(abFolder, oldFolder);
+
+    assertEquals(newName, abFolder.getId());
+    assertEquals(newName, newFolder.getId());
+
+    assertEquals(newName + "/note1", abNote1.getName());
+    assertEquals(newName + "/note2", abNote2.getName());
+  }
+
+  @Test
+  public void renameFolderTargetExistsAndHasChildTest() {
+    // "a" -> "a/b"
+    String oldName = "a";
+    String newName = "a/b";
+
+    Folder oldFolder = folderView.renameFolder(oldName, newName);
+    Folder newFolder = folderView.getFolder(newName);
+
+    assertNotNull(folderView.getFolder("a"));
+    assertNotNull(folderView.getFolder("a/b"));
+    assertNotNull(folderView.getFolder("a/b/b"));
+
+    assertEquals(0, folderView.getFolder("a").countNotes());
+    assertEquals(2, folderView.getFolder("a/b").countNotes());
+    assertEquals(2, folderView.getFolder("a/b/b").countNotes());
+
+    assertEquals(4, folderView.countFolders());
+    assertEquals(6, folderView.countNotes());
+
+    assertEquals(newName, aFolder.getId());
+    assertEquals(newName, newFolder.getId());
+
+    assertEquals(newName + "/note1", aNote1.getName());
+    assertEquals(newName + "/note2", aNote2.getName());
+    assertEquals(newName + "/b" + "/note1", abNote1.getName());
+    assertEquals(newName + "/b" + "/note2", abNote2.getName());
+  }
+
+  @Test
+  public void renameRootFolderTest() {
+    String newName = "lalala";
+    Folder nothing = folderView.renameFolder("/", newName);
+
+    assertNull(nothing);
+    assertNull(folderView.getFolder(newName));
+  }
+
+  @Test
+  public void renameFolderToRootTest() {
+    // "a/b" -> "/"
+    String oldName = "a/b";
+    String newName = "/";
+
+    Folder oldFolder = folderView.renameFolder(oldName, newName);
+    Folder newFolder = folderView.getFolder(newName);
+
+    assertNull(folderView.getFolder(oldName));
+    assertNotNull(newFolder);
+
+    assertEquals(2, folderView.countFolders());
+    assertEquals(6, folderView.countNotes());
+
+    assertEquals(abFolder, oldFolder);
+    assertEquals(rootFolder, newFolder);
+
+    assertEquals(newName, rootFolder.getId());
+
+    assertEquals("note1", abNote1.getName());
+    assertEquals("note2", abNote2.getName());
+  }
+
+  @Test
+  public void renameFolderNotExistsTest() {
+    // "x/y/z" -> "a"
+    String oldName = "x/y/z";
+    String newName = "a";
+
+    Folder oldFolder = folderView.renameFolder(oldName, newName);
+
+    assertNull(oldFolder);
+  }
+
+  @Test
+  public void renameFolderSameNameTest() {
+    // "a" -> "a"
+    String sameName = "a";
+
+    Folder oldFolder = folderView.renameFolder(sameName, sameName);
+    Folder newFolder = folderView.getFolder(sameName);
+
+    assertEquals(aFolder, oldFolder);
+    assertEquals(aFolder, newFolder);
+
+    assertNotNull(folderView.getFolder(sameName));
+    assertNotNull(newFolder);
+
+    assertEquals(sameName, aFolder.getId());
+  }
+
+  /**
+   * Should rename a empty folder
+   */
+  @Test
+  public void renameEmptyFolderTest() {
+    // Create a note of which name is "x/y/z" and rename "x" -> "u"
+
+    Note note = createNote();
+    note.setName("x/y/z");
+    folderView.putNote(note);
+
+    folderView.renameFolder("x", "u");
+
+    assertNotNull(folderView.getFolder("u"));
+    assertNotNull(folderView.getFolder("u/y"));
+  }
+
+  /**
+   * Should also rename child folders of the target folder
+   */
+  @Test
+  public void renameFolderHasChildrenTest() {
+    // "a" -> "x"
+    // "a/b" should also be renamed to "x/b"
+
+    folderView.renameFolder("a", "x");
+
+    assertNotNull(folderView.getFolder("x/b"));
+  }
+
+  @Test
+  public void onNameChangedTest() {
+    Note newNote = createNote();
+
+    assert (!folderView.hasNote(newNote));
+
+    newNote.setName("      ");
+    assert (!folderView.hasNote(newNote));
+
+    newNote.setName("a/b/newNote");
+    assert (folderView.hasNote(newNote));
+    assertEquals(abFolder, folderView.getFolderOf(newNote));
+
+    newNote.setName("newNote");
+    assert (!abFolder.getNotes().contains(newNote));
+    assertEquals(rootFolder, folderView.getFolderOf(newNote));
+  }
+
+  @Test
+  public void renameHighDepthFolderTest() {
+    Note note = createNote();
+    note.setName("x/y/z");
+
+    Folder folder = folderView.getFolder("x");
+    folder.rename("d");
+
+    assertEquals("d/y/z", note.getName());
+
+    assertNull(folderView.getFolder("x"));
+    assertNotNull(folderView.getFolder("d"));
+    assertNotNull(folderView.getFolder("d/y"));
+  }
+
+  @Test
+  public void renameFolderMergingTest() {
+    Note xNote1 = createNote();
+    Note xbNote1 = createNote();
+
+    xNote1.setName("x/note1");
+    xbNote1.setName("x/b/note1");
+
+    folderView.getFolder("a").rename("x");
+
+    assertEquals(3, folderView.getFolder("x").countNotes());
+    assertEquals(3, folderView.getFolder("x/b").countNotes());
+  }
+}
diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/NoteTest.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/NoteTest.java
index ed42144bf7a..863f4cc62d8 100644
--- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/NoteTest.java
+++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/notebook/NoteTest.java
@@ -145,4 +145,34 @@ public void clearAllParagraphOutputTest() {
     assertNull(p2.getReturn());
   }
 
+  @Test
+  public void getFolderIdTest() {
+    Note note = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    // Ordinary case test
+    note.setName("this/is/a/folder/noteName");
+    assertEquals("this/is/a/folder", note.getFolderId());
+    // Normalize test
+    note.setName("/this/is/a/folder/noteName");
+    assertEquals("this/is/a/folder", note.getFolderId());
+    // Root folder test
+    note.setName("noteOnRootFolder");
+    assertEquals(Folder.ROOT_FOLDER_ID, note.getFolderId());
+    note.setName("/noteOnRootFolderStartsWithSlash");
+    assertEquals(Folder.ROOT_FOLDER_ID, note.getFolderId());
+  }
+
+  @Test
+  public void getNameWithoutPathTest() {
+    Note note = new Note(repo, interpreterFactory, jobListenerFactory, index, credentials, noteEventListener);
+    // Notes in the root folder
+    note.setName("noteOnRootFolder");
+    assertEquals("noteOnRootFolder", note.getNameWithoutPath());
+    note.setName("/noteOnRootFolderStartsWithSlash");
+    assertEquals("noteOnRootFolderStartsWithSlash", note.getNameWithoutPath());
+    // Notes in subdirectories
+    note.setName("/a/b/note");
+    assertEquals("note", note.getNameWithoutPath());
+    note.setName("a/b/note");
+    assertEquals("note", note.getNameWithoutPath());
+  }
 }