# Android_NotePad

**Repository Path**: chzb034/android_-note-pad

## Basic Information

- **Project Name**: Android_NotePad
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-12-01
- **Last Updated**: 2025-12-02

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# NotePad-Android应用介绍文档

## 一.初始应用的功能

### 1.新建笔记和编辑笔记

(1)在主界面点击红色矩形所示按钮，新建笔记并进入编辑界面

![初始应用功能1.1](./运行结果截图/初始应用功能1.1.png)

(2)进入笔记编辑界面后，可进行笔记编辑

![初始应用功能1.2](./运行结果截图/初始应用功能1.2.png)

### 2.笔记列表

在进行笔记的新建和编辑后，在主界面中呈现笔记列表。在初始应用中背景颜色为黑色，字体颜色为白色，且笔记列表中的每个条目都只显示笔记标题

![初始应用功能3](./运行结果截图/初始应用功能3.png)

## 二.拓展基本功能

### （一）.标签筛选功能

#### 1.功能要求

支持按分类标签筛选笔记，用户可以选择特定分类，只显示该分类下的笔记

#### 2.实现思路和技术实现

(1)在主页面菜单中添加分类筛选选项

```xml
<item android:id="@+id/menu_category_filter"
      android:title="按分类筛选"
      android:icon="@android:drawable/ic_menu_view"
      android:showAsAction="never" />
```

(2)实现分类筛选菜单，显示所有可用分类

```java
/**
 * 显示分类筛选菜单
 */
private void showCategoryFilterMenu() {
    try {
        // 创建菜单
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("按分类筛选");
      
        // 创建分类列表，包含全部笔记、默认分类、预定义常用分类和数据库分类
        List<String> categoryNamesList = new ArrayList<>();
        List<Long> categoryIdsList = new ArrayList<>();
      
        // 添加全部笔记选项，使用特殊值表示不筛选
        categoryNamesList.add("全部笔记");
        categoryIdsList.add(-999L); // 使用-999而不是-1，避免与工作分类冲突
      
        // 添加默认分类选项
        categoryNamesList.add("默认");
        categoryIdsList.add(1L);
      
        // 添加预定义的常用分类
        categoryNamesList.add("工作");
        categoryIdsList.add(-1L); // 工作分类
      
        categoryNamesList.add("学习");
        categoryIdsList.add(-2L);
      
        categoryNamesList.add("生活");
        categoryIdsList.add(-3L);
      
        categoryNamesList.add("笔记");
        categoryIdsList.add(-4L);
      
        categoryNamesList.add("购物");
        categoryIdsList.add(-5L);
      
        // 查询数据库中的自定义分类
        Cursor categoryCursor = null;
        try {
            // 确保NotePad.Categories.CONTENT_URI有效
            if (NotePad.Categories.CONTENT_URI != null) {
                categoryCursor = getContentResolver().query(
                        NotePad.Categories.CONTENT_URI,
                        new String[] { NotePad.Categories._ID, NotePad.Categories.COLUMN_NAME_NAME },
                        null, null, null);
              
                if (categoryCursor != null && categoryCursor.moveToFirst()) {
                    do {
                        long categoryId = categoryCursor.getLong(categoryCursor.getColumnIndex(NotePad.Categories._ID));
                        String categoryName = categoryCursor.getString(categoryCursor.getColumnIndex(NotePad.Categories.COLUMN_NAME_NAME));
                      
                        // 只添加有效的分类
                        if (categoryName != null && !categoryName.isEmpty()) {
                            categoryNamesList.add(categoryName);
                            categoryIdsList.add(categoryId);
                        }
                    } while (categoryCursor.moveToNext());
                }
            }
        } catch (Exception e) {
            Log.e(TAG, "Error querying categories: " + e.getMessage());
        } finally {
            if (categoryCursor != null) {
                categoryCursor.close();
            }
        }
      
        // 转换为数组
        final String[] categories = categoryNamesList.toArray(new String[0]);
        final long[] categoryIds = new long[categoryIdsList.size()];
        for (int i = 0; i < categoryIdsList.size(); i++) {
            categoryIds[i] = categoryIdsList.get(i);
        }
      
        // 设置默认选中项
        int checkedItem = 0;
        for (int i = 0; i < categoryIds.length; i++) {
            if (categoryIds[i] == mSelectedFilterCategoryId) {
                checkedItem = i;
                break;
            }
        }
      
        // 显示单选列表
        builder.setSingleChoiceItems(categories, checkedItem, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mSelectedFilterCategoryId = categoryIds[which];
                dialog.dismiss();
                loadNotes(); // 重新加载笔记
            }
        });
      
        // 添加取消按钮
        builder.setNegativeButton("取消", null);
      
        builder.show();
    } catch (Exception e) {
        Log.e(TAG, "Error showing category filter menu: " + e.getMessage());
    }
}
```

