Android asset资源的获取与处理

记录下assestManager的简要使用。

1.列出assets目录下所有文件

    private void showAssetList(){
        AssetManager assetManager = getResources().getAssets();
        try {
            String[] lists = assetManager.list(\"zxl\");
            for (String fileName:lists){
                Log.e(\"asset文件\",fileName );
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

如上图所展示，我们可通过 fileName.concat(\".\") 来判定此文件是 文件夹(directory)还是文件(file) 。但该案例还没有打印出所有文件，下面我们就来实现迭代打印该文件夹下的所有文件。

    private void showAssetList(String fileAssetName){
        AssetManager assetManager = getResources().getAssets();
        try {
            String[] lists = assetManager.list(fileAssetName);
            for (String fileName:lists){
                if (fileName.contains(\".\")){
                    // 文件
                    Log.e(\"asset\",\"文件名路径  = \"+fileAssetName+File.separator+fileName+\"\\n\");
                }else {
                    Log.e(\"asset\",\"文件夹路径  = \"+fileAssetName+File.separator+fileName+\"\\n\");
                    showAssetList(fileAssetName+File.separator+fileName);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 E/asset: 文件名路径  = zxl/1.txt
 E/asset: 文件夹路径  = zxl/l
 E/asset: 文件名路径  = zxl/l/hehe.txt
 E/asset: 文件夹路径  = zxl/x
 E/asset: 文件名路径  = zxl/x/haha.txt
 E/asset: 文件夹路径  = zxl/z
 E/asset: 文件名路径  = zxl/z/wuwu.txt

 打印文件txt内容

    private void showContent(String fileName) {
        InputStream inputStream = null;
        BufferedReader bufferedReader = null;
        String line = null;
        AssetManager assetManager = getResources().getAssets();
        try {
            inputStream = assetManager.open(fileName);
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            while ((line = bufferedReader.readLine()) != null) {
                Log.e(\"数据打印\", line+\"\");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 E/数据打印: 哦哦 加油
 E/数据打印: 你是谁
 E/数据打印: 我是开发者
 E/数据打印: 哦哦 你好

2.sax解析assest下的xml文件<规范数据>

 数据源----

<?xml version=\"1.0\" encoding=\"utf-8\"?>
<!-- 测试数据-->
<data>
    <person>
        <name>小张</name>
        <age>18</age>
        <sex>男</sex>
    </person>

    <person>
        <name>小力</name>
        <age>15</age>
        <sex>男</sex>
    </person>

    <person>
        <name>小丽</name>
        <age>17</age>
        <sex>女</sex>
    </person>
</data>

具体解析过程，中间含详细的说明

调用：ParseDataManager.getInstance().parseData(MainActivity.this);

public class ParseDataManager {
    private static final String TAG = \"ParseDataManager\";
    private String assetPath = \"person.xml\";
    private static final int NODE_NAME = 1;
    private static final int NODE_AGE = 2;
    private static final int NODE_SEX = 3;
    private Person mPerson;
    private  List<Person> mDefaultEntries = new ArrayList<>();
    private int mCurrentState = 0;
    private ParseDataManager(){}

    public static ParseDataManager getInstance(){
        return ParseDataManagerHolder.MINATANCE;
    }

    private static class ParseDataManagerHolder{
        private static final ParseDataManager MINATANCE = new ParseDataManager();
    }

    public  void parseData(Context context){
        new EntryLoad().load(context,assetPath);
        if (mDefaultEntries != null){
            for (Person person:mDefaultEntries){
                Log.e(TAG, person.toString());
            }
        }
    }
    
    // sax解析必须实现的类
    private class EntryLoad extends DefaultHandler{

        public void load(Context context,String assetPath){
            InputStream is = null;
            try {
                // 打开待解析文件 获得文件流
                is = context.getAssets().open(assetPath);
                // 对绑定的handler进行解析
                Xml.parse(is,Xml.Encoding.UTF_8,this);
            } catch (IOException e) {
                e.printStackTrace();
            }catch (SAXException e) {
                e.printStackTrace();
            }finally {
                if (is != null){
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        /**
         * xml解析开始 ------ 只会调用一次
         * @throws SAXException
         */
        @Override
        public void startDocument() throws SAXException {
            super.startDocument();
            Log.e(TAG, \"startDocument:开始解析\");
        }

        /**
         * xml解析结束 ------- 只会调用一次
         * @throws SAXException
         */
        @Override
        public void endDocument() throws SAXException {
            super.endDocument();
            Log.e(TAG, \"endDocument:结束解析 \");
        }

        /**
         * 检测节点开始 <....>
         */
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            super.startElement(uri, localName, qName, attributes);
            Log.e(TAG, \"startElement: 处理节点 = \"+localName);
            if (\"data\".equals(localName)){
                mCurrentState = 0;
                return;
            }

            if (\"person\".equals(localName)){
                mPerson = new Person();
                return;
            }

            if (\"name\".equals(localName)){
                mCurrentState = NODE_NAME;
                return;
            }

            if (\"age\".equals(localName)){
                mCurrentState = NODE_AGE;
                return;
            }

            if (\"sex\".equals(localName)){
                mCurrentState = NODE_SEX;
                return;
            }

            mCurrentState = 0;
        }

        /**
         * 检测节点结束  </....>
         */
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            super.endElement(uri, localName, qName);
            Log.e(TAG, \"endElement: ----------\");
            if (\"person\".equals(localName)){
                mDefaultEntries.add(mPerson);
            }
        }

        /**
         * 节点中的文本信息
         */
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            super.characters(ch, start, length);
            String value = new String(ch, start, length);
            Log.e(TAG, \"characters 文本 = \"+value);
            switch (mCurrentState){
                case NODE_NAME:
                    mPerson.setName(value);
                    break;
                case NODE_AGE:
                    mPerson.setAge(Integer.parseInt(value));
                    break;
                case NODE_SEX:
                    mPerson.setSex(value);
                    break;
                    default:
                        break;
            }
            mCurrentState = 0;
        }
    }
}

解析数据log日志 

startDocument:开始解析
startElement: 处理节点 = data
characters 文本 = 
characters 文本 =     
startElement: 处理节点 = person ****(所以在这里检测节点 新建person对象)
characters 文本 = 
characters 文本 =         
startElement: 处理节点 = name
characters 文本 = 小张
endElement: ----------  ***(</...> 指代的是一个节点的结束标志)
characters 文本 = 
characters 文本 =         
startElement: 处理节点 = age
characters 文本 = 18
endElement: ----------
characters 文本 = 
characters 文本 =         
startElement: 处理节点 = sex
characters 文本 = 男
endElement: ----------
characters 文本 = 
characters 文本 =     
endElement: ------- (*****当结束节点的标志是person时,说明是有效数据 就加入缓存****)
characters 文本 = 
characters 文本 = 
characters 文本 =     
startElement: 处理节点 = person
characters 文本 = 
characters 文本 =         
startElement: 处理节点 = name
characters 文本 = 小力
endElement: ----------
...
characters 文本 = 
characters 文本 =     
endElement: ----------
characters 文本 = 
endElement: ----------
endDocument:结束解析 
name = 小张 age = 18 sex = 男
name = 小力 age = 15 sex = 男
name = 小丽 age = 17 sex = 女

3.利用属性来进行解析<自定义数据>

案例2的解析是比较常规的，通过检测节点开始初始化对象，在character中设置属性结果，在节点结束标记判断来缓存对象数据，正常来说我们应该多熟悉和掌握，下面将介绍一种通过属性来解析缓存数据的方式。

//数据源
<?xml version=\"1.0\" encoding=\"utf-8\"?>
<data>
    <person name=\"小张\" age=\"18\" sex=\"男\" />
    <person name=\"小李\" age=\"13\" sex=\"女\"/>
    <person name=\"小王\" age=\"12\" sex=\"男\"/>
    <person name=\"小白\" age=\"15\" sex=\"女\"/>
</data>


//结果
name = 小张 age = 18 sex = 男
name = 小李 age = 13 sex = 女
name = 小王 age = 12 sex = 男
name = 小白 age = 15 sex = 女

主体和案例2一致，主要通过获取属性值然后再添加入缓存中。api, attributes.getValue(uri,\'属性名称\'); 

        /**
         * 根据parson 获取属性值加入缓存中
         * @param uri
         * @param localName
         * @param qName
         * @param attributes
         * @throws SAXException
         */
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            super.startElement(uri, localName, qName, attributes);
            if (\"person\".equals(localName)){
                String name = attributes.getValue(uri, \"name\");
                String age = attributes.getValue(uri, \"age\");
                String sex = attributes.getValue(uri, \"sex\");
                mEntriesList.add(new Person(name,sex,Integer.parseInt(age)));
            }
        }

4.后续

     对asset的解析案例记录先到这里，后面会陆续的进行增加包括对json文件的解析。