android，如何获取目录列表？（安卓获取目录）

25-02-26 22

对于想了解android，如何获取目录列表？的读者，本文将提供新的信息，我们将详细介绍安卓获取目录，并且为您提供关于(android)解剖contentProvider获取通讯录列表-002、(and

对于想了解android，如何获取目录列表？的读者，本文将提供新的信息，我们将详细介绍安卓获取目录，并且为您提供关于(android)解剖contentProvider获取通讯录列表-002、(android)解剖contentProvider获取通讯录列表-003、android – NDK如何获取所有进程运行的列表？、android – 如何制作一个可以列表的列表？的有价值信息。

本文目录一览：

android，如何获取目录列表？（安卓获取目录）
(android)解剖contentProvider获取通讯录列表-002
(android)解剖contentProvider获取通讯录列表-003
android – NDK如何获取所有进程运行的列表？
android – 如何制作一个可以列表的列表？

android，如何获取目录列表？（安卓获取目录）

只是一个简单的问题，如何获得指定目录内的目录列表。

例如，

String path = Environment.getExternalStorageDirectory().toString()+"/myApp/";

现在，我需要获取“路径”目录中的目录列表。

谢谢！

答案1

小编典典

诸如此类（添加null检查，异常等。）

File f = new File(path);File[] files = f.listFiles();for (File inFile : files) {    if (inFile.isDirectory()) {        // is directory    }}

(android)解剖contentProvider获取通讯录列表-002

//基于上一次说的内容 ,我们来弄下获取联系人详细信息,直接上代码,在第三篇补上其他的操作

package org.mo.pmas.resolver;
//本文章归属于小黑_mo所有,转载请说明出来http://my.oschina.net/moziqi/
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.provider.ContactsContract;
import android.util.Log;
import org.mo.pmas.activity.R;
import org.mo.pmas.entity.Contact;
import org.mo.pmas.entity.Phone;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by moziqi on 2015/1/9 0009.
 */
public class ContactResolver implements BaseResolver<Contact> {
    private Context mContext;

    public ContactResolver(Context mContext) {
        this.mContext = mContext;
    }

    @Override
    public boolean save(Contact entity) {
        return false;
    }

    @Override
    public boolean update(Contact entity) {
        return false;
    }

    @Override
    public boolean delete(Contact entity) {
        return false;
    }

    @Override
    public List<Contact> findAll() {
        List<Contact> contacts = new ArrayList<Contact>();
        ContentResolver contentResolver = mContext.getContentResolver();
        Cursor cursor = contentResolver.query(
                ContactsContract.Contacts.CONTENT_URI,
                null,
                null,
                null,
                ContactsContract.Contacts.DISPLAY_NAME
                        + " COLLATE LOCALIZED ASC");
        if (cursor.moveToFirst()) {
            do {
                Contact contact = new Contact();
                // 获得联系人的ID号
                int contactId = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts._ID));
                // 获得联系人姓名
                String contactName = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));

                //获取联系人生日
                String[] projection = new String[]{ContactsContract.CommonDataKinds.Event.DATA1};
                String selection = ContactsContract.Data.MIMETYPE
                        + "=''"
                        + ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE
                        + "''"
                        + " and "
                        + ContactsContract.CommonDataKinds.Event.TYPE
                        + "=''"
                        + ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY
                        + "''"
                        + " and "
                        + ContactsContract.CommonDataKinds.Event.CONTACT_ID
                        + " = " + contactId;
                Cursor birthdayCursor = mContext.getContentResolver().query(
                        ContactsContract.Data.CONTENT_URI,
                        projection,
                        selection,
                        null,
                        null);
                String birthday = null;
                if (birthdayCursor.moveToFirst()) {
                    birthday = birthdayCursor.getString(birthdayCursor.getColumnIndex(ContactsContract.CommonDataKinds.Event.DATA));
                }
                birthdayCursor.close();

                //得到联系人头像Bitamp
                Bitmap contactPhoto = null;
                //得到联系人头像ID
                int photoid = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts.PHOTO_ID));
                //photoid 大于0 表示联系人有头像 如果没有给此人设置头像则给他一个默认的
                if (photoid > 0) {
                    Uri uri = ContentUris.withAppendedId(ContactsContract.Contacts.CONTENT_URI, (long) contactId);
                    InputStream input = ContactsContract.Contacts.openContactPhotoInputStream(mContext.getContentResolver(), uri);
                    contactPhoto = BitmapFactory.decodeStream(input);
                    try {
                        input.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                } else {
                    contactPhoto = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.h001);
                }

                // 获取该联系人邮箱
                //我这里只需要获取一个,没有遍历全部出来
                Cursor cursorEmail = mContext.getContentResolver().query(
                        ContactsContract.CommonDataKinds.Email.CONTENT_URI,
                        null,
                        ContactsContract.CommonDataKinds.Email.CONTACT_ID
                                + " = " + contactId, null, null);
                String email = null;
                if (cursorEmail.moveToFirst()) {
                    email = cursorEmail.getString(
                            cursorEmail.getColumnIndex(
                                    ContactsContract.CommonDataKinds.Email.DATA));
                }
                cursorEmail.close();

                // 获取该联系人地址
                //我这里只需要获取一个,没有遍历全部出来
                Cursor cursorAddress = mContext.getContentResolver().query(
                        ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_URI,
                        null,
                        ContactsContract.CommonDataKinds.StructuredPostal.CONTACT_ID
                                + " = " + contactId, null, null);
                String address = null;
                if (cursorAddress.moveToFirst()) {
                    //获取CITY
                    address = cursorAddress.getString(cursorAddress.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.CITY));
                }
                cursorAddress.close();

                contact.setId(contactId);
                contact.setName(contactName);
                contact.setContactPhoto(contactPhoto);
                contact.setEmail(email);
                contact.setAddress(address);
                contact.setBirthday(birthday);

                // 查看该联系人有多少个电话号码。如果没有这返回值为0
                int has_phone_number = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER));
                if (has_phone_number > 0) {
                    // 获得联系人的电话号码
                    Cursor cursorPhone = mContext.getContentResolver().query(
                            ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
                            null,
                            ContactsContract.CommonDataKinds.Phone.CONTACT_ID
                                    + " = " + contactId, null, null);
                    List<Phone> phones = new ArrayList<Phone>();
                    if (cursorPhone.moveToFirst()) {
                        do {
                            Phone phone = new Phone();
                            int phoneId = cursorPhone.getInt(
                                    cursorPhone.getColumnIndex(
                                            ContactsContract.CommonDataKinds.Phone._ID));
                            String phoneNumber = cursorPhone.getString(
                                    cursorPhone.getColumnIndex(
                                            ContactsContract.CommonDataKinds.Phone.NUMBER));
                            phone.setContact(contact);
                            phone.setId(phoneId);
                            phone.setPhoneNumber(phoneNumber);
                            //保存phone list集合
                            phones.add(phone);
                        } while (cursorPhone.moveToNext());
                    }
                    cursorPhone.close();
                    //如果有电话号码就把phones添加到contact上
                    contact.setPhones(phones);
                }

                contacts.add(contact);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return contacts;
    }
}