(3)在loadNotes方法中添加分类筛选逻辑

```java
// 如果有分类筛选，则添加分类条件
// -999表示不筛选（全部笔记），-1到-5是预定义分类，0及以上是自定义分类
if (mSelectedFilterCategoryId != -999) { // 只有不等于-999时才应用筛选
    if (selection != null) {
        selection += " AND ";
    } else {
        selection = "";
    }
  
    if (mSelectedFilterCategoryId == 1) { // 1表示默认分类
         // 筛选默认分类的笔记（数据库中默认分类ID为1）
         selection += NotePad.Notes.COLUMN_NAME_CATEGORY_ID + " = 1"; 
    } else {
        // 筛选特定分类的笔记
        // 对于预定义分类(-1到-5)，需要特殊处理，因为它们不是真正的数据库分类ID
        if (mSelectedFilterCategoryId < 0 && mSelectedFilterCategoryId > -6) { // -1到-5是预定义分类
            // 预定义分类需要特殊处理，这里添加日志便于调试
            Log.d(TAG, "Filtering by predefined category: " + mSelectedFilterCategoryId);
        }
        // 统一使用相同的查询逻辑
        selection += NotePad.Notes.COLUMN_NAME_CATEGORY_ID + " = ?";
      
        if (selectionArgs != null) {
            // 合并参数
            String[] newSelectionArgs = new String[selectionArgs.length + 1];
            System.arraycopy(selectionArgs, 0, newSelectionArgs, 0, selectionArgs.length);
            newSelectionArgs[selectionArgs.length] = String.valueOf(mSelectedFilterCategoryId);
            selectionArgs = newSelectionArgs;
        } else {
            selectionArgs = new String[] { String.valueOf(mSelectedFilterCategoryId) };
        }
    }
}
```

(4)在onOptionsItemSelected方法中添加分类筛选菜单的处理

```java
// 处理分类筛选菜单
if (id == MENU_CATEGORY_FILTER) {
    // 显示分类筛选菜单
    showCategoryFilterMenu();
    return true;
}
```

#### 3.实现效果界面截图

(1)主页面菜单中现在有"按分类筛选"选项

![拓展基本功能6.1](./运行结果截图/拓展基本功能6.1.png)

(2)点击"按分类筛选"后，显示分类选择对话框

![拓展基本功能6.2](./运行结果截图/拓展基本功能6.2.png)

(3)选择特定分类后，只显示该分类下的笔记

![拓展基本功能6.3](./运行结果截图/拓展基本功能6.3.png)

### （二）.搜索功能

#### 1.功能要求

支持按标题和内容搜索笔记，实时根据输入内容过滤笔记列表

#### 2.实现思路和技术实现

(1)在主页面布局中添加搜索框和搜索按钮

```xml
<!-- 搜索框区域 -->
<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="16dp"
    android:background="#ffffff"
    android:elevation="4dp"
    android:orientation="horizontal">
  
    <EditText
        android:id="@+id/search_edit_text"
        android:layout_width="0dp"
        android:layout_height="48dp"
        android:layout_weight="1"
        android:hint="搜索笔记标题或内容..."
        android:inputType="text"
        android:imeOptions="actionSearch"
        android:singleLine="true"
        android:paddingLeft="16dp"
        android:paddingRight="16dp"
        android:background="@drawable/rounded_corner_edit_text"
        android:drawableLeft="@android:drawable/ic_menu_search"
        android:drawablePadding="8dp"
        android:textSize="16sp"
        android:textColor="#333333"
        android:textColorHint="#999999" />
      
    <Button
        android:id="@+id/search_button"
        android:layout_width="90dp"
        android:layout_height="48dp"
        android:text="搜索"
        android:layout_marginLeft="12dp"
        android:background="@drawable/button_selector"
        android:textColor="#ffffff"
        android:textSize="16sp"
        android:elevation="2dp" />
</LinearLayout>
```

