精华内容
下载资源
问答
  • 手机内存卡几乎每天都得使用,使用率非常高,当然出错或出毛病的时间也会很多。如果遇到内存卡读不出来了,该怎么办?接下来,小编就向大家介绍手机内存卡读取不了的解决方案。1、手机卡坏掉或者接触不良造成手机内存...

    手机内存卡几乎每天都得使用,使用率非常高,当然出错或出毛病的时间也会很多。如果遇到内存卡读不出来了,该怎么办?接下来,小编就向大家介绍手机内存卡读取不了的解决方案。

    8d4decdcca82a6ba11118a1e6e2f8f2a.png

    1、 手机卡坏掉或者接触不良造成手机内存卡读不出来。如果是接触不良这是很好解决的问题,将卡取出,用橡皮擦擦内存卡的金手指,去掉上面的氧化层,再放入手机试试。若还不行,把内存卡座里面的触角片撬高点,或者在内存卡后面涂一层胶水来增加其厚度就可以了。将卡插入读卡器(确定读卡是好的),再将读卡插到电脑上,看能否读出卡中数据。 若电脑能读卡,说明卡没问题,可能手机卡槽有问题,再找一张正常卡插入试试,若其他卡插入也读不出,则是手机卡槽坏了,请人维修一下。

    2、 中毒所造成手机内存卡读不出来。这种情况比较多的,中毒还会导致内存卡无法格式化的问题,一般是不好修复的。如果是中病毒造成手机内存卡读不出来的情况,就要把内存卡格式化掉,(有时候会出现内存卡无法格式化和内存卡无法格式化失败的问题)一般能格式化的内存卡都能修复问题的。不能格式化的内存卡就不太好修复了,当然也可以借助内存卡修复软件来修复。如果里面有重要的数据那就得用数据恢复工具恢复里面地数据了,注意格式化后不要往内存卡里面写入数据,这样会造成恢复文件不完全的。

    以上就是腾讯电脑管家提供的电脑中的木马病毒如何彻底查杀方案,希望能给大家带来帮助!

    展开全文
  • 获取手机中外置内存卡、内置内存卡手机内存路径。思路是:先用 Environment.getExternalStorageDirectory()获得外部存储卡路径(某些机型也表现为内部存储卡路径),如没有获 取到有效sd卡插入,则使用安卓的配置...

    http://www.open-open.com/code/view/1433585940578

    首先内部存储路径为/data/data/youPackageName/,下面讲解的各路径都是基于你自己的应用的内部存储路径下。所有内部存储中保存的文件在用户卸载应用的时候会被删除。

    一、 files
    1. Context.getFilesDir(),该方法返回/data/data/youPackageName/files的File对象。
    2. Context.openFileInput()与Context.openFileOutput(),只能读取和写入files下的文件,返回的是FileInputStream和FileOutputStream对象。
    3. Context.fileList(),返回files下所有的文件名,返回的是String[]对象。
    4. Context.deleteFile(String),删除files下指定名称的文件。

    二、cache
    1. Context.getCacheDir(),该方法返回/data/data/youPackageName/cache的File对象。

    三、custom dir

    getDir(String name, int mode),返回/data/data/youPackageName/下的指定名称的文件夹File对象,如果该文件夹不存在则用指定名称创建一个新的文件夹

    //  获取当前程序路径

        getApplicationContext().getFilesDir().getAbsolutePath();

    //  获取该程序的安装包路径
        String path=getApplicationContext().getPackageResourcePath();

    //  获取程序默认数据库路径
        getApplicationContext().getDatabasePath(s).getAbsolutePath();

    //===============================================

    分割线

    ================================================

    获取手机中外置内存卡、内置内存卡、手机内存路径。思路是:先用 Environment.getExternalStorageDirectory()获得外部存储卡路径(某些机型也表现为内部存储卡路径),如没有获 取到有效sd卡插入,则使用安卓的配置文件system/etc/vold.fstab读取全部挂载信息,假如也没有可写入的sd卡,则使用 getFilesDir()方式获得当前应用所在存储路径。为适应不同手机的内存情况,先分三种情况获得可存储路径phonePicsPath,后面代码较长是因为有两个工具类,复制即可,代码如下:


    //首先判断是否有外部存储卡,如没有判断是否有内部存储卡,如没有,继续读取应用程序所在存储
    		if(getExternalSdCardPath() != null){
    			phonePicsPath = getExternalSdCardPath();
    		}else{
    			phonePicsPath = getFilesDir().getAbsolutePath();
    		}


    /**
         * 遍历 "system/etc/vold.fstab” 文件,获取全部的Android的挂载点信息
         * 
         * @return
         */
        private static ArrayList<String> getDevMountList() {
            String[] toSearch = FileUtils.readFile("/system/etc/vold.fstab").split(" ");
            ArrayList<String> out = new ArrayList<String>();
            for (int i = 0; i < toSearch.length; i++) {
                if (toSearch[i].contains("dev_mount")) {
                    if (new File(toSearch[i + 2]).exists()) {
                        out.add(toSearch[i + 2]);
                    }
                }
            }
            return out;
        }
    /**
         * 获取扩展SD卡存储目录
         * 
         * 如果有外接的SD卡,并且已挂载,则返回这个外置SD卡目录
         * 否则:返回内置SD卡目录
         * 
         * @return
         */
        public static String getExternalSdCardPath() {
     
            if (SDCardUtils.isMounted()) {
                File sdCardFile = new File(Environment.getExternalStorageDirectory().getAbsolutePath());
                return sdCardFile.getAbsolutePath();
            }
     
            String path = null;
     
            File sdCardFile = null;
     
            ArrayList<String> devMountList = getDevMountList();
     
            for (String devMount : devMountList) {
                File file = new File(devMount);
     
                if (file.isDirectory() && file.canWrite()) {
                    path = file.getAbsolutePath();
     
                    String timeStamp = new SimpleDateFormat("ddMMyyyy_HHmmss").format(new Date());
                    File testWritable = new File(path, "test_" + timeStamp);
     
                    if (testWritable.mkdirs()) {
                        testWritable.delete();
                    } else {
                        path = null;
                    }
                }
            }
     
            if (path != null) {
                sdCardFile = new File(path);
                return sdCardFile.getAbsolutePath();
            }
     
            return null;
        }



    FileUtils文件:



    package com.zqsy.order.tools;
    
    /***
     * 文件工具类
     * @author zhangda
     *
     */
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    import android.text.TextUtils;
    
    /**
     * File Utils
     * <ul>
     * Read or write file
     * <li>{@link #readFile(String)} read file</li>
     * <li>{@link #readFileToList(String)} read file to string list</li>
     * <li>{@link #writeFile(String, String, boolean)} write file from String</li>
     * <li>{@link #writeFile(String, String)} write file from String</li>
     * <li>{@link #writeFile(String, List, boolean)} write file from String List</li>
     * <li>{@link #writeFile(String, List)} write file from String List</li>
     * <li>{@link #writeFile(String, InputStream)} write file</li>
     * <li>{@link #writeFile(String, InputStream, boolean)} write file</li>
     * <li>{@link #writeFile(File, InputStream)} write file</li>
     * <li>{@link #writeFile(File, InputStream, boolean)} write file</li>
     * </ul>
     * <ul>
     * Operate file
     * <li>{@link #moveFile(File, File)} or {@link #moveFile(String, String)}</li>
     * <li>{@link #copyFile(String, String)}</li>
     * <li>{@link #getFileExtension(String)}</li>
     * <li>{@link #getFileName(String)}</li>
     * <li>{@link #getFileNameWithoutExtension(String)}</li>
     * <li>{@link #getFileSize(String)}</li>
     * <li>{@link #deleteFile(String)}</li>
     * <li>{@link #isFileExist(String)}</li>
     * <li>{@link #isFolderExist(String)}</li>
     * <li>{@link #makeFolders(String)}</li>
     * <li>{@link #makeDirs(String)}</li>
     * </ul>
     * 
     * @author <a href="http://www.trinea.cn" target="_blank">Trinea</a> 2012-5-12
     */
    public class FileUtils {
    
        public final static String FILE_EXTENSION_SEPARATOR = ".";
    
        private FileUtils() {
            throw new AssertionError();
        }
    
        /**
         * read file
         * 
         * @param filePath
         * @param charsetName The name of a supported {@link java.nio.charset.Charset </code>charset<code>}
         * @return if file not exist, return null, else return content of file
         * @throws RuntimeException if an error occurs while operator BufferedReader
         */
        public static String readFile(String filePath) {
        	String fileContent = "";
            File file = new File(filePath);
            if (file == null || !file.isFile()) {
                return null;
            }
    
            BufferedReader reader = null;
            try {
                InputStreamReader is = new InputStreamReader(new FileInputStream(file));
                reader = new BufferedReader(is);
                String line = null;
                int i = 0;
                while ((line = reader.readLine()) != null) {
                    fileContent += line + " ";
                }
                reader.close();
                return fileContent;
            } catch (IOException e) {
            	e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                    	e.printStackTrace();
                    }
                }
            }
            return fileContent;
        }
    
        /**
         * write file
         * 
         * @param filePath
         * @param content
         * @param append is append, if true, write to the end of file, else clear content of file and write into it
         * @return return false if content is empty, true otherwise
         * @throws RuntimeException if an error occurs while operator FileWriter
         */
        public static boolean writeFile(String filePath, String content, boolean append) {
            if (StringUtils.isEmpty(content)) {
                return false;
            }
    
            FileWriter fileWriter = null;
            try {
                makeDirs(filePath);
                fileWriter = new FileWriter(filePath, append);
                fileWriter.write(content);
                fileWriter.close();
                return true;
            } catch (IOException e) {
                throw new RuntimeException("IOException occurred. ", e);
            } finally {
                if (fileWriter != null) {
                    try {
                        fileWriter.close();
                    } catch (IOException e) {
                        throw new RuntimeException("IOException occurred. ", e);
                    }
                }
            }
        }
    
        /**
         * write file
         * 
         * @param filePath
         * @param contentList
         * @param append is append, if true, write to the end of file, else clear content of file and write into it
         * @return return false if contentList is empty, true otherwise
         * @throws RuntimeException if an error occurs while operator FileWriter
         */
        public static boolean writeFile(String filePath, List<String> contentList, boolean append) {
            if (contentList == null || contentList.size() == 0) {
                return false;
            }
    
            FileWriter fileWriter = null;
            try {
                makeDirs(filePath);
                fileWriter = new FileWriter(filePath, append);
                int i = 0;
                for (String line : contentList) {
                    if (i++ > 0) {
                        fileWriter.write("\r\n");
                    }
                    fileWriter.write(line);
                }
                fileWriter.close();
                return true;
            } catch (IOException e) {
                throw new RuntimeException("IOException occurred. ", e);
            } finally {
                if (fileWriter != null) {
                    try {
                        fileWriter.close();
                    } catch (IOException e) {
                        throw new RuntimeException("IOException occurred. ", e);
                    }
                }
            }
        }
    
        /**
         * write file, the string will be written to the begin of the file
         * 
         * @param filePath
         * @param content
         * @return
         */
        public static boolean writeFile(String filePath, String content) {
            return writeFile(filePath, content, false);
        }
    
        /**
         * write file, the string list will be written to the begin of the file
         * 
         * @param filePath
         * @param contentList
         * @return
         */
        public static boolean writeFile(String filePath, List<String> contentList) {
            return writeFile(filePath, contentList, false);
        }
    
        /**
         * write file, the bytes will be written to the begin of the file
         * 
         * @param filePath
         * @param stream
         * @return
         * @see {@link #writeFile(String, InputStream, boolean)}
         */
        public static boolean writeFile(String filePath, InputStream stream) {
            return writeFile(filePath, stream, false);
        }
    
        /**
         * write file
         * 
         * @param file the file to be opened for writing.
         * @param stream the input stream
         * @param append if <code>true</code>, then bytes will be written to the end of the file rather than the beginning
         * @return return true
         * @throws RuntimeException if an error occurs while operator FileOutputStream
         */
        public static boolean writeFile(String filePath, InputStream stream, boolean append) {
            return writeFile(filePath != null ? new File(filePath) : null, stream, append);
        }
    
        /**
         * write file, the bytes will be written to the begin of the file
         * 
         * @param file
         * @param stream
         * @return
         * @see {@link #writeFile(File, InputStream, boolean)}
         */
        public static boolean writeFile(File file, InputStream stream) {
            return writeFile(file, stream, false);
        }
    
        /**
         * write file
         * 
         * @param file the file to be opened for writing.
         * @param stream the input stream
         * @param append if <code>true</code>, then bytes will be written to the end of the file rather than the beginning
         * @return return true
         * @throws RuntimeException if an error occurs while operator FileOutputStream
         */
        public static boolean writeFile(File file, InputStream stream, boolean append) {
            OutputStream o = null;
            try {
                makeDirs(file.getAbsolutePath());
                o = new FileOutputStream(file, append);
                byte data[] = new byte[1024];
                int length = -1;
                while ((length = stream.read(data)) != -1) {
                    o.write(data, 0, length);
                }
                o.flush();
                return true;
            } catch (FileNotFoundException e) {
                throw new RuntimeException("FileNotFoundException occurred. ", e);
            } catch (IOException e) {
                throw new RuntimeException("IOException occurred. ", e);
            } finally {
                if (o != null) {
                    try {
                        o.close();
                        stream.close();
                    } catch (IOException e) {
                        throw new RuntimeException("IOException occurred. ", e);
                    }
                }
            }
        }
    
        /**
         * move file
         * 
         * @param sourceFilePath
         * @param destFilePath
         */
        public static void moveFile(String sourceFilePath, String destFilePath) {
            if (TextUtils.isEmpty(sourceFilePath) || TextUtils.isEmpty(destFilePath)) {
                throw new RuntimeException("Both sourceFilePath and destFilePath cannot be null.");
            }
            moveFile(new File(sourceFilePath), new File(destFilePath));
        }
    
        /**
         * move file
         * 
         * @param srcFile
         * @param destFile
         */
        public static void moveFile(File srcFile, File destFile) {
            boolean rename = srcFile.renameTo(destFile);
            if (!rename) {
                copyFile(srcFile.getAbsolutePath(), destFile.getAbsolutePath());
                deleteFile(srcFile.getAbsolutePath());
            }
        }
    
        /**
         * copy file
         * 
         * @param sourceFilePath
         * @param destFilePath
         * @return
         * @throws RuntimeException if an error occurs while operator FileOutputStream
         */
        public static boolean copyFile(String sourceFilePath, String destFilePath) {
            InputStream inputStream = null;
            try {
                inputStream = new FileInputStream(sourceFilePath);
            } catch (FileNotFoundException e) {
                throw new RuntimeException("FileNotFoundException occurred. ", e);
            }
            return writeFile(destFilePath, inputStream);
        }
    
        /**
         * read file to string list, a element of list is a line
         * 
         * @param filePath
         * @param charsetName The name of a supported {@link java.nio.charset.Charset </code>charset<code>}
         * @return if file not exist, return null, else return content of file
         * @throws RuntimeException if an error occurs while operator BufferedReader
         */
        public static List<String> readFileToList(String filePath, String charsetName) {
            File file = new File(filePath);
            List<String> fileContent = new ArrayList<String>();
            if (file == null || !file.isFile()) {
                return null;
            }
    
            BufferedReader reader = null;
            try {
                InputStreamReader is = new InputStreamReader(new FileInputStream(file), charsetName);
                reader = new BufferedReader(is);
                String line = null;
                while ((line = reader.readLine()) != null) {
                    fileContent.add(line);
                }
                reader.close();
                return fileContent;
            } catch (IOException e) {
                throw new RuntimeException("IOException occurred. ", e);
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        throw new RuntimeException("IOException occurred. ", e);
                    }
                }
            }
        }
    
        /**
         * get file name from path, not include suffix
         * 
         * <pre>
         *      getFileNameWithoutExtension(null)               =   null
         *      getFileNameWithoutExtension("")                 =   ""
         *      getFileNameWithoutExtension("   ")              =   "   "
         *      getFileNameWithoutExtension("abc")              =   "abc"
         *      getFileNameWithoutExtension("a.mp3")            =   "a"
         *      getFileNameWithoutExtension("a.b.rmvb")         =   "a.b"
         *      getFileNameWithoutExtension("c:\\")              =   ""
         *      getFileNameWithoutExtension("c:\\a")             =   "a"
         *      getFileNameWithoutExtension("c:\\a.b")           =   "a"
         *      getFileNameWithoutExtension("c:a.txt\\a")        =   "a"
         *      getFileNameWithoutExtension("/home/admin")      =   "admin"
         *      getFileNameWithoutExtension("/home/admin/a.txt/b.mp3")  =   "b"
         * </pre>
         * 
         * @param filePath
         * @return file name from path, not include suffix
         * @see
         */
        public static String getFileNameWithoutExtension(String filePath) {
            if (StringUtils.isEmpty(filePath)) {
                return filePath;
            }
    
            int extenPosi = filePath.lastIndexOf(FILE_EXTENSION_SEPARATOR);
            int filePosi = filePath.lastIndexOf(File.separator);
            if (filePosi == -1) {
                return (extenPosi == -1 ? filePath : filePath.substring(0, extenPosi));
            }
            if (extenPosi == -1) {
                return filePath.substring(filePosi + 1);
            }
            return (filePosi < extenPosi ? filePath.substring(filePosi + 1, extenPosi) : filePath.substring(filePosi + 1));
        }
    
        /**
         * get file name from path, include suffix
         * 
         * <pre>
         *      getFileName(null)               =   null
         *      getFileName("")                 =   ""
         *      getFileName("   ")              =   "   "
         *      getFileName("a.mp3")            =   "a.mp3"
         *      getFileName("a.b.rmvb")         =   "a.b.rmvb"
         *      getFileName("abc")              =   "abc"
         *      getFileName("c:\\")              =   ""
         *      getFileName("c:\\a")             =   "a"
         *      getFileName("c:\\a.b")           =   "a.b"
         *      getFileName("c:a.txt\\a")        =   "a"
         *      getFileName("/home/admin")      =   "admin"
         *      getFileName("/home/admin/a.txt/b.mp3")  =   "b.mp3"
         * </pre>
         * 
         * @param filePath
         * @return file name from path, include suffix
         */
        public static String getFileName(String filePath) {
            if (StringUtils.isEmpty(filePath)) {
                return filePath;
            }
    
            int filePosi = filePath.lastIndexOf(File.separator);
            return (filePosi == -1) ? filePath : filePath.substring(filePosi + 1);
        }
    
        /**
         * get folder name from path
         * 
         * <pre>
         *      getFolderName(null)               =   null
         *      getFolderName("")                 =   ""
         *      getFolderName("   ")              =   ""
         *      getFolderName("a.mp3")            =   ""
         *      getFolderName("a.b.rmvb")         =   ""
         *      getFolderName("abc")              =   ""
         *      getFolderName("c:\\")              =   "c:"
         *      getFolderName("c:\\a")             =   "c:"
         *      getFolderName("c:\\a.b")           =   "c:"
         *      getFolderName("c:a.txt\\a")        =   "c:a.txt"
         *      getFolderName("c:a\\b\\c\\d.txt")    =   "c:a\\b\\c"
         *      getFolderName("/home/admin")      =   "/home"
         *      getFolderName("/home/admin/a.txt/b.mp3")  =   "/home/admin/a.txt"
         * </pre>
         * 
         * @param filePath
         * @return
         */
        public static String getFolderName(String filePath) {
    
            if (StringUtils.isEmpty(filePath)) {
                return filePath;
            }
    
            int filePosi = filePath.lastIndexOf(File.separator);
            return (filePosi == -1) ? "" : filePath.substring(0, filePosi);
        }
    
        /**
         * get suffix of file from path
         * 
         * <pre>
         *      getFileExtension(null)               =   ""
         *      getFileExtension("")                 =   ""
         *      getFileExtension("   ")              =   "   "
         *      getFileExtension("a.mp3")            =   "mp3"
         *      getFileExtension("a.b.rmvb")         =   "rmvb"
         *      getFileExtension("abc")              =   ""
         *      getFileExtension("c:\\")              =   ""
         *      getFileExtension("c:\\a")             =   ""
         *      getFileExtension("c:\\a.b")           =   "b"
         *      getFileExtension("c:a.txt\\a")        =   ""
         *      getFileExtension("/home/admin")      =   ""
         *      getFileExtension("/home/admin/a.txt/b")  =   ""
         *      getFileExtension("/home/admin/a.txt/b.mp3")  =   "mp3"
         * </pre>
         * 
         * @param filePath
         * @return
         */
        public static String getFileExtension(String filePath) {
            if (StringUtils.isBlank(filePath)) {
                return filePath;
            }
    
            int extenPosi = filePath.lastIndexOf(FILE_EXTENSION_SEPARATOR);
            int filePosi = filePath.lastIndexOf(File.separator);
            if (extenPosi == -1) {
                return "";
            }
            return (filePosi >= extenPosi) ? "" : filePath.substring(extenPosi + 1);
        }
    
        /**
         * Creates the directory named by the trailing filename of this file, including the complete directory path required
         * to create this directory. <br/>
         * <br/>
         * <ul>
         * <strong>Attentions:</strong>
         * <li>makeDirs("C:\\Users\\Trinea") can only create users folder</li>
         * <li>makeFolder("C:\\Users\\Trinea\\") can create Trinea folder</li>
         * </ul>
         * 
         * @param filePath
         * @return true if the necessary directories have been created or the target directory already exists, false one of
         *         the directories can not be created.
         *         <ul>
         *         <li>if {@link FileUtils#getFolderName(String)} return null, return false</li>
         *         <li>if target directory already exists, return true</li>
         *         <li>return {@link java.io.File#makeFolder}</li>
         *         </ul>
         */
        public static boolean makeDirs(String filePath) {
            String folderName = getFolderName(filePath);
            if (StringUtils.isEmpty(folderName)) {
                return false;
            }
    
            File folder = new File(folderName);
            return (folder.exists() && folder.isDirectory()) ? true : folder.mkdirs();
        }
    
        /**
         * @param filePath
         * @return
         * @see #makeDirs(String)
         */
        public static boolean makeFolders(String filePath) {
            return makeDirs(filePath);
        }
    
        /**
         * Indicates if this file represents a file on the underlying file system.
         * 
         * @param filePath
         * @return
         */
        public static boolean isFileExist(String filePath) {
            if (StringUtils.isBlank(filePath)) {
                return false;
            }
    
            File file = new File(filePath);
            return (file.exists() && file.isFile());
        }
    
        /**
         * Indicates if this file represents a directory on the underlying file system.
         * 
         * @param directoryPath
         * @return
         */
        public static boolean isFolderExist(String directoryPath) {
            if (StringUtils.isBlank(directoryPath)) {
                return false;
            }
    
            File dire = new File(directoryPath);
            return (dire.exists() && dire.isDirectory());
        }
    
        /**
         * delete file or directory
         * <ul>
         * <li>if path is null or empty, return true</li>
         * <li>if path not exist, return true</li>
         * <li>if path exist, delete recursion. return true</li>
         * <ul>
         * 
         * @param path
         * @return
         */
        public static boolean deleteFile(String path) {
            if (StringUtils.isBlank(path)) {
                return true;
            }
    
            File file = new File(path);
            if (!file.exists()) {
                return true;
            }
            if (file.isFile()) {
                return file.delete();
            }
            if (!file.isDirectory()) {
                return false;
            }
            for (File f : file.listFiles()) {
                if (f.isFile()) {
                    f.delete();
                } else if (f.isDirectory()) {
                    deleteFile(f.getAbsolutePath());
                }
            }
            return file.delete();
        }
    
        /**
         * get file size
         * <ul>
         * <li>if path is null or empty, return -1</li>
         * <li>if path exist and it is a file, return file size, else return -1</li>
         * <ul>
         * 
         * @param path
         * @return returns the length of this file in bytes. returns -1 if the file does not exist.
         */
        public static long getFileSize(String path) {
            if (StringUtils.isBlank(path)) {
                return -1;
            }
    
            File file = new File(path);
            return (file.exists() && file.isFile() ? file.length() : -1);
        }
    }



    StringUtils文件



    package com.zqsy.order.tools;
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLEncoder;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * String Utils
     * 
     * @author <a href="http://www.trinea.cn" target="_blank">Trinea</a> 2011-7-22
     */
    public class StringUtils {
    
        private StringUtils() {
            throw new AssertionError();
        }
    
        /**
         * is null or its length is 0 or it is made by space
         * 
         * <pre>
         * isBlank(null) = true;
         * isBlank(&quot;&quot;) = true;
         * isBlank(&quot;  &quot;) = true;
         * isBlank(&quot;a&quot;) = false;
         * isBlank(&quot;a &quot;) = false;
         * isBlank(&quot; a&quot;) = false;
         * isBlank(&quot;a b&quot;) = false;
         * </pre>
         * 
         * @param str
         * @return if string is null or its size is 0 or it is made by space, return true, else return false.
         */
        public static boolean isBlank(String str) {
            return (str == null || str.trim().length() == 0);
        }
    
        /**
         * is null or its length is 0
         * 
         * <pre>
         * isEmpty(null) = true;
         * isEmpty(&quot;&quot;) = true;
         * isEmpty(&quot;  &quot;) = false;
         * </pre>
         * 
         * @param str
         * @return if string is null or its size is 0, return true, else return false.
         */
        public static boolean isEmpty(CharSequence str) {
            return (str == null || str.length() == 0);
        }
    
        /**
         * compare two string
         * 
         * @param actual
         * @param expected
         * @return
         * @see ObjectUtils#isEquals(Object, Object)
         */
        public static boolean isEquals(String actual, String expected) {
        	return actual == expected || (actual == null ? expected == null : actual.equals(expected));
        }
    
        /**
         * get length of CharSequence
         * 
         * <pre>
         * length(null) = 0;
         * length(\"\") = 0;
         * length(\"abc\") = 3;
         * </pre>
         * 
         * @param str
         * @return if str is null or empty, return 0, else return {@link CharSequence#length()}.
         */
        public static int length(CharSequence str) {
            return str == null ? 0 : str.length();
        }
    
        /**
         * null Object to empty string
         * 
         * <pre>
         * nullStrToEmpty(null) = &quot;&quot;;
         * nullStrToEmpty(&quot;&quot;) = &quot;&quot;;
         * nullStrToEmpty(&quot;aa&quot;) = &quot;aa&quot;;
         * </pre>
         * 
         * @param str
         * @return
         */
        public static String nullStrToEmpty(Object str) {
            return (str == null ? "" : (str instanceof String ? (String)str : str.toString()));
        }
    
        /**
         * capitalize first letter
         * 
         * <pre>
         * capitalizeFirstLetter(null)     =   null;
         * capitalizeFirstLetter("")       =   "";
         * capitalizeFirstLetter("2ab")    =   "2ab"
         * capitalizeFirstLetter("a")      =   "A"
         * capitalizeFirstLetter("ab")     =   "Ab"
         * capitalizeFirstLetter("Abc")    =   "Abc"
         * </pre>
         * 
         * @param str
         * @return
         */
        public static String capitalizeFirstLetter(String str) {
            if (isEmpty(str)) {
                return str;
            }
    
            char c = str.charAt(0);
            return (!Character.isLetter(c) || Character.isUpperCase(c)) ? str : new StringBuilder(str.length())
                    .append(Character.toUpperCase(c)).append(str.substring(1)).toString();
        }
    
        /**
         * encoded in utf-8
         * 
         * <pre>
         * utf8Encode(null)        =   null
         * utf8Encode("")          =   "";
         * utf8Encode("aa")        =   "aa";
         * utf8Encode("啊啊啊啊")   = "%E5%95%8A%E5%95%8A%E5%95%8A%E5%95%8A";
         * </pre>
         * 
         * @param str
         * @return
         * @throws UnsupportedEncodingException if an error occurs
         */
        public static String utf8Encode(String str) {
            if (!isEmpty(str) && str.getBytes().length != str.length()) {
                try {
                    return URLEncoder.encode(str, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException("UnsupportedEncodingException occurred. ", e);
                }
            }
            return str;
        }
    
        /**
         * encoded in utf-8, if exception, return defultReturn
         * 
         * @param str
         * @param defultReturn
         * @return
         */
        public static String utf8Encode(String str, String defultReturn) {
            if (!isEmpty(str) && str.getBytes().length != str.length()) {
                try {
                    return URLEncoder.encode(str, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    return defultReturn;
                }
            }
            return str;
        }
    
        /**
         * get innerHtml from href
         * 
         * <pre>
         * getHrefInnerHtml(null)                                  = ""
         * getHrefInnerHtml("")                                    = ""
         * getHrefInnerHtml("mp3")                                 = "mp3";
         * getHrefInnerHtml("&lt;a innerHtml&lt;/a&gt;")                    = "&lt;a innerHtml&lt;/a&gt;";
         * getHrefInnerHtml("&lt;a&gt;innerHtml&lt;/a&gt;")                    = "innerHtml";
         * getHrefInnerHtml("&lt;a&lt;a&gt;innerHtml&lt;/a&gt;")                    = "innerHtml";
         * getHrefInnerHtml("&lt;a href="baidu.com"&gt;innerHtml&lt;/a&gt;")               = "innerHtml";
         * getHrefInnerHtml("&lt;a href="baidu.com" title="baidu"&gt;innerHtml&lt;/a&gt;") = "innerHtml";
         * getHrefInnerHtml("   &lt;a&gt;innerHtml&lt;/a&gt;  ")                           = "innerHtml";
         * getHrefInnerHtml("&lt;a&gt;innerHtml&lt;/a&gt;&lt;/a&gt;")                      = "innerHtml";
         * getHrefInnerHtml("jack&lt;a&gt;innerHtml&lt;/a&gt;&lt;/a&gt;")                  = "innerHtml";
         * getHrefInnerHtml("&lt;a&gt;innerHtml1&lt;/a&gt;&lt;a&gt;innerHtml2&lt;/a&gt;")        = "innerHtml2";
         * </pre>
         * 
         * @param href
         * @return <ul>
         *         <li>if href is null, return ""</li>
         *         <li>if not match regx, return source</li>
         *         <li>return the last string that match regx</li>
         *         </ul>
         */
        public static String getHrefInnerHtml(String href) {
            if (isEmpty(href)) {
                return "";
            }
    
            String hrefReg = ".*<[\\s]*a[\\s]*.*>(.+?)<[\\s]*/a[\\s]*>.*";
            Pattern hrefPattern = Pattern.compile(hrefReg, Pattern.CASE_INSENSITIVE);
            Matcher hrefMatcher = hrefPattern.matcher(href);
            if (hrefMatcher.matches()) {
                return hrefMatcher.group(1);
            }
            return href;
        }
    
    /**
         * process special char in html
         * 
         * <pre>
         * htmlEscapeCharsToString(null) = null;
         * htmlEscapeCharsToString("") = "";
         * htmlEscapeCharsToString("mp3") = "mp3";
         * htmlEscapeCharsToString("mp3&lt;") = "mp3<";
         * htmlEscapeCharsToString("mp3&gt;") = "mp3\>";
         * htmlEscapeCharsToString("mp3&amp;mp4") = "mp3&mp4";
         * htmlEscapeCharsToString("mp3&quot;mp4") = "mp3\"mp4";
         * htmlEscapeCharsToString("mp3&lt;&gt;&amp;&quot;mp4") = "mp3\<\>&\"mp4";
         * </pre>
         * 
         * @param source
         * @return
         */
        public static String htmlEscapeCharsToString(String source) {
            return StringUtils.isEmpty(source) ? source : source.replaceAll("&lt;", "<").replaceAll("&gt;", ">")
                    .replaceAll("&amp;", "&").replaceAll("&quot;", "\"");
        }
    
        /**
         * transform half width char to full width char
         * 
         * <pre>
         * fullWidthToHalfWidth(null) = null;
         * fullWidthToHalfWidth("") = "";
         * fullWidthToHalfWidth(new String(new char[] {12288})) = " ";
         * fullWidthToHalfWidth("!"#$%&) = "!\"#$%&";
         * </pre>
         * 
         * @param s
         * @return
         */
        public static String fullWidthToHalfWidth(String s) {
            if (isEmpty(s)) {
                return s;
            }
    
            char[] source = s.toCharArray();
            for (int i = 0; i < source.length; i++) {
                if (source[i] == 12288) {
                    source[i] = ' ';
                    // } else if (source[i] == 12290) {
                    // source[i] = '.';
                } else if (source[i] >= 65281 && source[i] <= 65374) {
                    source[i] = (char)(source[i] - 65248);
                } else {
                    source[i] = source[i];
                }
            }
            return new String(source);
        }
    
        /**
         * transform full width char to half width char
         * 
         * <pre>
         * halfWidthToFullWidth(null) = null;
         * halfWidthToFullWidth("") = "";
         * halfWidthToFullWidth(" ") = new String(new char[] {12288});
         * halfWidthToFullWidth("!\"#$%&) = "!"#$%&";
         * </pre>
         * 
         * @param s
         * @return
         */
        public static String halfWidthToFullWidth(String s) {
            if (isEmpty(s)) {
                return s;
            }
    
            char[] source = s.toCharArray();
            for (int i = 0; i < source.length; i++) {
                if (source[i] == ' ') {
                    source[i] = (char)12288;
                    // } else if (source[i] == '.') {
                    // source[i] = (char)12290;
                } else if (source[i] >= 33 && source[i] <= 126) {
                    source[i] = (char)(source[i] + 65248);
                } else {
                    source[i] = source[i];
                }
            }
            return new String(source);
        }
    }
    展开全文
  • adb命令读取Android手机内存卡文件

    千次阅读 2019-11-28 15:17:06
    最近在跟一个厂家调试外设装备,这个机器的系统是Android的,但是他不能通过数据线连接电脑来传输手机存储中的文件,所以只能通过adb命令来取出内存卡中的文件,修改之后再用adb命令放回去。此文以mac电脑的地址为例...

    最近在跟一个厂家调试外设装备,这个机器的系统是Android的,但是他不能通过数据线连接电脑来传输手机存储中的文件,所以只能通过adb命令来取出内存卡中的文件,修改之后再用adb命令放回去。此文以mac电脑的地址为例:

    1.使用adb pull取出内存卡中的文件

    adb pull /sdcard/fsdg.db /Users/xxxx/Android

    其中/sdcard/fsdg.db为我的Android设备中需要拿出来的fsdg.db在存储卡中的位置

    /Users/xxxx/Android为我从存储卡中取出要放置在本机的位置。

    2.使用adb push向内存卡中放入文件

    adb push /Users/xxxx/Android/fsdg.db /sdcard/

    /Users/xxxx/Android/fsdg.db为我本地存储fsdg.db的位置。

    其中/sdcard/为我要放置在Android手机内置存储器中的位置

     

    展开全文
  • Android系统手机内存卡分区详解

    千次阅读 2012-08-09 14:59:35
    分区的目的简单的说,就是为了可以把软件装在内存卡。(至于把内存卡升到ext4是为了使我的国行G2更稳定和增加处理的速度, 没办法,移动的心机就是麻烦。大部分机型是不需要的,各位可以选择性的分区。)  为什么...

          分区的目的简单的说,就是为了可以把软件装在内存卡。(至于把内存卡升到ext4是为了使我的国行G2更稳定和增加处理的速度, 没办法,移动的心机就是麻烦。大部分机型是不需要的,各位可以选择性的分区。)

         为什么要对存储卡进行分区

         APP2SD的工作原理:

         以4G的TF卡做比方,将4G的卡分成3个分区,FAT32作为你正常存储音乐,图片的普通存储范围,SWAP分区是作为系统缓存,越大对系统运行缓慢的影响愈好,但一般不会超过96M,还有一个EXT3分区,这个分区的作用就是将你安装的软件安装到TF卡上,不占用手机内置内存,更好的提升系统稳定性和运行速度。

        以我的国行G2为例子,目前的Hero Rom基本都要求存储卡有三个分区才能保证Rom刷新成功并工作正常。

        这三个分区是:

       1.Fat32 主分区:普通的存储卡空间,用于文件存储等;

       2.Ext4 主分区:用于AppToSD,即将应用程序安装到存储卡而非手机存储,ROM自动完成;

       3.Linux-Swap 主分区:用于解决G2 32B系统内存不足的问题,系统自动调用此分区。

     

       有关Linux-Swap分区、SD卡、分区与SD卡损耗的一些信息

        Micro SD卡也就是熟称的“TF”卡,是Motorola与SanDisk共同推出的最新一代的记忆卡规格,它采用了最新的封装技术,并配合SanDisk最新NAND MLC技术及控制器技术。大小(11mm x 15mm x1mm),约等于半张SIM卡,Trans-Flash Card为SD Card产品成员的一员,附有SD转接器,可兼容任何SD读卡器,TF卡可经SD卡转换器后,当SD卡使用。T-Flash卡是市面上最小的闪存卡,适用于多项多媒体应用.Trans-flash产品采用SD架构设计而成,SD协会于2004年年底正式将其更名为 Micro SD,已成为SD产品中的一员。

         Micro SD的储存单元分为两类:SLC(Single Layer Cell 单层单元)和MLC(Multi-Level Cell多层单元)。SLC闪存的优点是复写次数高达100000次,比MLC闪存高10倍。此外,为了保证MLC的寿命,控制芯片都校验和智能磨损平衡技术算法,使得每个存储单元的写入次数可以平均分摊,达到100万小时故障间隔时间(MTBF)。目前的 TF 卡无写入次数平均分摊管理,导致写入次数为理论上的 1w次。那么建立 swap 分区意味着系统会对这一组单元集中作频繁写入操作,是否会导致 TF 卡的迅速损坏呢?

          可以通过修改/dev/sys/vm/swappiness的值来告诉系统你想交换的多勤快。在 Linux 里面,swappiness的值的大小对如何使用swap分区是有着很大的联系的。swappiness=0的时候表示最大限度使用物理内存,然后才是 swap空间,swappiness=100的时候表示积极的使用swap分区,并且把内存上的数据及时的搬运到swap空间里面。两个极端,对于ubuntu的默认设置,这个值等于60。所以我们可修改 swappiness 来控制系统对 swap 分区的写入频率。
          Linux 的 Swap分区的作用可简单描述为:当系统的物理内存不够用的时候,就需要将物理内存中的一部分空间释放出来,以供当前运行的程序使用。那些被释放的空间可能来自一些很长时间没有什么操作的程序,这些被释放的空间被临时保存到Swap空间中,等到那些程序要运行时,再从Swap中恢复保存的数据到内存中。这样,系统总是在物理内存不够时,才进行Swap交换。

         关键词就是虚拟内存。目前 G2的系统内存明显不够使用,所以建立了 Swap 分区后,可以有效的缓解这个问题。具体在 hero 上表现为”正在加载/Loading”现象少了。

        存储卡分区的次序与分区大小

         存储卡按照次序的三个分区:FAT32 主分区;EXT4 主分区;LINUX-SWAP 主分区。

         举例的分区大小:LINUX-SWAP:96M;EXT4:500M;FAT32:剩下所有存储卡内空间。

         一定要注意,先分区FAT32,再分区EXT3,最后分区LINUX-SWAP。问题出现:怎样最先确定FAT32分区的大小?很简单,从系统里看看你SDCARD的空间,减去500M EXT3空间,再减去96M LINUX-SWAP的大小就好。例如8G卡实际容量若为7.59G,那么FAT32分区大小为7590-500-96=6994M分区大小即可。

    还有一个细节,使用分区软件进行分区操作的时候,分区大小可能不会正好是上述数值,多多少少几M,或者出现小数都是没关系的。

    具体的分区方法

    上面说了那么多的内存卡的相关知识,可能不少机油都不耐烦了,那么下面我们就说说具体的内存卡分区操作。

    要分区那就需要先进入Recovery界面,操作是如下:

    方法1:在关机情况下同时按住HOME键和电源键。

    方法2:在开机的情况下长按电源键,选择重启,在选择栏中选择刷机模式。(这里插一句,进入刷机界面之前最好先把USB线连接电脑,为什么要连接在后面会做说明)

    下面是进入Recovery界面后的截图

    下面我们通过操作轨迹球选择Partition sdcard 这个选项,按下轨迹球确认

    然后进入下面的画面

    选择第一个Partition SD

    接着会出现提示,问你是否要划分TF卡

    按HOME也就是小房子键继续

    这个时候应该出现的是Swap=32MB,按HOME确定。如果你需要升到ext4的话,可以通过音量键来调整大小,调整到需要的大小,如果不调整的话可能升到ext4的时候,重启会在通知栏出现-53,-70等数字,这个都是因为没有调整造成的。好了,调整好这个,会出现这个界面。

    提示问你划分多大的空间作为第二分区,推荐不要超过800M,选好后按HOME键确定,也可以按音量键进行大小的调节。确定后出现下面的界面。

    现在你可以按HOME继续,(这个过程中你如果想再调整Swap,可以按除去HOME键以外的键来进行退出操作,然后按HOME键回到图6的界面再进行修改。)按下HOME确定后,会开始格式化TF卡,格完后会返回到图4。

    如果需要把ext2升级到ext4的话,在Partition sdcard里面,先选择SD:ext2 to ext3,点击HOME,等界面回到图片7后再选择SD:ext3 to ext4。(如果不想要升到ext4,直接全部按HOME就可以了) 。

    HOME?是哪个按键?HOME就是家嘛,家就是房子嘛,看键盘上那个小房子图标的按键,就是它了。

    返回RECOVERY系统主菜单,选择WIPE

    再选择第一项,然后同之前一样,一路HOME到底。

    P.S :上面的操作可以不做,不过有可能会发生一些问题,导致启动不能。

    完成上面的操作就按返回键回到Recovery界面。

    点击USB-MS toggle,TF卡就会被电脑识别成可移动磁盘,这里要注意2点:

    第一点要注意的事:手机在点击了USB-MS toggle后,暂时不要进行任何操作,等待电脑读取到内存卡。

    第二点是要注意到地方是:刚开始USB连接电脑是没有读取到内存卡的,但是选择了这个选项后,电脑会读取到内存卡,在读取过程中需要等待30秒左右,这个过程中可以刷新一下“我的电脑”,一定要电脑读取到内存卡后,再进行下一步操作。这也是为什么开始的时候建议把USB连接到电脑中,这样也可以避免因电池电量不足造成分区失败。

    电脑识别到内存卡后,将下载好的rom(比如axing_3.121.zip)拷贝到TF里,拷完后按home键返回主菜单。

    点击Flash zip from sdcard

    找到刚才拷贝的rom名字(比如axing_3.121.zip),按下轨迹球确认,之后再按home键开始刷新, 等界面回到Recovery界面后。点击Reboot system now。

    重启手机,进入系统

    等开机后,安装软件试试,是不是可以选择装在内存卡啦?连接电脑后你会发现自己的卡少了500左右的内存,那么恭喜你,你分区成功了哦。(PS:分区后内存卡的东西会消失,注意备份。这里建议把UC浏览器,QQ等一些常用的软件安装在内置储存,不然你的内存卡取出后再装上去需要读取时间,会造成一些不便。)

    好的,这个分区教程大概说到这,以上方法亲测成功。其他机型分区有不一样的地方,或者我说的不正确的地方我会不断修正的,希望这个教程可以帮助到大家。

     

    转载请注明:文章转载自 dospy智能手机网

    展开全文
  • 联想手机内存卡照片数据删除怎么免费恢复 李浩的内存卡损坏里面的数据也提取不出来,这边着急上火的要恢复内存卡的数据,那边有着急着去约会。李浩三十出头还没恋爱,他的母亲很为他着急,逼着他去相亲。李浩拗...
  • 1. 保存数据到手机内存因为直接保存到手机内存的app所在包下,所以不需要权限 主要的思路: 1、把EditText的内容取出来 2、把内容放在内存中,文件路径file为(app的包下,两种都可以,第一种是写死了,包名一改...
  • 中兴V880变砖?不用怕,现在小编就来教大家中兴V880变砖后怎么样来修复,主要通过中兴V880内存卡文件修复。... 3、把内存卡取出,插到手机上。(官方文档提示应将中兴V880内存卡文件夹downl...
  • 电脑(手机)无法读取内存卡(存储卡)的解决方法大全,步骤/方法:1、手机卡坏掉或者接触不良造成手机内存卡读不出来。解决办法:如果是接触不良这是很好解决的问题,将卡取出,用橡皮擦擦内存卡的金手指,去掉上面的...
  • 网上查了下android手机扫描内存或者SD里面的音频或者视频文件,进行显示。... 所以可以自行添加一个扫描手机内存的方法,在扫描完之后,再使用传统的视频、音频文件获取方式获取来获取。 以下两个方法是用来启动
  • 一,保存文件到手机内存和SD 这里引用一个案例
  • 树莓派踩坑 最近入门树莓派,在刷了win10IOT系统后再刷回RAPBIAN时出错,猜想可能是win10刷回linux那样的分区...最后,想到一个办法,把内存卡装到手机(HUAWEI)上,手机识别到内存卡有问题,重新格式化,再回到pc...
  • (我当初操作是把一个内存卡的引导信息,复制写入我的金士顿u盘里面,保存之后,u盘的大小出现了,可用空间也出来了,打开里面的文件也在,但是打开某些文件的时候会出错,所以要找到匹配的引导文件,后来探索到更好...
  • 原标题:专业解读:为什么安卓手机内存越来越大?首先,本文所说的内存即我们通常意义上所称的运行内存RAM,而非储存内存ROM。简单点来说,就是我们平常见到的6G+64G、8G+128G中前面的6G/8G。明白这一点,我们再看...
  • 手机内存RAM、ROM简介

    千次阅读 2018-01-07 18:30:11
    手机内存RAM、ROM简介
  • 为了实现一个功能,需要搜集手机信息,自己先在网上找了相关信息进行了汇总,主要是汇集手机的信息,一般想要的信息在手机设置->关于手机->状态消息里面包含了手机的各种信息,下面的代码中也主要显示了那些信息,...
  • 我们这里所说的相机,准确来说应该称之为数据存储。不过依然有不少的人会将之称呼为相机,可能是因为这些存储大多数都用于数码相机的图片存储上。实际上在某些数码相机上通常都会默认内置1-2G的空间用于存储...
  • 相信许多新手机友都有感慨过手机内存太小,软件总是装的不够,于是就会上网寻找解决得办法,接着就会看到一些平常不熟悉的术语如a2sd,EXT2/3等,本教程则较为详细地展示如何进行EXT2分区的过程,需要的机友可以参考...
  • 支持手机、SD检测速度,写入读取应用打开速度有影响顺序读和顺序写测试在RAM和存储之间传输大量数据(兆字节)。这些测试代表磁盘操作,例如大文件复制,视频记录/编码/解码等。写缓冲-影响写测试。写入操作使用中间...
  • android手机给应用分配的内存通常是8兆左右,如果处理内存处理不当很容易造成OutOfMemoryError,我们的产品出现最多的错误也是OutOfMemoryError的异常,  在解决这个异常时在网上发现很多关于...
  • 为了实现一个功能,需要搜集手机信息,自己先在网上找了相关信息进行了汇总,主要是汇集手机的信息,一般想要的信息在手机设置->关于手机->状态消息里面包含了手机的各种信息,下面的代码中也主要显示了那些信息,...
  • 有些图片的分辨率比较高,把它直接加载到手机内存中之后,会导致堆内存溢出的问题,下面就讲解一下Android的堆内存以及如何在Android应用中加载一个高分辨率的图片的方法 还原堆内存溢出的错误 首先来还原一下堆...
  • 因为周末出去玩了一趟,所拍的照片都是用手机完成的,好在我的手机内存还是蛮大的,加上平时不怎么玩游戏什么的,所以剩下的内存挺多,但是玩了一趟回来之后,我的内存就满了,全是周末拍的照片,这都归功于同去的女...
  • android.os下的StatFs类主要用来获取文件系统的状态,能够获取sd的大小和剩余空间,例如通过实例化一个StatFs对象 new StatFs(path.getPath())把SD卡根目录路径传进去可以获取SD卡根目录下的内存存储状态。
  • 内存

    2020-04-11 20:54:50
     内存(Memory)指的是内存存储器,又称为主存,是CPU用来直接寻址和存储的空间,它相当于一座桥梁,用以负责诸如硬盘、主板、显卡等硬件上的数据与处理器之间数据交换处理,我们可以把内存看作数据缓存区,一个...
  • 新旧SD卡换装方法探讨:本文引用地址:http://www.eepw.com.cn/article/201610/305616.htm许多用户在Android手机买来使用一段时间后,往往发现无论是手机的外部存储...这时自然会想到替换一个容量大的内存卡(miniS...
  • 试过软格机,没用,硬格机搞定。...一直到你手机出现“选择时区”为止 硬格机前注意把内存卡拔下来关机,开机时候按住通话键+3号键+*号键+然后按开机。不要松手,然后出现一行英文,就开始格式化了。一块按,一个
  • 关于安卓手机图库提示“sd卡已卸载或不存在",...2.手机内存卡质量不怎么样,或者说兼容性不怎好,那换个卡试试。 3.操作系统出问题了,可能需要重新刷机。 4.取出内存卡,1分钟后---安好--开机。 5.用SDIncrease对

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,343
精华内容 6,537
关键字:

如何取出手机的内存卡