常见Android工具类之列表

常见Android工具类之列表（未完待续。。。）

• 获取应用程序的版本名和版本号
• 获取手机联系人的信息（电话号码和名字）
• 意图开启一个Activity的几种方式
• 应用程序的Log的控制
• MD5加密一个字符串得到哈希值
• 获取手机进程的相关信息（进程的总数、内存可用，总空间）
• 判断系统的服务是否在后台运行
• 功能是把一个流对象转换成字符串对象
• 一个弹吐司的工具类
• 拷贝资产目录下的数据库到Android系统下

获取应用程序的版本名和版本号

public class AppInfoUtils { 
/* *  获取版本名 */ 
public static String getAppInfoName(Context context){  
try {
 //获取packageManager实例 PackageManager pm=context.getPackageManager(); 
//获取版本信息 PackageInfo packageinfo= 
pm.getPackageInfo(context.getPackageName(), 0); 
String versionname=packageinfo.versionName; return versionname;  
} catch (NameNotFoundException e)
 { e.printStackTrace(); } return "";  }   
/* * 获取版本号 */ 
public static int getAppInfoNumber(Context context){  
try { //获取packageManager实例 
PackageManager pm=context.getPackageManager(); 
//获取版本信息 PackageInfo packageinfo=
 pm.getPackageInfo(context.getPackageName(), 0); 
int versionnumber=packageinfo.versionCode; return versionnumber;  
} catch (NameNotFoundException e) { e.printStackTrace(); } return 0;  } }

获取手机联系人的信息（电话号码和名字）

public class ContactsInfoUtils { public static List<ContactsInfo>
 getContactsInfo(Context context){  
List<ContactsInfo> infocontacts=new ArrayList<ContactsInfo>(); 
//获取内容提供者的解析器 
ContentResolver resolver=context.getContentResolver(); 
Uri uri=Uri.parse("content://com.android.contacts/raw_contacts"); 
Uri dataUri=Uri.parse("content://com.android.contacts/data");
 //游标 
Cursor cursor=resolver.query(uri, new String[]{"contact_id"}, null, null, null); 
//遍历游标集合 while(cursor.moveToNext()){ 
String id=cursor.getString(cursor.getColumnIndex("contact_id")); 
System.out.println("id"+id);  
if(id!=null){ 
ContactsInfo infos=new ContactsInfoUtils().new ContactsInfo(); 
Cursor datacursor=resolver.query(dataUri, new String[]{"data1","mimetype"}, "raw_contact_id=?", new String[]{id}, null); 
while(datacursor.moveToNext()){ 
String data1=datacursor.getString(0); 
String mimetype=datacursor.getString(1); 
if("vnd.android.cursor.item/name".equals(mimetype)){ 
//姓名
 infos.setName(data1);
 }else if("vnd.android.cursor.item/phone_v2".equals(mimetype)){
 //电话
 infos.setPhone(data1);
 }else if("vnd.android.cursor.item/email_v2".equals(mimetype)){
 //电话
 infos.setEmail(data1); }  
} infocontacts.add(infos); 
} 
return infocontacts; }
 return infocontacts;    
} 
public static List<ContactsInfo> getROMContacts(Context context){ 
//联系人信息集合 List<ContactsInfo> contactList = new ArrayList<ContactsInfo>(); 
 // 获取手机通讯录信息  
ContentResolver resolver = context.getContentResolver();  
/** 所有的联系人信息 */  
Cursor personCur = resolver.query(ContactsContract.Contacts.CONTENT_URI, null,  null, null, null); 
 // 循环遍历，获取每个联系人的姓名和电话号码 
 while (personCur.moveToNext()) {  
// 新建联系人对象  
ContactsInfo cInfor =new ContactsInfoUtils().new ContactsInfo();  
// 联系人姓名 
 String cname = "";  
// 联系人电话  
String cnum = ""; 
 // 联系人id号码  
String ID; 
 ID = personCur.getString(personCur  .getColumnIndex(ContactsContract.Contacts._ID));  
// 联系人姓名  
cname = personCur.getString(personCur .getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));  
// id的整型数据  
int id = Integer.parseInt(ID); if (id > 0) {  
// 获取指定id号码的电话号码  
Cursor c = resolver.query(  ContactsContract.CommonDataKinds.Phone.CONTENT_URI,  null, ContactsContract.CommonDataKinds.Phone.CONTACT_ID  + "=" + ID, null, null);  
// 遍历游标  
while (c.moveToNext()) {  cnum = c.getString(c  .getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));  } 
 // 将对象加入到集合中  
cInfor.setName(cname);  
cInfor.setPhone(cnum);  
contactList.add(cInfor);   
} } return contactList; }   
public class ContactsInfo{
 public String name; 
public String email; 
public String getName() { 
return name; } 
public void setName(String name) {
 this.name = name; }
 public String getEmail() { 
return email; }
 public void setEmail(String email) { 
this.email = email; } 
public String getPhone() { 
return phone; } 
public void setPhone(String phone) { 
this.phone = phone; } 
public String phone; } } 