(2)在NotesList类中初始化搜索组件并设置点击事件

```java
// 初始化搜索组件
mSearchEditText = (EditText) findViewById(R.id.search_edit_text);
mSearchButton = (Button) findViewById(R.id.search_button);

// 设置搜索按钮点击事件
mSearchButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        performSearch();
    }
});

// 设置搜索框的回车键搜索
mSearchEditText.setOnKeyListener(new OnKeyListener() {
    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN) {
            performSearch();
            return true;
        }
        return false;
    }
});
```

(3)实现performSearch方法，处理搜索逻辑

```java
/**
 * 执行搜索操作
 */
private void performSearch() {
    String searchText = mSearchEditText.getText().toString().trim();
  
    // 保存当前搜索查询
    if (!searchText.isEmpty()) {
        mCurrentSearchQuery = searchText;
    } else {
        // 如果搜索框为空，则清除搜索
        mCurrentSearchQuery = null;
    }
  
    // 调用loadNotes()方法加载并显示搜索结果
    loadNotes();
}
```

(4)在loadNotes方法中添加搜索逻辑

```java
// 如果有搜索查询，则添加搜索条件
if (mCurrentSearchQuery != null && !mCurrentSearchQuery.trim().isEmpty()) {
    // 查询标题或内容中包含搜索字符串的笔记
    selection = NotePad.Notes.COLUMN_NAME_TITLE + " LIKE ? OR " + 
                NotePad.Notes.COLUMN_NAME_NOTE + " LIKE ?";
    String searchPattern = "%" + mCurrentSearchQuery + "%";
    selectionArgs = new String[] { searchPattern, searchPattern };
}
```

(5)在菜单中添加清除搜索选项

```java
// 动态添加清除搜索菜单项，只有在进行搜索时才显示
if (mCurrentSearchQuery != null && !mCurrentSearchQuery.isEmpty()) {
    menu.add(0, CLEAR_SEARCH_ID, 0, "清除搜索");
}
```

(6)实现clearSearch方法，清除搜索条件

```java
/**
 * 清除搜索，显示所有笔记
 */
private void clearSearch() {
    mCurrentSearchQuery = null;
    mSearchEditText.setText("");
    loadNotes(); // 重新加载所有笔记
}
```

#### 3.实现效果界面截图

(1)主页面现在有搜索框和搜索按钮

![拓展基本功能7.1](./运行结果截图/拓展基本功能7.1.png)

(2)输入搜索内容后，点击搜索按钮，显示符合条件的笔记

![拓展基本功能7.2](./运行结果截图/拓展基本功能7.2.png)

### （三）.时间戳功能

#### 1.功能要求

每个笔记都显示创建时间和修改时间，在修改笔记后更新为修改时间

#### 2.实现思路和技术实现

(1)在NotePadProvider类中添加时间戳处理

```java
// Gets the current system time in milliseconds
Long now = Long.valueOf(System.currentTimeMillis());
Date date = new Date(now);
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
String formattedDate = format.format(date);

// If the values map doesn't contain the creation date, sets the value to the current time.
if (values.containsKey(NotePad.Notes.COLUMN_NAME_CREATE_DATE) == false) {
    values.put(NotePad.Notes.COLUMN_NAME_CREATE_DATE, formattedDate);
}

// If the values map doesn't contain the modification date, sets the value to the current
// time.
if (values.containsKey(NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE) == false) {
    values.put(NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE, formattedDate);
}
```

(2)在NoteEditor类的updateNote方法中更新修改时间

```java
Long now = Long.valueOf(System.currentTimeMillis());
Date date = new Date(now);
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
String formattedDate = format.format(date);
values.put(NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE, formattedDate);
```

(3)在CategoryCursorAdapter的getView方法中格式化时间显示

```java
// 格式化日期显示
TextView dateView = (TextView) view.findViewById(android.R.id.text2);
if (dateView != null && getCursor() != null && getCursor().moveToPosition(position)) {
    long dateMillis = getCursor().getLong(COLUMN_INDEX_MODIFICATION_DATE);
    // 使用SimpleDateFormat格式化时间
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    String formattedDate = dateFormat.format(new Date(dateMillis));
    dateView.setText(formattedDate);
}
```

(4)在列表项布局中添加时间戳显示

```xml
<TextView
    android:id="@android:id/text2"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:textSize="14sp"
    android:textColor="#666666"
    android:layout_marginTop="4dp"
    android:singleLine="true"
    android:ellipsize="end" />
```