//另外2个bean类

public class Contact implements Serializable {

    private Integer id;//编号

    private String name;//名字

    private String birthday;//生日

    private String email;//邮箱地址

    private String address;//通讯地址

    private Bitmap contactPhoto;//联系人照片

    private String phoneNumber;//联系电话

    private String sortLetters;  //显示数据拼音的首字母

    private String contactGroup;//联系组名称

    private String objectId;

    private String createdAt;

    private ContactGroup mContactGroup;

    private MyUser myUser;

    private List<Phone> phones;
    
    //getset
 }

package org.mo.pmas.entity;

import android.os.Parcel;
import android.os.Parcelable;

import java.io.Serializable;

/**
 * Created by moziqi on 2015/1/9 0009.
 */
public class Phone implements Serializable {

    private Integer id;
    private String objectId;
    private String phoneNumber;
    private Contact contact;
    private MyUser myUser;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getObjectId() {
        return objectId;
    }

    public void setObjectId(String objectId) {
        this.objectId = objectId;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public Contact getContact() {
        return contact;
    }

    public void setContact(Contact contact) {
        this.contact = contact;
    }

    public MyUser getMyUser() {
        return myUser;
    }

    public void setMyUser(MyUser myUser) {
        this.myUser = myUser;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "phoneNumber=''" + phoneNumber + ''\'''' +
                ", objectId=''" + objectId + ''\'''' +
                ", id=" + id +
                ''}'';
    }
}

参考内容http://www.verydemo.com/demo_c131_i81641.html

http://www.eoeandroid.com/thread-24595-1-1.html

(android)解剖contentProvider获取通讯录列表-003

群组的增删改查, 群组跟联系人是多对多的关系,这个是我的理解

//代码多长,我就分开来写吧
public class ContactGroupResolver implements BaseResolver<ContactGroup> {

    private Context mContext;

    public ContactGroupResolver(Context mContext) {
        this.mContext = mContext;
    }

    private ContentResolver resolver;

    public ContactGroupResolver(ContentResolver resolver) {
        this.resolver = resolver;
    }
    //这个你懂得
 }