意图开启一个Activity的几种方式

public class IntentUtils {  
/** * 进入一个界面 */ 
public static void startActivityInfo(Activity context,Class<?>cls){
 Intent intent=new Intent(context,cls); 
context.startActivity(intent); } 
 /** * 进入一个界面并结束自己 */ 
public static void startActivityAndFinish(Activity context,Class<?>cls){
 Intent intent=new Intent(context,cls); 
context.startActivity(intent); context.finish(); } 
/** * 延迟进入进入一个界面 *  */ 
public static void startActivityDelay(final Activity context,final Class<?>cls,final long time){  
new Thread(){ 
@Override 
public void run() {
 try { Thread.sleep(time); }
 catch (InterruptedException e) 
{ e.printStackTrace(); } 
Intent intent=new Intent(context,cls);
 context.startActivity(intent); } }.start(); }  
/** * 延迟进入进入另一个界面并销毁这个界面 *  */ 
public static void startActivityDelayAndFinish(final Activity context,final Class<?>cls,final long time){  
new Thread(){ 
@Override 
public void run() { 
try { Thread.sleep(time);
 } catch (InterruptedException e) { 
e.printStackTrace(); } 
Intent intent=new Intent(context,cls); 
context.startActivity(intent); 
context.finish(); } }.start(); } }

应用程序的Log的控制

public class Logger {  
private static final int VERBOSE=1; 
private static final int DEBUG=2; 
private static final int INFO=3; 
private static final int WARN=4; 
private static final int ERROR=5; 
private static int LOGLEVEL=4;  
public static void v(String tag,String msg){ 
if(VERBOSE>LOGLEVEL){ Log.v(tag, msg); } } 
public static void d(String tag,String msg){ 
if(DEBUG>LOGLEVEL){
 Log.d(tag, msg); } }
 public static void i(String tag,String msg){ 
if(INFO>LOGLEVEL){ 
Log.i(tag, msg); } } 
public static void w(String tag,String msg){
 if(WARN>LOGLEVEL){ 
Log.w(tag, msg); } } 
public static void e(String tag,String msg){ 
if(ERROR>LOGLEVEL){ 
Log.e(tag, msg); } } }

MD5加密一个字符串得到哈希值

public class MD5Utils { 
/** * 采用md5加密算法，不可逆 * @param text * @return */ 
public static String encode(String text){  try { 
MessageDigest digest=MessageDigest.getInstance("md5");  
byte[] result=digest.digest(text.getBytes()); 
StringBuffer sb=new StringBuffer(); 
for(byte b:result){ 
String hex=Integer.toHexString(b&0xff)+2; 
if(hex.length()==1){ 
sb.append("0"); } 
sb.append(hex); } 
return sb.toString();
 } catch (NoSuchAlgorithmException e) {
 e.printStackTrace();
return ""; } } 
}

获取手机进程的相关信息（进程的总数、内存可用，总空间）