#### 3.实现效果界面截图

(1)笔记列表中的每个条目现在显示标题、时间戳和正文预览

![拓展基本功能8.1](./运行结果截图/拓展基本功能8.1.png)

(2)创建新笔记时，显示当前时间

![拓展基本功能8.2](./运行结果截图/拓展基本功能8.2.png)

(3)修改笔记后，时间戳更新为修改时间

![拓展基本功能8.3](./运行结果截图/拓展基本功能8.3.png)

### （四）.分类选择功能

#### 1.功能要求

在笔记编辑页面支持选择不同的笔记分类，方便用户对笔记进行分类管理

#### 2.实现思路和技术实现

(1)在笔记编辑页面布局中添加分类选择Spinner

```xml
<!-- 分类选择区域 -->
<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:padding="12dp"
    android:background="#f5f5f5">
  
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="分类："
        android:textSize="16sp"
        android:textColor="#333333"
        android:layout_gravity="center_vertical" />
      
    <Spinner
        android:id="@+id/category_spinner"
        android:layout_width="match_parent"
        android:layout_height="48dp"
        android:layout_marginLeft="8dp"
        android:background="@drawable/rounded_corner_spinner"
        android:popupBackground="#ffffff"
        android:spinnerMode="dropdown"
        android:paddingLeft="16dp"
        android:paddingRight="16dp" />
</LinearLayout>
```

(2)在NoteEditor类中初始化分类Spinner和适配器

```java
// 初始化分类Spinner
mCategorySpinner = (Spinner) findViewById(R.id.category_spinner);

// 加载分类数据
loadCategories();
```

(3)实现loadCategories方法，加载分类数据

```java
/**
 * 加载分类数据
 */
private void loadCategories() {
    // 查询分类数据
    Cursor categoryCursor = getContentResolver().query(
            NotePad.Categories.CONTENT_URI,
            new String[] { NotePad.Categories._ID, NotePad.Categories.COLUMN_NAME_NAME },
            null, null, null);
  
    // 创建适配器
    mCategoryAdapter = new SimpleCursorAdapter(
            this,
            android.R.layout.simple_spinner_item,
            categoryCursor,
            new String[] { NotePad.Categories.COLUMN_NAME_NAME },
            new int[] { android.R.id.text1 },
            0);
  
    // 设置下拉列表样式
    mCategoryAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  
    // 设置适配器
    mCategorySpinner.setAdapter(mCategoryAdapter);
  
    // 设置分类选择监听器
    mCategorySpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
        @Override
        public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
            mSelectedCategoryId = id;
        }
      
        @Override
        public void onNothingSelected(AdapterView<?> parent) {
            mSelectedCategoryId = 0;
        }
    });
}
```

(4)在保存笔记时更新分类信息

```java
/**
 * 更新笔记
 */
private void updateNote(String text, String title) {
    // 创建ContentValues对象
    ContentValues values = new ContentValues();
  
    // 更新分类ID
    values.put(NotePad.Notes.COLUMN_NAME_CATEGORY_ID, mSelectedCategoryId);
  
    // 更新其他字段...
  
    // 执行更新操作
    getContentResolver().update(
            mUri,
            values,
            null,
            null);
}
```

#### 3.实现效果界面截图

(1)笔记编辑页面现在有分类选择下拉框

![拓展基本功能10.1](./运行结果截图/拓展基本功能10.1.png)

(2)点击下拉框显示所有可用分类

![拓展基本功能10.2](./运行结果截图/拓展基本功能10.2.png)

### （五）.批量删除功能

#### 1.功能要求

支持长按笔记进入多选模式，可选择多个笔记进行批量删除操作

#### 2.实现思路和技术实现

(1)在主页面设置长按事件监听

```java
// 设置长按进入多选模式
getListView().setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
    @Override
    public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
        if (!mMultiSelectMode) {
            startMultiSelectMode(position, view);
            return true;
        }
        return false;
    }
});
```

(2)实现多选模式相关变量

```java
// 多选模式相关变量
private boolean mMultiSelectMode = false;
private SparseBooleanArray mSelectedItemsIds;
```

(3)实现开始多选模式方法

```java
/**
 * 开始多选模式
 */
private void startMultiSelectMode(int position, View view) {
    mMultiSelectMode = true;
    mSelectedItemsIds.clear();
    toggleSelection(position, view);
    invalidateOptionsMenu(); // 刷新菜单
}
```

