Android编写一个查找当前路径下所有重复文件的函数

好的，我可以为您提供一个参考代码段：

import os

def find_duplicate_files():
    seen_files = {}
    for root, dirs, files in os.walk("."):
        for filename in files:
            full_path = os.path.join(root, filename)
            if os.path.isfile(full_path):
                with open(full_path, "rb") as f:
                    filehash = hashlib.md5(f.read()).hexdigest()
                if filehash in seen_files:
                    print("Duplicate found: {}".format(full_path))
                else:
                    seen_files[filehash] = full_path

该函数使用`os.walk()`方法遍历当前目录（包括所有子目录）下的所有文件，并使用MD5算法生成每个文件的散列值，如果发现有两个文件具有相同的散列值，则它们被视为重复文件。

相关问题

Android编写一个搜索当前路径下所有重复文件的函数

可以尝试采用以下方式编写一个搜索当前路径下所有重复文件的函数：

1. 获取当前路径。
2. 遍历当前路径下的所有文件和子目录。
3. 对于每个文件，计算并记录其特征值（可以采用文件哈希、文件名和大小等方式进行计算）。
4. 如果同一个特征值对应的文件数大于1，则认为这些文件是重复的文件，并输出它们的路径和文件名。

以下是基于Python的实现代码示例：

import os
import hashlib

def search_duplicate_files():
    current_path = os.getcwd()
    file_hash_dict = {}
    for root, dirs, files in os.walk(current_path):
        for file in files:
            file_path = os.path.join(root, file)
            file_hash = get_file_hash(file_path)
            if file_hash in file_hash_dict:
                file_hash_dict[file_hash].append(file_path)
            else:
                file_hash_dict[file_hash] = [file_path]
    for file_hash, file_paths in file_hash_dict.items():
        if len(file_paths) > 1:
            print('重复文件：')
            for file_path in file_paths:
                print(file_path)

def get_file_hash(file_path):
    with open(file_path, 'rb') as f:
        file_hash = hashlib.md5(f.read()).hexdigest()
    return file_hash

search_duplicate_files()

Android编写一个搜索指定路径下所有重复文件的函数

可以使用哈希表（Hash Table）来实现。遍历指定路径下的所有文件，对每个文件进行哈希处理，如果该哈希值已经存在于哈希表中，则说明找到了重复文件，将其路径存储到一个列表中。最后返回该列表即可。以下是部分示例代码（仅供参考）：

import java.io.File;
import java.io.FileInputStream;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.HashMap;

public class FileSearch {
    
    public static void main(String[] args) {
        String path = "指定路径";
        ArrayList<String> duplicates = searchDuplicates(path);
        System.out.println(duplicates.toString());
    }
    
    public static ArrayList<String> searchDuplicates(String path) {
        File dir = new File(path);
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException("Path is not a directory.");
        }
        HashMap<String, String> hashTable = new HashMap<>();
        ArrayList<String> duplicates = new ArrayList<>();
        try {
            for (File file : dir.listFiles()) {
                if (file.isDirectory()) {
                    duplicates.addAll(searchDuplicates(file.getPath()));
                } else {
                    String md5 = getMD5(file);
                    String existing = hashTable.get(md5);
                    if (existing != null) {
                        duplicates.add(existing);
                        duplicates.add(file.getPath());
                    } else {
                        hashTable.put(md5, file.getPath());
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return duplicates;
    }
    
    private static String getMD5(File file) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        FileInputStream fis = new FileInputStream(file);
        byte[] buffer = new byte[1024];
        int length;
        while ((length = fis.read(buffer)) != -1) {
            md.update(buffer, 0, length);
        }
        fis.close();
        BigInteger bigInt = new BigInteger(1, md.digest());
        return bigInt.toString(16);
    }
}

请注意，该方法只能找到哈希值相同的文件，并不一定是完全相同的文件。如果存在两个或多个不同的文件，它们的哈希值相同，该方法将视为重复文件。为了降低误判率，可以在哈希表中存储文件大小信息，并在比较哈希值前先比较文件大小。