public class ProcessInfoUtils { 
/** * 获取系统进程的总数 * @return */ 
public static int getRunningProcessCount(Context context){ 
/* * 获取进程管理器 */ 
ActivityManager am=(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
 //返回正在运行进程的集合 
List<RunningAppProcessInfo>infos= am.getRunningAppProcesses(); 
return infos.size();  } 
/** * 获取系统进程内存的可用空间 * @return * @param context 上下文，获得可用内存 */ 
public static long getAvialRam(Context context){ 
/* * 获取进程管理器 */ 
ActivityManager am=(ActivityManager) 
context.getSystemService(Context.ACTIVITY_SERVICE); 
MemoryInfo outInfo=new MemoryInfo(); 
am.getMemoryInfo(outInfo); 
return outInfo.availMem;  } /** * 获取系统进程内存的总空间 * @return * @param context 上下文，获得总空间 */ 
public static long getTotalRam(Context context){
 /* * 获取进程管理器 */ /*
ActivityManager am=(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); 
MemoryInfo outInfo=new MemoryInfo(); 
am.getMemoryInfo(outInfo);*/   
try { File file=new File("/proc/meminfo"); 
FileInputStream fis=new FileInputStream(file); 
BufferedReader br=new BufferedReader(new InputStreamReader(fis)); String line=br.readLine(); 
StringBuffer sb=new StringBuffer(); 
for(char c :line.toCharArray()){ if(c>='0' && c<='9'){ 
sb.append(c); } }
 //返回的是字节 
return Long.parseLong(sb.toString())*1024; } 
catch (Exception e) { e.printStackTrace(); 
 return 0; } } }

判断系统的服务是否在后台运行

public class ServicerUtils {
 /** * 判断系统的服务是否在后台运行 */
 public static boolean isServiceRunning(Context context,String StringName){ //获取进程和服务的管理器 
ActivityManager am=(ActivityManager) 
context.getSystemService(Context.ACTIVITY_SERVICE); 
List<RunningServiceInfo> infos=am.getRunningServices(1000);
 for(ActivityManager.RunningServiceInfo info:infos){ 
String className=info.service.getClassName(); //System.out.println(className);
 if(StringName.equals(className)){ return true; } } 
return false; } }

功能是把一个流对象转换成字符串对象解析成功则返回值为字符串，不成功则为null

public class StreamUtils { 
public static String readStream(InputStream is){  
try { ByteArrayOutputStream baos=new ByteArrayOutputStream(); 
byte []buffer=new byte[1024]; 
int len=0; 
while((len=is.read(buffer))!=-1){ 
baos.write(buffer, 0, len);  }
 is.close();
 return baos.toString(); } 
catch (IOException e) { 
e.printStackTrace();
 return null; }  }   }

一个任意线程弹吐司的工具类

public class ToastUtils {  
/* *可以在任意线程（包括主线程和子线程）中更新Ui  * @param activity 上下文 * @param text 文本 *  */ 
public static void show(final Activity activity,final String text){ 
if("main".equals(Thread.currentThread().getName())){ 
Toast.makeText(activity, text, 0).show(); }
else{ activity.runOnUiThread(new Runnable(){ 
public void run() { 
Toast.makeText(activity, text, 0).show(); }; });  
} }
  /**  * 可以在任意线程（包括主线程和子线程）中更新UI *  * @param activity 上下文 * @param text 文本 * @param len 时长 */ 
public static void show(final Activity activity,final String text,final int len){
 if("main".equals(Thread.currentThread().getName())){ 
Toast.makeText(activity, text, len).show(); 
}else{ activity.runOnUiThread(new Runnable(){ 
public void run() { 
Toast.makeText(activity, text, len).show(); }; }); 
 } } }

拷贝资产目录下的数据库到Android系统下

 private void copyDB(final String name) { /* * 数据库多时可能耗时 */ new Thread(){ 
public void run() {
 File file=new File(getFilesDir(),name); 
if(file.exists()&&file.length()>0){ 
System.out.println("数据库已经加载过，无需在加载！"); 
}else{  try { 
InputStream is=getAssets().open(name); 
FileOutputStream fos=new FileOutputStream(file);
 byte[] buffer=new byte[1024]; 
int len=-1; 
while((len=is.read(buffer))!=-1){ 
fos.write(buffer, 0, len); }
is.close(); fos.close();  }
catch (Exception e) { 
e.printStackTrace(); } } }; }.start(); }