(4)实现切换选择状态方法

```java
/**
 * 切换选择状态
 */
private void toggleSelection(int position, View view) {
    boolean isSelected = mSelectedItemsIds.get(position, false);
    mSelectedItemsIds.put(position, !isSelected);
  
    // 更新视图显示选中状态
    if (view != null) {
        LinearLayout itemLayout = (LinearLayout) view;
        if (!isSelected) {
            // 使用正确的方式获取颜色资源
            itemLayout.setBackgroundColor(getResources().getColor(android.R.color.holo_blue_light));
        } else {
            // 使用正确的方式获取颜色资源
            itemLayout.setBackgroundColor(getResources().getColor(android.R.color.transparent));
        }
    }
  
    // 刷新菜单
    invalidateOptionsMenu();
}
```

(5)实现批量删除方法

```java
/**
 * 批量删除选中的笔记
 */
private void deleteSelectedNotes(long[] noteIds) {
    try {
        if (noteIds.length > 0) {
            // 构建IN子句的WHERE条件，实现批量删除
            StringBuilder whereClause = new StringBuilder();
            whereClause.append(NotePad.Notes._ID).append(" IN (");
            String[] whereArgs = new String[noteIds.length];
          
            for (int i = 0; i < noteIds.length; i++) {
                whereClause.append("?");
                if (i < noteIds.length - 1) {
                    whereClause.append(", ");
                }
                whereArgs[i] = String.valueOf(noteIds[i]);
            }
            whereClause.append(")");
          
            // 执行批量删除
            int deletedCount = getContentResolver().delete(
                    NotePad.Notes.CONTENT_URI,  // 使用基础URI
                    whereClause.toString(),     // WHERE条件
                    whereArgs                   // 条件参数
            );
          
            // 取消多选模式
            cancelMultiSelectMode();
          
            // 刷新笔记列表
            loadNotes();
          
            // 显示删除成功提示
            Toast.makeText(this, "已成功删除 " + deletedCount + " 个笔记", Toast.LENGTH_SHORT).show();
        }
    } catch (Exception e) {
        // 显示删除失败提示
        Toast.makeText(this, "删除失败：" + e.getMessage(), Toast.LENGTH_SHORT).show();
        Log.e(TAG, "批量删除笔记失败", e);
    }
}
```

(6)实现获取选中笔记ID方法

```java
/**
 * 获取选中的笔记ID数组
 */
private long[] getSelectedNoteIds() {
    // 首先计算有多少个选中的项
    int selectedCount = 0;
    for (int i = 0; i < mSelectedItemsIds.size(); i++) {
        if (mSelectedItemsIds.valueAt(i)) {
            selectedCount++;
        }
    }
  
    if (selectedCount == 0) return new long[0];
  
    Cursor cursor = (Cursor) getListAdapter().getItem(0);
    if (cursor == null) return new long[0];
  
    long[] ids = new long[selectedCount];
    int index = 0;
  
    // 注意：_ID列的索引是0，而不是COLUMN_INDEX_TITLE
    for (int i = 0; i < mSelectedItemsIds.size(); i++) {
        int position = mSelectedItemsIds.keyAt(i);
        if (mSelectedItemsIds.valueAt(i)) {
            cursor.moveToPosition(position);
            ids[index++] = cursor.getLong(0); // 0是_ID列的索引
        }
    }
  
    return ids;
}
```

(7)实现取消多选模式方法

```java
/**
 * 取消多选模式
 */
private void cancelMultiSelectMode() {
    mMultiSelectMode = false;
    mSelectedItemsIds.clear();
    invalidateOptionsMenu();
    // 重新加载笔记以重置视图状态
    loadNotes();
}
```

#### 3.实现效果界面截图

(1)长按笔记进入多选模式

![拓展基本功能12.1](./运行结果截图/拓展基本功能12.1.png)

(2)选择多个笔记项

![拓展基本功能12.2](./运行结果截图/拓展基本功能12.1.png)

(3)点击删除选中项，显示确认对话框

![拓展基本功能12.3](./运行结果截图/拓展基本功能12.3.png)

(4)删除成功
![拓展基本功能12.4](./运行结果截图/拓展基本功能12.4.png)

### （六）.排序功能

#### 1.功能要求