里面的每一个方法

    /**
     * 获取所有的组
     *
     * @return
     */
    public List<HashMap<String, String>> getGroups() {
        List<HashMap<String, String>> groups = new ArrayList<HashMap<String, String>>();

        Cursor cursor = resolver.query(ContactsContract.Groups.CONTENT_URI, null, null, null, null);
        HashMap<String, String> group = new HashMap<String, String>();
        while (cursor.moveToNext()) {
            int id = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
            String title = cursor.getString(cursor.getColumnIndex(ContactsContract.Groups.TITLE));
            group.put("id", id + "");
            group.put("title", title);
            groups.add(group);
        }
        cursor.close();
        return groups;
    }

 /**
     * 创建组
     *
     * @return int
     */
    public long createGroup(String title) {
        if (TextUtils.isEmpty(title)) {
            return -1;
        }
        long gId = getGroupByTitle(title);
        if (gId == -1) {
            ContentValues values = new ContentValues();
            values.put(ContactsContract.Groups.TITLE, title);
            Uri uri = resolver.insert(ContactsContract.Groups.CONTENT_URI, values);
            gId = ContentUris.parseId(uri);
        }
        return gId;
    }

/**
     * 根据组的名称查询组
     *
     * @return int
     */
    public int getGroupByTitle(String title) {
        int id = -1;
        Cursor cursor = mContext.getContentResolver().query(
                ContactsContract.Groups.CONTENT_URI,
                new String[]{ContactsContract.Groups._ID},
                ContactsContract.Groups.TITLE + "=''" + title + "''",
                null, null);
        if (cursor.moveToNext()) {
            id = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
        }
        cursor.close();
        return id;
    }

   /**
     * 根据组的id删除组
     *
     * @return int
     */
    public int delGroupById(String selection, String[] ids) {
        Uri uri = Uri.parse(ContactsContract.Groups.CONTENT_URI + "?" + ContactsContract.CALLER_IS_SYNCADAPTER + "=true");
        int i = resolver.delete(
                uri,
                ContactsContract.Groups._ID + selection,
                ids);
        return i;
    }

    /**
     * 保存群组
     * @param entity
     * @return
     */
    @Override
    public boolean save(ContactGroup entity) {
        if (TextUtils.isEmpty(entity.getName())) {
            return false;
        }
        long gId = getGroupByTitle(entity.getName());
        if (gId == -1) {
            ContentValues values = new ContentValues();
            values.put(ContactsContract.Groups.TITLE, entity.getName());
            Uri uri = mContext.getContentResolver().insert(ContactsContract.Groups.CONTENT_URI, values);
            gId = ContentUris.parseId(uri);
            return true;
        } else {
            return false;
        }
    }

   /**
     * 更新群组
     * @param entity
     * @return
     */
    @Override
    public boolean update(ContactGroup entity) {
        long gId = getGroupByTitle(entity.getName());
        if (gId == -1) {
            Uri uri = ContentUris.withAppendedId(ContactsContract.Groups.CONTENT_URI, entity.getId());
            ContentValues values = new ContentValues();
            values.put(ContactsContract.Groups.TITLE, entity.getName());
            mContext.getContentResolver().update(uri, values, null, null);
            return true;
        } else {
            return false;
        }

    }

   /**
     * 删除群组
     * @param entity
     * @return
     */
    @Override
    public boolean delete(ContactGroup entity) {
        Uri uri = Uri.parse(ContactsContract.Groups.CONTENT_URI + "?" + ContactsContract.CALLER_IS_SYNCADAPTER + "=true");
        int i = mContext.getContentResolver().delete(
                uri,
                ContactsContract.Groups._ID + "=" + entity.getId(),
                null);
        if (i > 0) {
            return true;
        } else {
            return false;
        }
    }

 /**
     * 查找所有群组
     * @return
     */
    @Override
    public List<ContactGroup> findAll() {
        List<ContactGroup> groups = new ArrayList<ContactGroup>();
        Cursor cursor = mContext.getContentResolver().query(ContactsContract.Groups.CONTENT_URI,
                null,
                null,
                null,
                null);
        if (cursor.moveToFirst()) {
            do {
                ContactGroup contactGroup = new ContactGroup();
                int id = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
                String title = cursor.getString(cursor.getColumnIndex(ContactsContract.Groups.TITLE));
                contactGroup.setId(id);
                contactGroup.setName(title);
                groups.add(contactGroup);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return groups;
    }

 /**
     * 通过id查找群组
     * @param id
     * @return
     */
    @Override
    public ContactGroup findOneById(Serializable id) {
        ContactGroup contactGroup = null;
        Cursor cursor = mContext.getContentResolver().query(ContactsContract.Groups.CONTENT_URI,
                null,
                ContactsContract.Groups._ID + "=?",
                new String[]{id + ""},
                null);
        if (cursor.moveToFirst()) {
            contactGroup = new ContactGroup();
            int cgid = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
            String title = cursor.getString(cursor.getColumnIndex(ContactsContract.Groups.TITLE));
            contactGroup.setId(cgid);
            contactGroup.setName(title);
        }
        cursor.close();
        return contactGroup;
    }

  /**
     * 通过群组获取联系人列表
     * @param groupId
     * @return
     */
    public List<Contact> getAllContactsByGroupId(int groupId) {
        List<Contact> contacts = new ArrayList<Contact>();
        String[] RAW_PROJECTION = new String[]{ContactsContract.Data.RAW_CONTACT_ID,};
        String RAW_CONTACTS_WHERE = ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID
                + "=?"
                + " and "
                + ContactsContract.Data.MIMETYPE
                + "="
                + "''"
                + ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE
                + "''";

        // 通过分组的id 查询得到RAW_CONTACT_ID
        Cursor cursor = mContext.getContentResolver().query(
                ContactsContract.Data.CONTENT_URI, RAW_PROJECTION,
                RAW_CONTACTS_WHERE, new String[]{groupId + ""}, "data1 asc");
        while (cursor.moveToNext()) {
            // RAW_CONTACT_ID
            int col = cursor.getColumnIndex("raw_contact_id");
            int raw_contact_id = cursor.getInt(col);
            Contact ce = new Contact();
            ce.setId(raw_contact_id);
            Uri dataUri = Uri.parse("content://com.android.contacts/data");
            Cursor dataCursor = mContext.getContentResolver().query(dataUri,
                    null, "raw_contact_id=?",
                    new String[]{raw_contact_id + ""}, null);

            while (dataCursor.moveToNext()) {
                String data1 = dataCursor.getString(dataCursor
                        .getColumnIndex("data1"));
                String mime = dataCursor.getString(dataCursor
                        .getColumnIndex("mimetype"));
                if ("vnd.android.cursor.item/name".equals(mime)) {
                    ce.setName(data1);
                }
            }
            dataCursor.close();
            contacts.add(ce);
            ce = null;
        }
        cursor.close();
        return contacts;
    }

   /**
     * 通过联系人获取群组
     * @param conactId
     * @return
     */
    public ContactGroup getContactGroupByConactId(Integer conactId) {
        ContactGroup contactGroup = null;
        Cursor query = mContext.getContentResolver().query(
                ContactsContract.Data.CONTENT_URI,
                null,
                ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID + "=? and " + ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE + "=?",
                new String[]{"" + conactId, ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE},
                null);
        if (query.moveToFirst()) {
            contactGroup = new ContactGroup();
            int id = query.getInt(query.getColumnIndex(ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID));
            contactGroup = findOneById(id);
        }
        query.close();
        return contactGroup;
    }

    /**
     * 保存关系
     * @param contactGroupId
     * @param contactId
     */
    public void saveRelationship(Integer contactGroupId, Integer contactId) {
        ContentValues values = new ContentValues();
        values.put(ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID, contactId);
        values.put(ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID, contactGroupId);
        values.put(ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE, ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE);
        mContext.getContentResolver().insert(ContactsContract.Data.CONTENT_URI, values);
    }

给组移除成员(groupId,personId):   
getContentResolver().delete(ContactsContract.Data.CONTENT_URI,ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID + "=? and " +ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID + "=? and " +ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE + "=?",new String[]{"" + personId,"" + groupId,ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE});

android – NDK如何获取所有进程运行的列表？

无论如何使用NDK使用纯C/C++代码在设备上运行当前所有进程？

解决方法:

对于大多数这类东西来说,Android是Linux,而在Linux上执行此操作的官方方法是读取/ proc文件系统.这就是ps命令行程序的功能.这是Android’s ps program的片段,它位于平台/系统/核心存储库中：

d = opendir("/proc");

while((de = readdir(d)) != 0){
    if(isdigit(de->d_name[0])){
        int pid = atoi(de->d_name);
        if(!pidfilter || (pidfilter == pid)) {
            ps_line(pid, 0, namefilter);
            if(threads) ps_threads(pid, namefilter);
        }
    }
}

ps_line函数非常大,但你想要的部分是它读取/ proc /< pid> / stat的地方.从该文件中,您可以轻松获取进程名称,因为格式是PID(进程名称)其他内容 – 只需查找第一个paren并解析直到结束时.

android – 如何制作一个可以列表的列表？

我正在尝试让我的类可以使用,但它里面有一个枚举列表.

我已经看过如何使用单个枚举here …

我怎么能这样做？

谢谢！

总结

以上是小编为你收集整理的android – 如何制作一个可以列表的列表？全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

我们今天的关于android，如何获取目录列表？和安卓获取目录的分享已经告一段落，感谢您的关注，如果您想了解更多关于(android)解剖contentProvider获取通讯录列表-002、(android)解剖contentProvider获取通讯录列表-003、android – NDK如何获取所有进程运行的列表？、android – 如何制作一个可以列表的列表？的相关信息，请在本站查询。

本文标签：