精华内容
下载资源
问答
  • android开发关于和使用本机内存,内置存储卡和外置存储卡 -----------------------------------------------------------------------------------------------------------------------------------------------...


    android开发关于和使用本机内存,内置存储卡和外置存储卡


    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    关于android存储器简介:


                     android开发常常需要涉及数据缓存,这就需要我们了解手机当前使用的内存状况,是否存在外置存储卡,如果有怎么办,没有是否使用内置存储卡。



    首先手机本机存储器,有Rom,Ram。


       Rom  :在android中Rom相当于系统盘,当C盘用 ,很多时候要使用需要获取root权限。

                  一般可以分为机身内存和内置存储(三星的多是叫:USB存储器);

                 机身内存包括system、data和cache等分区目录,软件默认都是安装机身内存或者内置存储卡里的 。

                data(就是手机储存总量)+system(手机系统占用)

               

                    具体看是什么手机;


       Ram:在相当于电脑的运行内存,运存  。不多做解释,就是随机运行时内存,断电数据全部消失。


            外置存储器有:手机存储器 (TF卡), 相当于D,E ,F 等硬盘。



    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------




    android开发中读取手机存储器和外置存储器。



    Android读取手机内存之机身内存

    这个我反复试验过,可以弄入以及读取数据到data目录下,但是需要获取root权限(这里是指使用的目录地址非当前应用在data中的目录地址),这个真有点纠结,难道要使用**软件的人都去root下?嘿嘿,所以这里不推荐,这里就不粘贴代码了 ,要使用手机内存只能使用当前应用对应在data目录的地址了。下面是一个下载图片到手机内存的方法:(当前应用在data下对应的目录)


        

     // 网络图片先下载到本地cache目录保存,以imagUrl的图片文件名保存。如果有同名文件在cache目录就从本地加载
    		public static Drawable loadImageFromUrl(Context context, String imageUrl) {
    			Drawable drawable = null;  
    	        if(imageUrl == null )  
    	            return null;  
    	        String imagePath = "";  
    	        String   fileName   = "";  
    	              
    	        // 获取url中图片的文件名与后缀  
    	        if(imageUrl!=null&&imageUrl.length()!=0){   
    	            fileName  = imageUrl.substring(imageUrl.lastIndexOf("/")+1);  
    	        }  
    	          
    	        // 图片在手机本地的存放路径,注意:fileName为空的情况  
    	        imagePath = context.getCacheDir() + "/" + fileName;  
    	        Log.i(TAG,"context.getCacheDi = " + context.getCacheDir());  
    	        Log.i(TAG,"imagePath = " + imagePath);  
    	        File file = new File(imagePath);// 保存文件       同:    File file = new File(context.getCacheDir(),fileName);  
    	        Log.i(TAG,"file.toString()=" + file.toString());  
    	        if(!file.exists()&&!file.isDirectory())  
    	        {  
    	            try {  
    	                // 可以在这里通过文件名来判断,是否本地有此图片  
    	                  
    	                FileOutputStream   fos=new   FileOutputStream( file );  
    	                InputStream is = new URL(imageUrl).openStream();  
    	                int   data = is.read();   
    	                while(data!=-1){   
    	                        fos.write(data);   
    	                        data=is.read();;   
    	                }   
    	                fos.close();  
    	                is.close();  
    //	              drawable = Drawable.createFromStream(  
    //	                      new URL(imageUrl).openStream(), file.toString() ); // (InputStream) new URL(imageUrl).getContent();  
    	                drawable = Drawable.createFromPath(file.toString());  
    //	                Log.i(TAG, "file.exists()不文件存在,网上下载:" + drawable.toString());  
    	            } catch (IOException e) {  
    	                Log.e(TAG, e.toString() + "图片下载及保存时出现异常!");  
    	            }  
    	        }else  
    	        {  
    	        	try {
    					FileInputStream filein=new FileInputStream(file);
    					drawable=Drawable.createFromStream(filein, "src");
    				} catch (FileNotFoundException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
                     //上面的方法同下;
                    //drawable = Drawable.createFromPath(file.toString());  
    //	            Log.i("test", "file.exists()文件存在,本地获取");  
    	        } 
    	        return drawable ;
    		}





    Android读取手机内存内置存储器实例


    下面给出一个小例子来说明如何Android读取手机内存里的文件,这在Android开发中是比较重要的一部分,如何要是掌握不好的话,我们就没法把数据库里保存的数据给读出来,也就是说我们我们每一次玩游戏的时候,我们的数据库都是最原始的数据,这样就会给我们带来很多的麻烦。如果出现这样的事情,那么你的应用就是非常烂的,代码如下:


        
        public static InputStream readInternalFileInputStream(Context context,String fileName){    
          
          
          
        /**   
        * 读取手机内存文件   
        *   
        */    
          
        try{    
        FileInputStream fis = context.openFileInput(fileName);    
          
        return fis;    
        }catch(Exception e){    
        return null;    
        }    
          
        }    
        public static String readInternalFile(Context context,String fileName){    
          
          
        /**   
        * 读取手机内存文件   
        *   
        */    
          
        try{    
        byte[] buffer = new byte[512];    
        int read =0;    
        StringBuffer stringbuffer = new StringBuffer();    
        FileInputStream fis = context.openFileInput(fileName);    
          
          
        do{    
        read = fis.read(buffer);    
        if(read>0)    
        stringbuffer.append(new String(buffer, 0, read, "utf-8"));    
          
        }while(read!=-1);    
          
          
        fis.close();    
        return stringbuffer.toString();    
          
          
        }catch(Exception e){    
        return null;    
        }    
          
        }   
    
    



    外置内存

    android 读取sd卡中的图片


    一 读取sd卡中的图片
         1 获取读取sd的权限
            在AndroidMainfest.xml文件中添加

      

             <!-- 在SDCard中创建与删除文件权限 -->
     <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" ></uses-permission>
     <!-- 往SDCard写入数据权限 -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" ></uses-permission>
     <uses-permission android:name="android.permission.RESTART_PACKAGES" ></uses-permission>




        注意:在<application...></application>前添加
        2 找到sd卡的目录(以真机的情况说明)
     
     /**
          *图片文件路径
     *打印Environment.getExternalStorageDirectory()得到:"/mnt/sdcard",即找到了sd卡的根目录
          */
     public String filePath=Environment.getExternalStorageDirectory()+"/client/tile/1_0_0.jpg";


       3 根据路径获取图片    
         File mfile=new File(path);
         if (mfile.exists()) {//若该文件存在
         Bitmap bm = BitmapFactory.decodeFile(path);
         return bm;
         }
    
    

    二 注意事项
        在读取sd卡中图片的过程中的一些可用判断
         1 Environment.getExternalStorageState()获取路径是否成功
           /*如获取成功,返回值为MEDIA_MOUNTED*/


       if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))
        {
    
             String filePath=Environment.getExternalStorageDirectory().getPath();
        }




       2 获取sd卡的权限成功
         /*fileName=Environment.getExternalStorageDirectory()+"/client" 是个文件夹目录*/

         File f = new File(fileName);
         //可读
         if(f.canRead())
         Log.v("EagleTag","very bad");
         //可写
         if(f.canWrite())
              Log.v("EagleTag","very good");
    
    



    --------------------------------------------------------------------------------------------------------------





    android的data和system以及cache系统目录讲解

     
     
     
    /system 存放的是rom的信息;
     
    /system/app 存放rom本身附带的软件即系统软件;
     
    /system/data 存放/system/app 中核心系统软件的数据文件信息。
     
     /data 存放的是用户的软件信息(非自带rom安装的软件);
     
    /data/app 存放用户安装的软件;
     
    /data/data 存放所有软件(包括/system/app 和 /data/app 和 /mnt/asec中装的软件)的一些lib和xml文件等数据信息;
     
    /data/dalvik-cache 存放程序的缓存文件,这里的文件都是可以删除的。
     


     
    /sdcard和/mnt/sdcard一样吗?/mnt/asce是干嘛用的?
     
    我来谈谈/mnt/asce目录
    1、android升级到2.2以上,出现了这个目录,这个目录是干什么的呢?
    2、2.2以上,出现了新的功能,应用可以安装的sd卡上,哪到底安装在哪儿呢?我找遍了整个卡结果发现了所有这些应用安装在.android 的asecure目录下,要把卡放到读卡器上去看才知道。
    3、那是如何与系统发生关系的,学过unix的人都知道,mnt是在/下的一个目录,sd卡是通过mount挂接上去的,/mnt叫挂接点,系统就能通过挂接点/mnt访问sd卡了
    4、在/mnt下有三个目录如下:asec、secure、sdcard 其中asec就是我们安装在卡上的应用、secure是用于sd卡应用程序安装路径加密的吧自己猜想的、sdcard就是卡上的其他内容。
     
     
    /mnt/asce实际上对应的真正物理目录是/mnt/sdcard/.android_secure(记住android_secure前有个点,这是个隐藏目录)
     
     
    我们回过来看/sdcard和/mnt/sdcard就容易理解:
     
    /sdcard 目录,这是一个软链接(相当于windows的文件夹的快捷方式),链接到/mnt/sdcard 目录,即这个目录的内容就是sdcard的内容。
     
     
       因此,用户程序安装到到sd卡上后,其内容可能分散到:/mnt/asec , /mnt/secure , /data/data 。
     
        要实现app2sd,目前比较流行有两种方案,分别是app2ext 和 data2ext,下面分别介绍下这2种方案。
     
        app2ext的原理是,删除data区中的app文件夹,然后在sd卡的ext分区上创建一个app文件,并通过软链接映射到data区。这样系统会以为,app这个软链接是一个真实的文件夹,会把程序都安装在里面,但实际上,这些程序都安装到卡上了。但由于操作系统并不知道,所以这种情况下,我们依然看到系统显示这个程序是安装在“内置空间”的。
        data2ext则更彻底,它不是用软链接,而是直接用“挂载”功能,Linux下所有的存储设备都必须挂载成一个文件夹才能进行文件操作(如sd卡就挂载在/mnt/sdcard目录下面)。data文件夹本来是对应手机内部Flash中的一个分区(为了保持术语的准确,这里要把内部Flash和内存相区别,内部Flash是ROM,内存是RAM)。而data2ext则是修改了挂载对应关系,使data文件夹挂载的不是内置Flash,而是sd卡的整个ext分区。这样,不仅是app,连存储程序设置的data和缓存dalvik-cache都会存储到sd卡中。
     
        可以看到,dalvik-cache和data这两个文件夹的位置,是这两种方式的一个重大区别。其中dalvik-cache是虚拟机预编译缓存,data(不同于/data,这个是/data/data)是存储程序数据的地方,例如游戏的存档记录,软件的配置信息等。这样有什么区别,区别在于假如你重刷了ROM,app2ext的话,所有的程序都可以保留,但是这些程序的配置信息和游戏的存档都会丢失。而data2ext则可以连同配置和存档都保留,但是dalvik-cache也是一个容易积累垃圾的地方,这些垃圾也会一同保留。
     
     
        data2ext由于是把整个data分区都放在sd卡上,因此,我们刷ROM需要WIPE的时候,这个data分区的内容就可能不会被wipe,这可以保存用户的个人资料,但是也可能造成系统莫名其妙的故障。
     
     

    原文:http://www.2cto.com/kf/201212/178288.html


    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    Android 4.0中关于内外置存储卡读写权限问题

    在2.x的版本中,在manifest中配置的权限android.permission.WRITE_EXTERNAL_STORAGE确实是用来使得sd卡获得写的权限。而在4.0开发的源码当中,由于有了内外置sd卡的区,android.permission.WRITE_EXTERNAL_STORAGE的权限用来设置了内置sd卡的写权限,如果在manifest中只是配置了这个权限,那个应用只能在内置sd卡中进行写操作,还是无法在外置sd卡中进行写操作。

    需要写外置sd卡的话,需要配置另一个权限android.permission.WRITE_MEDIA_STORAGE,这样就可以在外置sd卡中进行写入操作了。

    这两个权限都被定义在android源码目录\frameworks\base\data\etc\platform.xml中:

     


    使用到的类主要是framework/base/core/java/android/os/storage/StorageVolume.java及相同目录下的StorageManager.java文件。

    StorageManager类可以获得所有的存储媒体列表,及StorageVolume类型的数组,从而可以获得对应存储是否可读写一类的信息。

    问题在于 android 4.0的 SDK包中没有增加这个接口
    解决的办法 一种是依赖 厂家将这2个权限默认为一个 也就是外部存储SD卡的android.permission.WRITE_EXTERNAL_STORAGE 和android.permission.WRITE_MEDIA_STORAGE等同 —— 这个是目前比较好的做法

    第二种是: reflection 这个我具体没有弄过 待验证

    第三种是 将你的源代码在 android的source code下编译 ; 或者得到厂家定制的android.jar包。


    以上部分可参照原文,地址http://blog.sina.com.cn/s/blog_5da93c8f0101fgy9.html



    希望可以帮助遇到相同问题的童鞋。

    转载请注明出处:http://blog.csdn.net/fth826595345/article/details/8823392#t8

      

    待续.......

    展开全文
  • Android获取所有存储卡挂载路径

    千次阅读 2015-07-02 18:01:41
    最近因项目需求,需要在存储卡查找文件,经测试发现部分手机挂载路径查找不到,这里分享一个有效的方法。 /** * 获取所有存储卡挂载路径 * @return */ public static List getMountPathList() { List ...

    最近因项目需求,需要在存储卡查找文件,经测试发现部分手机挂载路径查找不到,这里分享一个有效的方法。

    	/**
    	 * 获取所有存储卡挂载路径
    	 * @return
    	 */
        public static List<String> getMountPathList() {  
            List<String> pathList = new ArrayList<String>();  
            final String cmd = "cat /proc/mounts";  
            Runtime run = Runtime.getRuntime();//取得当前JVM的运行时环境 
            try {  
                Process p = run.exec(cmd);//执行命令  
                BufferedInputStream inputStream = new BufferedInputStream(p.getInputStream());  
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));  
      
                String line;  
                while ((line = bufferedReader.readLine()) != null) {  
                    // 获得命令执行后在控制台的输出信息  
                    Logger.i(line);  
                    //输出信息内容:  /data/media /storage/emulated/0 sdcardfs rw,nosuid,nodev,relatime,uid=1023,gid=1023 0 0
                    String[] temp = TextUtils.split(line, " ");  
                    //分析内容可看出第二个空格后面是路径  
                    String result = temp[1];  
                    File file = new File(result);  
                    //类型为目录、可读、可写,就算是一条挂载路径
                    if (file.isDirectory() && file.canRead() && file.canWrite()) {  
                    	Logger.d("add --> "+file.getAbsolutePath());  
                        pathList.add(result);  
                    }  
      
                    // 检查命令是否执行失败
                    if (p.waitFor() != 0 && p.exitValue() == 1) {  
                        // p.exitValue()==0表示正常结束,1:非正常结束  
                    	Logger.e("命令执行失败!");  
                    }  
                }  
                bufferedReader.close();  
                inputStream.close();  
            } catch (Exception e) {  
            	Logger.e(e.toString());  
            	//命令执行异常,就添加默认的路径
                pathList.add(Environment.getExternalStorageDirectory().getAbsolutePath());  
            }
            return pathList;  
        } 

    展开全文
  • 我最近项目里有个 往外置存贮卡里写入的... 4.0以后才把内置外置存储卡分开了。4.0以下编译会不会可以适配到6.0? 有什么代码能打开系统自带的文件管理器,不要返回路径?没权限的话,我想让用户自己复制文件到U盘
  • SpringBoot项目启动的时候Console控制台日志打印住,无任何异常信息打印 问题描述: 之前项目是好的,但是后面经人写了一部分代码之后,项目启动不了,SpringBoot项目启动时直接住,日志也不打印,也没有具体...

    项目场景:

    SpringBoot项目启动的时候Console控制台日志打印卡住,无任何异常信息打印


    问题描述:

    之前项目是好的,但是后面经人写了一部分代码之后,项目启动不了,SpringBoot项目启动时直接卡住,日志也不打印,也没有具体的异常信息,某位同事折腾一天。

     


    原因分析:

    之前我遇到过类似的问题。现在我把我所有的问题分析列在下面:

    1. 有可能是改动了pom.xml文件,项目没有彻底更新,导致引入的jar存在版本问题或者根本没有引入进来 
    2. 项目是Debug模式启动,然后有一些特殊的断点导致项目启动卡住
    3. 项目的目录结构变更,导致某些bean没有被加载到?或者加载了多个相同的bean
    4. 某些异常没有被捕获到,同时启动类里面也没有加上全局的try-catch,导致项目卡住
    5. 部分代码需要随程序自启,使用@PostConstruct、InitializingBean、ApplicationRunner等方式实现项目初始化时加载,如果有远程连接,而且连接失败或者异常了,没有try-catch,也容易导致启动程序卡死。

    解决方案:

    针对上述列出来的分析,我们可以采用以下解决方案,一步步尝试

    1. 如果是pom.xml变更了没生效,我们只需要对pom.xml 重新import即可,另外可以考虑清除idea缓存
    2. 如果是debug模式的断点引起的话,去掉所有断点再试试
    3. 如果是项目目录结构变更,这个maven clean一下,重新install 即可
    4. 如果可以变更启动类的话,建议在开发阶段对启动类的main方法里面的代码加上try-catch,这样启动项目的时候就知道具体异常是什么
    5. 如果说分析哪些程序自启的代码导致项目启动卡住的话,我建议查看项目启动快照,具体如下:

    分析当前主线程到底因为什么卡住(waiting),比如我这里是因为数据源配置的有问题导致卡住

    最终解决方案:6、如果上述方案都无法解决问题,那么可以查看项目启动日志文件,一般和项目同级目录或者有个log目录存储,里面会记录所有信息/异常信息

    例如:这里是我同事的异常:

    异常分析:是因为他从另外一个项目copy过来的mapper.xml文件,之前用的是mybatis,现在项目用的ibatis,不识别<where>标签,ibatis只支持<dynamic prepend="where"> 来用

    改成ibatis识别的方式即可。  这里注重给大家讲怎么去找到并分析异常。

    总结:

    项目启动卡住了,肯定是有异常原因存在,我们需要的是沉着冷静,一步步找问题所在。另外就是大家在CV代码时,尤其是两个不同的项目的时候,一定要注意细节啊!

     

     

     

     

    展开全文
  • 本周的学习内容是Android存储,要求:数据库Sqlite相关操作,常用的文件存取方式,以及实用场景学习,主要学习Sqlite,SD文件操作,SharedPreference 二丶效果演示:     三丶功能介绍及主要内容 1.图一完成...

    本文出自:http://blog.csdn.net/dt235201314/article/details/73176149

    源码下载欢迎Star(updating):https://github.com/JinBoy23520/CoderToDeveloperByTCLer

    一丶慨述

    本周的学习内容是Android存储,要求:数据库Sqlite相关操作,常用的文件存取方式,以及实用场景学习,主要学习Sqlite,SD卡文件操作,SharedPreference

    二丶效果演示:

          

         

    三丶功能介绍及主要内容

    1.图一完成创建文件存储在手机内存中并读取删除,文件操作相关知识;

    2.图二完成创建文件存储在手机SD卡中并读取删除,文件操作相关知识;

    3.图三完成Sharedpreference存储用户偏好数据,读取删除数据等操作。可通过不同APP读取,暂不讲加密

    4.图四完成SQLite完成玩家信息增删改查 

    参考博客:

    玩家信息管理(SQLite+Fragment加强)

    以及大神“小猪”博客:http://blog.csdn.net/coder_pig


    四丶代码讲解

    1.文件存储

    主要方法:


    Demo1:

    FileHelper.Java

    /**
     * <pre>
     *     author : JinBiao
     *     CSDN : http://my.csdn.net/DT235201314
     *     time   : 2017/06/11
     *     desc   : 文件协助类
     *              1.文件操作模式:
     *              1.Context.MODE_PRIVATE:私有操作模式,默认模式,代表该文件是私有数据,只能被应用本身访问,
     *              在该模式下,写入的内容会覆盖源文件的内容,如果想把新写入的内容追加到原文件中,可以使用Context.MODE_APPEND
                    2.Context.MODE_APPEND:追加操作模式:模式会检查文件是否存在,存在就往文件追加内容,否则就创建新文件
                    3.Context.MODE_WORLD_READABLE:表示当前文件可以被其他应用读取。
                    4.Context.MODE_WORLD_WRITEABLE:表示当前文件可以被其他应用写入。
                    如果希望文件被其他应用读和写,可以传入:
                    openFileOutput("1234.txt", Context.MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE);
                    另外,文件默认放在/data/data//files目录下
                    对于文件的获取,Android中提供了getCacheDir()和getFilesDir()方法:
                    getCacheDir()方法用于获取/data/data//cache目录
                    getFilesDir()方法用于获取/data/data//files目录
     *     version: 1.0
     * </pre>
     */
    
    public class FileHelper {
    
        private Context mContext;
        
        public FileHelper() {
        }
    
        public FileHelper(Context mContext) {
            super();
            this.mContext = mContext;
        }
    
        /**
         * 这里定义的是一个文件保存的方法,写入到文件中,所以是输出流
         **/
        public void save(String filename, String filecontent) throws Exception {
            //这里我们使用私有模式,创建出来的文件只能被本应用访问,还会覆盖原文件哦
            FileOutputStream output = mContext.openFileOutput(filename, Context.MODE_PRIVATE);
            output.write(filecontent.getBytes());  //将String字符串以字节流的形式写入到输出流中
            output.close();         //关闭输出流
        }
    
    
        /**
         * 这里定义的是文件读取的方法
         */
        public String read(String filename) throws IOException {
            //打开文件输入流
            FileInputStream input = mContext.openFileInput(filename);
            byte[] temp = new byte[1024];
            StringBuilder sb = new StringBuilder("");
            int len = 0;
            //读取文件内容:
            while ((len = input.read(temp)) > 0) {
                sb.append(new String(temp, 0, len));
            }
            //关闭输入流
            input.close();
            return sb.toString();
        }
    }
    点击事件操作

       @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btnclean:
    //                deleteFile(editname.getText().toString());
                    editdetail.setText("");
                    editname.setText("");
                    break;
                case R.id.btnsave:
                    FileHelper fHelper = new FileHelper(mContext);
                    String filename = editname.getText().toString();
                    String filedetail = editdetail.getText().toString();
                    try {
                        fHelper.save(filename, filedetail);
                        Toast.makeText(getApplicationContext(), "数据写入成功", Toast.LENGTH_SHORT).show();
                    } catch (Exception e) {
                        e.printStackTrace();
                        Toast.makeText(getApplicationContext(), "数据写入失败", Toast.LENGTH_SHORT).show();
                    }
                    break;
                case R.id.btnread:
                    String detail = "";
                    FileHelper fHelper2 = new FileHelper(getApplicationContext());
                    try {
                        String fname = editname.getText().toString();
                        detail = fHelper2.read(fname);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    Toast.makeText(getApplicationContext(), detail, Toast.LENGTH_SHORT).show();
                    break;
            }
        }

    Demo2



    读取流程图

    SDFileHelper.Java

    /**
     * <pre>
     *     author : JinBiao
     *     CSDN : http://my.csdn.net/DT235201314
     *     time   : 2017/06/12
     *     desc   : SD卡文件操作协助类
     *     version: 1.0
     * </pre>
     */
    
    public class SDFileHelper {
        private Context context;
    
        public SDFileHelper() {
        }
    
        public SDFileHelper(Context context) {
            super();
            this.context = context;
        }
    
        /**
         * 往SD卡写入文件的方法
         * @param filename
         * @param filecontent
         * @throws Exception
         */
        public void savaFileToSD(String filename, String filecontent) throws Exception {
            //如果手机已插入sd卡,且app具有读写sd卡的权限
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                filename = Environment.getExternalStorageDirectory().getCanonicalPath() + "/" + filename;
                //这里就不要用openFileOutput了,那个是往手机内存中写数据的
                FileOutputStream output = new FileOutputStream(filename);
                output.write(filecontent.getBytes());
                //将String字符串以字节流的形式写入到输出流中
                output.close();
                //关闭输出流
            } else Toast.makeText(context, "SD卡不存在或者不可读写", Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 读取SD卡中文件的方法
         * @param filename
         * @return
         * @throws IOException
         */
        public String readFromSD(String filename) throws IOException {
            StringBuilder sb = new StringBuilder("");
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                filename = Environment.getExternalStorageDirectory().getCanonicalPath() + "/" + filename;
                //打开文件输入流
                FileInputStream input = new FileInputStream(filename);
                byte[] temp = new byte[1024];
                int len = 0;
                //读取文件内容:
                while ((len = input.read(temp)) > 0) {
                    sb.append(new String(temp, 0, len));
                }
                //关闭输入流
                input.close();
            }
            return sb.toString();
        }
    点击事件操作:

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btnclean:
                editdetail.setText("");
                editname.setText("");
                break;
            case R.id.btnsave:
                String filename = editname.getText().toString();
                String filedetail = editdetail.getText().toString();
                SDFileHelper sdHelper = new SDFileHelper(mContext);
                try {
                    sdHelper.savaFileToSD(filename, filedetail);
                    Toast.makeText(getApplicationContext(), "数据写入成功", Toast.LENGTH_SHORT).show();
                } catch (Exception e) {
                    e.printStackTrace();
                    Toast.makeText(getApplicationContext(), "数据写入失败", Toast.LENGTH_SHORT).show();
                }
                break;
            case R.id.btnread:
                String detail = "";
                SDFileHelper sdHelper2 = new SDFileHelper(mContext);
                try {
                    String filename2 = editname.getText().toString();
                    detail = sdHelper2.readFromSD(filename2);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                Toast.makeText(getApplicationContext(), detail, Toast.LENGTH_SHORT).show();
                break;
        }
    }

    读写权限:

    <!-- 在SDCard中创建与删除文件权限 -->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
    <!-- 往SDCard写入数据权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    Demo3


    SharePreference

    使用流程图

    SharedPreference是以xml map键值对形式保存文件

    SharedHelper.java

    /**
     * <pre>
     *     author : JinBiao
     *     CSDN : http://my.csdn.net/DT235201314
     *     time   : 2017/06/12
     *     desc   : SharedPreferences数据存储协助类
     *              map键值对形式保存文件
     *     version: 1.0
     * </pre>
     */
    
    public class SharedHelper {
        private Context mContext;
    
        public SharedHelper() {
        }
    
        public SharedHelper(Context mContext) {
            this.mContext = mContext;
        }
    
        /**
         * 定义一个保存数据的方法
         * @param username
         * @param passwd
         */
        public void save(String username, String passwd) {
            SharedPreferences sp = mContext.getSharedPreferences("my_sp", Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            editor.putString("username", username);
            editor.putString("passwd", passwd);
            editor.commit();
            Toast.makeText(mContext, "信息已写入SharedPreference中", Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 定义一个读取SP文件的方法
         * @return
         */
        public Map<String, String> read() {
            Map<String, String> data = new HashMap<String, String>();
            SharedPreferences sp = mContext.getSharedPreferences("my_sp", Context.MODE_PRIVATE);
            data.put("username", sp.getString("username", ""));
            data.put("passwd", sp.getString("passwd", ""));
            return data;
        }
    }

    SharedPreferenceActivity:

    public class SharedPreferenceActivity extends Activity {
        private EditText editname;
        private EditText editpasswd;
        private Button btnlogin,btnshow,button_clear;
        private String strname;
        private String strpasswd;
        private SharedHelper sh;
        private Context mContext;
        private SharedPreferences sp;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.shared_preference_activity);
            mContext = getApplicationContext();
            sh = new SharedHelper(mContext);
            intViews();
        }
    
        private void intViews() {
            editname = (EditText)findViewById(R.id.editname);
            editpasswd = (EditText)findViewById(R.id.editpasswd);
            button_clear = (Button)findViewById(R.id.button_clear);
            btnshow = (Button)findViewById(R.id.buttonshow);
            btnlogin = (Button)findViewById(R.id.btnlogin);
            btnlogin.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    strname = editname.getText().toString();
                    strpasswd = editpasswd.getText().toString();
                    sh.save(strname,strpasswd);
                }
            });
    
            btnshow.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    //获得第一个应用的包名,从而获得对应的Context,需要对异常进行捕获
                    try {
                        mContext = createPackageContext("com.example.jinboy.codertodeveloperbytcler.java_demo.appdemo.ui.androiddemo"
                                , Context.CONTEXT_IGNORE_SECURITY);
                    } catch (PackageManager.NameNotFoundException e) {
                        e.printStackTrace();
                    }
                    //根据Context取得对应的SharedPreferences
                    sp = mContext.getSharedPreferences("my_sp", Context.MODE_WORLD_READABLE);
                    String name = sp.getString("username", "");
                    String passwd = sp.getString("passwd", "");
                    Toast.makeText(getApplicationContext(), "Demo1的SharedPreference存的\n用户名为:" +
                            name + "\n密码为:" + passwd, Toast.LENGTH_SHORT).show();
                }
            });
    
            button_clear.setOnClickListener(new View.OnClickListener(){
                @Override
                public void onClick(View v) {
                    SPUtils.clear(mContext);
                    Toast.makeText(getApplicationContext(), "已删除保存信息" , Toast.LENGTH_SHORT).show();
                }
            });
        }
    
    
        @Override
        protected void onStart() {
            super.onStart();
            Map<String,String> data = sh.read();
            editname.setText(data.get("username"));
            editpasswd.setText(data.get("passwd"));
        }
    }
    
    SharedPreference工具类

    /**
     * <pre>
     *     author : JinBiao
     *     CSDN : http://my.csdn.net/DT235201314
     *     time   : 2017/06/12
     *     desc   : SharedPreference工具类
     *     version: 1.0
     * </pre>
     */
    
    public class SPUtils {
    
        /**
         * 保存在手机里的SP文件名
         */
        public static final String FILE_NAME = "my_sp";
    
        /**
         * 保存数据
         */
        public static void put(Context context, String key, Object obj) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            if (obj instanceof Boolean) {
                editor.putBoolean(key, (Boolean) obj);
            } else if (obj instanceof Float) {
                editor.putFloat(key, (Float) obj);
            } else if (obj instanceof Integer) {
                editor.putInt(key, (Integer) obj);
            } else if (obj instanceof Long) {
                editor.putLong(key, (Long) obj);
            } else {
                editor.putString(key, (String) obj);
            }
            editor.commit();
        }
    
    
        /**
         * 获取指定数据
         */
        public static Object get(Context context, String key, Object defaultObj) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
            if (defaultObj instanceof Boolean) {
                return sp.getBoolean(key, (Boolean) defaultObj);
            } else if (defaultObj instanceof Float) {
                return sp.getFloat(key, (Float) defaultObj);
            } else if (defaultObj instanceof Integer) {
                return sp.getInt(key, (Integer) defaultObj);
            } else if (defaultObj instanceof Long) {
                return sp.getLong(key, (Long) defaultObj);
            } else if (defaultObj instanceof String) {
                return sp.getString(key, (String) defaultObj);
            }
            return null;
        }
    
        /**
         * 删除指定数据
         */
        public static void remove(Context context, String key) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            editor.remove(key);
            editor.commit();
        }
    
    
        /**
         * 返回所有键值对
         */
        public static Map<String, ?> getAll(Context context) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
            Map<String, ?> map = sp.getAll();
            return map;
        }
    
        /**
         * 删除所有数据
         */
        public static void clear(Context context) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            editor.clear();
            editor.commit();
        }
    
        /**
         * 检查key对应的数据是否存在
         */
        public static boolean contains(Context context, String key) {
            SharedPreferences sp = context.getSharedPreferences(FILE_NAME, context.MODE_PRIVATE);
            return sp.contains(key);
        }
    }

    demo4:

    代码详解参考:

    扣丁学堂——SQLite

    玩家信息管理(SQLite+Fragment加强)

    Android基础入门教程——6.3.1 数据存储与访问之——初见SQLite数据库

    ContentProvider目前不做详解文章代码参考:

    扣丁学堂——ContentProvide

    Android基础入门教程——4.4.1 ContentProvider初探 

    Android基础入门教程——4.4.2 ContentProvider再探——Ducument Provider

    Android深入四大组件(五)Content Provider的启动过程



    五丶文件存储运用场景:

    1.文件操作不能用于其他应用,一般用于图片文件的保存;

    2.SharedPreference一般用于用户信息储存,能与其他应用共享数据,一般结合加密使用,如实现免登陆等操作;

    3.SQLite轻量级数据库,数据可共享,一般用于结构化数据存储,例如前面文章提到的日记本开发,结构化数据又提供增删改查功能;

    4.ContentProvider以提供公用url使数据数据在不同app中共享,例如视频音频图片通讯录等





    展开全文
  • 安卓获取USB存储卡的外挂路径

    千次阅读 2016-05-25 10:07:27
    * 获取所有存储卡挂载路径 * @return */ public static List<string> getMountPathList() { List<string> pathList = new ArrayList(); final String cmd = cat /proc/mounts; Runtime run = Runtime....
  • Unity3d资源写入Android内置存储卡

    千次阅读 2014-10-24 15:30:02
    所以应该在做游戏之前就想出一套很好的资源管理,使用,更新的方案,不能等游戏的导出包达到一定程度再合计资源管理,坑啊 最近一次对Assetbundle进行打包写入手机Application.persistentDataPath目录下面的时候...
  • 原文地址: http://blog.csdn.net/xiaominghimi/archive/2011/01/04/6114629.aspx<br />作者:Himi  上一篇跟各位童鞋介绍了SharedPreference 和 File流如何存储数据,并且推荐使用FileOutputStream/...
  • 在我们通常开发的应用程序中,不可避免的会出现crash现象,特别是当应用程序已经上线之后,这些crash异常信息我们通常是很难捕捉到的,如果我们不能对这些异常信息做及时的收集并且修复的话,势必会带来用户体验度的...
  • Windows使用C++获取网卡信息

    千次阅读 2017-04-26 11:14:13
    使用 Windows sdk 提供的 API 函数 GetAdaptersInfo() 可以获得本机所有网卡的网卡名 , 网卡描述 , 网卡 MAC 地址 , 网卡IP , 网卡类型等信息 , 并用 IP_ADAPTER_INFO 结构体存储 ; 使用 GetIfEntry() 可以获取网卡...
  • 在开头,先说一下在imageVIew中如何显示文件中存储的视频的第一帧的图片。很简单,几行代码就搞定。 MediaMetadataRetriever media = new MediaMetadataRetriever(); media.setDataSource(user.getPath()); ...
  • Java 异常处理

    千次阅读 2018-04-05 09:03:00
    Java 异常处理异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println(11/0...
  • 将数据库存储在SD中的方法

    千次阅读 2013-05-15 23:11:43
    【Android游戏开发十三】(保存游戏数据 [下文])详解SQLite存储方式,并把SQLite的数据库文件存储在SD中!!! 分类: 【 Android 游戏开发】 2011-01-04 02:08 15605人阅读 评论(48) 收藏 举报 ...
  • Android程序Crash时的异常上报

    万次阅读 多人点赞 2013-12-12 22:38:11
    当crash发生的时候,我们可以捕获到异常信息,把异常信息存储到SD中,然后在合适的时机通过网络将crash信息上传到服务器上,这样开发人员就可以分析用户crash的场景从而在后面的版本中修复此类crash。我们还可以在...
  • Android程序Crash时如何获取异常信息

    千次阅读 2016-11-30 17:43:59
    当crash发生的时候,我们可以捕获到异常信息,把异常信息存储到SD中,然后在合适的时机通过网络将crash信息上传到服务器上,这样开发人员就可以分析用户crash的场景从而在后面的版本中修复此类crash。我们还可以在...
  • 以前使用过一些 USB 存储设备使用痕迹检测和删除工具,于是想写了一个小工具来模拟这些功能。 USB 存储设备在使用后会在注册表留下一些记录,一般是通过检索相应的注册表键值来检查使用痕迹。这些键值包括: ...
  • Android开发——理解文件存储

    千次阅读 2016-10-16 13:20:32
    一、内部存储和外部存储的概念在Android中,我们可以把数据存储在SharedPreferences、内部存储、外部存储、SQLite数据库和网络上。其中内部存储指的是设备内存,一般存储私有数据;外部存储是共享的,可以用来存储...
  • 客户端存储

    千次阅读 2012-01-05 20:51:03
    Web应用允许使用浏览器提供的API实现将数据存储到用户的电脑上。这种客户端存储相当于赋予了Web浏览器记忆功能。比方说,Web应用就可以用这种方式来“记住”用户的配置信息甚至是用户所有的状态信息,以便准确地...
  • 编写 USB 存储设备使用痕迹检测和删除工具
  • Android数据存储

    千次阅读 2016-07-12 13:32:07
    数据存储在Android开发中是很重要的,因为做一个项目一定会用到数据存储,比如游戏或者应用的一些设置配置,游戏存档,应用使用习惯等。这篇主要写本地文件的存储,下篇会介绍数据库相关内容。 这里首先讲Android的...
  • 文件存储前言文件存储内存内部存储外部存储内部存储操作API读写操作外部存储操作公共目录私有目录私有文件私有缓存 前言 众所周知,数据存储在每个应用中都会用到,那所用到的技术应该怎么选呢,这里Android给...
  • 使用mat分析 内存泄露Memory Leak 内存溢出Memory Overflow 虚拟机栈和本地方法栈溢出 方法区和运行时常量池溢出 本机直接内存溢出 思维导图 接下来,我们来通过示例来演示下出现异常的场景。 Java...
  • 数据存储在开发中是使用最频繁的,在这里主要介绍Android平台中实现数据存储的5种方式,分别是: 1 使用SharedPreferences存储数据 2 文件存储数据 3 SQLite数据库存储数据 4 使用ContentProvider存储数据 5 网络...
  • 异常(Outlier)检测算法综述

    万次阅读 2014-05-09 21:50:39
    什么是异常(outlier)?Hawkins(1980)给出了异常的本质性的定义:异常是在数据集中与众不同的数据,使人怀疑这些数据并非随机偏差,而是产生于完全不同的机制。聚类算法对异常的定义:异常是聚类嵌于其中的背景噪声。...
  • 第三章 存储

    千次阅读 2020-04-11 21:18:06
    文章目录第四章 存储(一)Android 5种保存数据的方法(1)方法1:SharedPreferences 用户偏好设置1.1)简介——Android最简单数据存储方式1.2)基本使用1.3)工具类——对SharedPreferences功能进行封装1.4)数据的...
  • Linux作为一套免费使用和自由传播的类Unix操作系统,不仅系统性能稳定,而且是开源软件。其核心防火墙组件性能高效、配置简单,保证了系统的安全。Linux既可以当作服务器,又可以当作网络防火墙是Linux的 一大亮点。...
  • Android存储的实现

    千次阅读 2016-04-10 15:19:04
    本文结合案例介绍了Android存储的基础知识点: 1、使用SharedPreferences读写简单的数据; 2、保存和读取外部存储的内容; 3、保存和读取内部存储的内容; 4、对Android内嵌数据库SQLite的增删改查、更新版本等操作...
  • Android开机log和常见异常的分析

    千次阅读 2017-05-23 10:43:58
    分析开机log,一是可以理一下android启动流程,二是可以通过log定位错误,下面列举一些常见android程序发生错误时抛出的异常,查找关键字xxxException可以快速定位android层错误以及原因: Java.lang....
  • 简述 程序运行时,发生了不被期望的结果,阻止了程序按照预期正常执行,这就是异常。世界上没有不出错的程序,只有正确处理好意外情况,才能保证程序的可靠...异常处理机制能让程序在异常发生时,按照代码的预先...
  • 安卓五种存储方式入门

    千次阅读 2016-03-14 13:27:26
    数据存储在开发中是使用最频繁的,在这里主要介绍Android平台中实现数据存储的5种方式,分别是: 1 使用SharedPreferences存储数据 2 文件存储数据 3 SQLite数据库存储数据 4 使用ContentProvider存储数据 5 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,044
精华内容 18,817
关键字:

当前使用的存储卡异常