支持按不同字段排序，包括修改日期、标题和分类

#### 2.实现思路和技术实现

(1)在菜单中添加排序选项

```java
// 添加排序菜单
SubMenu sortMenu = menu.addSubMenu(Menu.NONE, SORT_MENU_ID, Menu.NONE, "排序");
sortMenu.add(Menu.NONE, SORT_BY_DATE_MODIFIED_DESC, Menu.NONE, "按修改日期降序");
sortMenu.add(Menu.NONE, SORT_BY_DATE_MODIFIED_ASC, Menu.NONE, "按修改日期升序");
sortMenu.add(Menu.NONE, SORT_BY_TITLE_ASC, Menu.NONE, "按标题升序");
sortMenu.add(Menu.NONE, SORT_BY_TITLE_DESC, Menu.NONE, "按标题降序");
sortMenu.add(Menu.NONE, SORT_BY_CATEGORY, Menu.NONE, "按分类排序");
```

(2)在onOptionsItemSelected方法中处理排序选项

```java
} else if (id == SORT_BY_DATE_MODIFIED_DESC) {
    // 按修改日期降序排序
    mCurrentSortOrder = NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE + " DESC";
    loadNotes();
    return true;
} else if (id == SORT_BY_DATE_MODIFIED_ASC) {
    // 按修改日期升序排序
    mCurrentSortOrder = NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE + " ASC";
    loadNotes();
    return true;
} else if (id == SORT_BY_TITLE_ASC) {
    // 按标题升序排序
    mCurrentSortOrder = NotePad.Notes.COLUMN_NAME_TITLE + " ASC";
    loadNotes();
    return true;
} else if (id == SORT_BY_TITLE_DESC) {
    // 按标题降序排序
    mCurrentSortOrder = NotePad.Notes.COLUMN_NAME_TITLE + " DESC";
    loadNotes();
    return true;
} else if (id == SORT_BY_CATEGORY) {
    // 按分类排序
    mCurrentSortOrder = NotePad.Notes.COLUMN_NAME_CATEGORY_ID + " ASC";
    loadNotes();
    return true;
}
```

(3)在loadNotes方法中使用当前排序方式

```java
// 使用现代的ContentResolver.query方法替代废弃的managedQuery
Cursor cursor = getContentResolver().query(
        uri,
        PROJECTION,            // Which columns to return
        selection,             // Which rows to return (all rows)
        selectionArgs,         // Selection arguments (none)
        mCurrentSortOrder      // 使用当前的排序方式
);
```

(4)初始化mCurrentSortOrder变量

```java
// 当前排序方式
private String mCurrentSortOrder = NotePad.Notes.DEFAULT_SORT_ORDER;
```

#### 3.实现效果界面截图

(1)菜单中现在有"排序"选项，包含多种排序方式

![拓展基本功能9.1](./运行结果截图/拓展基本功能9.1.png)

(2)选择不同的排序方式后，笔记列表按照所选方式排序
(按修改日期降序)

![拓展基本功能9.2](./运行结果截图/拓展基本功能9.2.png)

## 二.技术总结

### （一）.核心技术点

1. **标签筛选**：使用ContentResolver.query方法，通过修改selection参数实现分类筛选
2. **搜索功能**：使用LIKE查询条件，实现按标题和内容搜索
3. **时间戳功能**：使用SimpleDateFormat格式化时间，在CursorAdapter中显示
4. **排序功能**：通过修改sortOrder参数，实现不同排序方式
5. **导出笔记功能**：使用Intent.ACTION_CREATE_DOCUMENT和ContentResolver实现文件导出

### （二）.优化建议

1. **添加搜索历史记录**：保存用户的搜索历史，方便快速搜索
2. **支持高级搜索**：添加更多搜索条件，如按时间范围、分类等
3. **优化排序性能**：对于大数据量，考虑使用索引优化排序性能
4. **添加自定义排序**：允许用户自定义排序规则
5. **支持批量导出**：添加批量导出多个笔记的功能
6. **支持更多导出格式**：除了TXT格式外，支持导出为PDF、HTML等格式

#### 7.导出笔记功能

##### 1.功能要求

用户可以将单个笔记导出为文本文件，方便备份和分享。

##### 2.实现思路与代码

（1）在编辑器菜单中添加导出选项

```java
<item android:id="@+id/menu_export"
    android:title="导出笔记"
    android:icon="@android:drawable/ic_menu_save"
    android:showAsAction="never" />
```

（2）在NoteEditor类中实现exportNote方法

```java
private void exportNote() {
    // 获取笔记标题和内容
    EditText mNoteTitle = (EditText) findViewById(R.id.note_title);
    String title = mNoteTitle.getText().toString();
    String content = mText.getText().toString();
    
    // 如果笔记为空，不允许导出
    if (title.isEmpty() && content.isEmpty()) {
        Toast.makeText(this, "笔记内容为空，无法导出", Toast.LENGTH_SHORT).show();
        return;
    }
    
    // 生成导出文件名
    String fileName = title.isEmpty() ? "无标题笔记" : title;
    // 替换文件名中的特殊字符
    fileName = fileName.replaceAll("[/\\:*?\"<>|]", "_");
    // 添加时间戳
    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd_HHmmss");
    String timestamp = sdf.format(new Date());
    fileName = fileName + "_" + timestamp + ".txt";
    
    // 构建导出内容
    StringBuilder exportContent = new StringBuilder();
    if (!title.isEmpty()) {
        exportContent.append(title).append("\n\n");
    }
    exportContent.append(content);
    
    try {
        // 使用Intent.ACTION_CREATE_DOCUMENT来让用户选择保存位置
        Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        intent.setType("text/plain");
        intent.putExtra(Intent.EXTRA_TITLE, fileName);
        startActivityForResult(intent, 1001);
    } catch (Exception e) {
        Log.e(TAG, "导出失败: " + e.getMessage());
        Toast.makeText(this, "导出失败: " + e.getMessage(), Toast.LENGTH_SHORT).show();
    }
}
```

（3）在onActivityResult方法中处理文件保存

```java
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    
    if (requestCode == 1001 && resultCode == RESULT_OK) {
        // 获取用户选择的保存位置
        Uri uri = data.getData();
        if (uri != null) {
            try {
                // 获取笔记内容
                EditText mNoteTitle = (EditText) findViewById(R.id.note_title);
                String title = mNoteTitle.getText().toString();
                String content = mText.getText().toString();
                
                // 构建导出内容
                StringBuilder exportContent = new StringBuilder();
                if (!title.isEmpty()) {
                    exportContent.append(title).append("\n\n");
                }
                exportContent.append(content);
                
                // 写入文件
                ContentResolver resolver = getContentResolver();
                FileOutputStream fos = (FileOutputStream) resolver.openOutputStream(uri);
                fos.write(exportContent.toString().getBytes());
                fos.close();
                
                Toast.makeText(this, "笔记导出成功", Toast.LENGTH_SHORT).show();
            } catch (IOException e) {
                Log.e(TAG, "写入文件失败: " + e.getMessage());
                Toast.makeText(this, "导出失败: " + e.getMessage(), Toast.LENGTH_SHORT).show();
            }
        }
    }
}
```

（4）在onOptionsItemSelected方法中添加导出选项的处理

```java
else if (id == R.id.menu_export) {
    exportNote();
    return true;
}
```

##### 3.实现效果界面截图

(1)编辑器菜单中有"导出笔记"选项

![拓展基本功能11.1](./运行结果截图/拓展基本功能11.1.png)


(2)选择导出后，系统会打开文件保存对话框，用户可以选择保存位置

![拓展基本功能11.2](./运行结果截图/拓展基本功能11.2.png)


(3)导出成功后会显示提示信息

![拓展基本功能11.3](./运行结果截图/拓展基本功能11.3.png)

## 三.总结

本NotePad应用经过功能拓展，现在具备了更加完善的功能：

1. **标签筛选**：支持按分类筛选笔记，方便用户管理和查找
2. **搜索功能**：支持按标题和内容搜索笔记，实时过滤结果
3. **时间戳功能**：显示笔记的创建和修改时间，方便用户了解笔记的时间线
4. **分类选择功能**：在编辑页面支持选择不同的笔记分类，方便用户对笔记进行分类管理
5. **批量删除功能**：支持长按笔记进入多选模式，可选择多个笔记进行批量删除操作
6. **排序功能**：支持按不同字段排序，包括修改日期、标题和分类
7. **导出笔记功能**：支持将单条笔记导出为文本文件，用户可以自定义保存位置，方便备份和分享

这些功能的实现，使得NotePad应用更加实用、易用和灵活，能够满足用户的各种笔记管理需求。