一世 我们知道。android程序存储器通常被限制16M。当然，24M的，和android程序存储器分为2部分：native和dalvik。dalvik 就是我们寻常说的java堆。我们创建的对象是在这里面分配的，而bitmap是直接在native上分配的，对于内存的限制是 native+dalvik 不能超过最大限制。

1.单个app 内存大小限制

  1. ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  2. activityManager.getMemoryClass();

2."/proc/meminfo"  系统内存信息文件【整个系统的内存情况】

Android获取手机总内存和可用内存

“/proc/meminfo”解析

3.ActivityManager.MemoryInfo【整个系统】

availMem         剩余内存

threshold         临界值 【超过次值就開始杀死后台服务和没有关联的进程】

lowMemory     低内存状态

4.android.os.Debug

getNativeHeapFreeSize()

getNativeHeapAllocatedSize()

getNativeHeapSize()

5.android.os.Debug.MemoryInfo【当前进程的内存情况】



6.Runtime



totalMemory()


freeMemory()

maxMemory()

7.VMRuntime

getTargetHeapUtilization()

getMinimumHeapSize()

getExternalBytesAllocated()   应该是外部分配的内存Native内存

8.GC_EXTERNAL_ALLOC
freed 与 GC_EXPLICIT freed 是什么?

系统GC释放的内存提示


一般在LOG里面显演示样例如以下：
09-28 17:16:37.543: DEBUG/dalvikvm(21466): GC_EXTERNAL_ALLOC freed 390 objects /
45656 bytes in 50ms

09-28 17:16:40.513: DEBUG/dalvikvm(3267): GC_EXPLICIT freed 4501 objects / 251624 bytes in 67ms

EXPLICIT：Free的内存是VM中java使用的内存
即 heap mem

EXTERNA：Free的内存是VM中通过JNI的Native类中的malloc分配的内存
比如 Bitmap 和一些 Cursor

在Davilk中，给一个程序分配的内存依据机型厂商的不同，而不同。如今的大部分的是32M了。而在VM内部会把这些内存分成java使用的内存和 Native使用的内存，它们之间是不能共享的。就是说当你的Native内存用完了。如今Java又有空暇的内存。这时Native会又一次像VM申请，而不是直接使用java的。

比如上边的样例

explicit 3411K/6663K

external 24870K/26260K

假设这时须要创建一个2M的

Bitmap，

Native现有内存26260-24870=1390K<2048k,因此他就会向Vm申请内存，尽管java空暇的内存是

6663-3411=3252>2048,但这部分内存Native是不能使用。

可是你如今去申请2M的Native内存，VM会告诉你无法分配的，由于如今已使用的内存已经接近峰值了32M(26260+6663=32923 )，所以如今就会成force close 报OOM。

所以如今我们要检查我们的native内存的使用情况来避免OOM。

ps: http://stackoverflow.com/questions/2298208/how-to-discover-memory-usage-of-my-application-in-android#2299813


三、通过Android系统提供的Runtime类，运行adb 命令(top,procrank,ps...等命令)查询

内存耗用：VSS/RSS/PSS/USS

Terms

? VSS - Virtual Set Size 虚拟耗用内存（包括共享库占用的内存）

?

RSS - Resident Set Size 实际使用物理内存（包括共享库占用的内存）

? PSS - Proportional Set Size 实际使用的物理内存（比例分配共享库占用的内存）

? USS - Unique Set Size 进程独自占用的物理内存（不包括共享库占用的内存）

一般来说内存占用大小有例如以下规律：VSS >= RSS >= PSS >= USS

查看每一个进程及其内存状况

	private void getRunningAppProcessInfo() {

		mActivityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);

		// 获得系统里正在执行的全部进程

		List<RunningAppProcessInfo> runningAppProcessesList = mActivityManager

				.getRunningAppProcesses();

		for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcessesList) {

			// 进程ID号

			int pid = runningAppProcessInfo.pid;

			// 用户ID

			int uid = runningAppProcessInfo.uid;

			// 进程名

			String processName = runningAppProcessInfo.processName;

			// 占用的内存

			int[] pids = new int[] { pid };

			Debug.MemoryInfo[] memoryInfo = mActivityManager

					.getProcessMemoryInfo(pids);

			int memorySize = memoryInfo[0].dalvikPrivateDirty;

			st = st + "processName=" + processName + ",pid=" + pid + ",uid="

					+ uid + ",memorySize=" + memorySize + "kb" + "\n";

			System.out.println("processName=" + processName + ",pid=" + pid

					+ ",uid=" + uid + ",memorySize=" + memorySize + "kb");

		}

	}

查看总内存：

	public long getmem_TOLAL() {

		long mTotal;

		// /proc/meminfo读出的内核信息进行解释

		String path = "/proc/meminfo";

		String content = null;

		BufferedReader br = null;

		try {

			br = new BufferedReader(new FileReader(path), 8);

			String line;

			if ((line = br.readLine()) != null) {

				content = line;

			}

		} catch (FileNotFoundException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		} finally {

			if (br != null) {

				try {

					br.close();

				} catch (IOException e) {

					e.printStackTrace();

				}

			}

		}

		// beginIndex

		int begin = content.indexOf(':');

		// endIndex

		int end = content.indexOf('k');

		// 截取字符串信息

		content = content.substring(begin + 1, end).trim();

		mTotal = Integer.parseInt(content);

		return mTotal;

	}

查看内存信息（该api较新）：

	public long getmem_UNUSED(Context mContext) {

		long MEM_UNUSED;

		// 得到ActivityManager

		ActivityManager am = (ActivityManager) mContext

				.getSystemService(Context.ACTIVITY_SERVICE);

		// 创建ActivityManager.MemoryInfo对象

		ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();

		am.getMemoryInfo(mi);

		textView3.setText("totalMen:" + mi.totalMem / 1024 + "\n"

				+ "threshold:" + mi.threshold / 1024 + "\n" + "availMem:"

				+ mi.availMem / 1024 + "\n");

		// 取得剩余的内存空间

		MEM_UNUSED = mi.availMem / 1024;

		return MEM_UNUSED;

	}

查看app内存：

	ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);

	int i=manager.getMemoryClass();

	textView.setText("\n"+"app:"+i);
像Linux这样的现代操作系统的内存使用是非常复杂的。因此非常难准确的知道你的应用程序使用了好多内存。

查看内存使用的方式有非常多种。可是各个方式查看到的结果可能会有微略不同。
方式一，Running
services
通过手机上Running services的Activity查看，能够通过Setting->Applications->Running services进。
关于Running services的具体内容请參考《Android中使用"running
services"查看service进程内存》
方式二，使用ActivityManager的getMemoryInfo(ActivityManager.MemoryInfo outInfo)
ActivityManager.getMemoryInfo()主要是用于得到当前系统剩余内存的及推断是否处于低内存执行。

实例1：
    private void displayBriefMemory() {    
        final ActivityManager activityManager = (ActivityManager)
getSystemService(ACTIVITY_SERVICE);    
        ActivityManager.MemoryInfo info = new ActivityManager.MemoryInfo();   
        activityManager.getMemoryInfo(info);    
        Log.i(tag,"系统剩余内存:"+(info.availMem >>
10)+"k");   
        Log.i(tag,"系统是否处于低内存执行："+info.lowMemory);
        Log.i(tag,"当系统剩余内存低于"+info.threshold+"时就看成低内存执行");
    } 
ActivityManager.getMemoryInfo()是用ActivityManager.MemoryInfo返回结果，而不是Debug.MemoryInfo。他们不一样的。

ActivityManager.MemoryInfo仅仅有三个Field:
availMem:表示系统剩余内存
lowMemory：它是boolean值，表示系统是否处于低内存执行
hreshold：它表示当系统剩余内存低于好多时就看成低内存执行
方式三。在代码中使用Debug的getMemoryInfo(Debug.MemoryInfo
memoryInfo)或ActivityManager的MemoryInfo[] getProcessMemoryInfo(int[]
pids)
该方式得到的MemoryInfo所描写叙述的内存使用情况比較具体.数据的单位是KＢ.
MemoryInfo的Field例如以下
dalvikPrivateDirty： The
private dirty pages used by dalvik。
dalvikPss ：The proportional
set size for dalvik.
dalvikSharedDirty ：The
shared dirty pages used by dalvik.
nativePrivateDirty ：The private dirty
pages used by the native heap.
nativePss ：The proportional set size for
the native heap.
nativeSharedDirty ：The
shared dirty pages used by the native heap.
otherPrivateDirty ：The private dirty pages
used by everything else.
otherPss ：The proportional
set size for everything else.
otherSharedDirty ：The
shared dirty pages used by everything else.
Android和Linux一样有大量内存在进程之间进程共享。

某个进程准确的使用好多内存实际上是非常难统计的。

由于有paging out to disk（换页）。所以假设你把全部映射到进程的内存相加，它可能大于你的内存的实际物理大小。
dalvik：是指dalvik所使用的内存。

native：是被native堆使用的内存。

应该指使用C\C++在堆上分配的内存。

other:是指除dalvik和native使用的内存。可是详细是指什么呢？至少包含在C\C++分配的非堆内存，比方分配在栈上的内存。puzlle!
private:是指私有的。非共享的。

share:是指共享的内存。
PSS：实际使用的物理内存（比例分配共享库占用的内存）
Pss：它是把共享内存依据一定比例分摊到共享它的各个进程来计算所得到进程使用内存。

网上又说是比例分配共享库占用的内存。那么至于这里的共享是否仅仅是库的共享，还是不清楚。

 PrivateDirty：它是指非共享的，又不能换页出去（can
not be paged to disk ）的内存的大小。比方Linux为了提高分配内存速度而缓冲的小对象，即使你的进程结束，该内存也不会释放掉。它仅仅是又又一次回到缓冲中而已。
SharedDirty:參照PrivateDirty我觉得它应该是指共享的，又不能换页出去（can
not be paged to disk ）的内存的大小。比方Linux为了提高分配内存速度而缓冲的小对象，即使全部共享它的进程结束，该内存也不会释放掉，它仅仅是又又一次回到缓冲中而已。
详细代码请參考实例1
注意１：MemoryInfo所描写叙述的内存使用情况都能够通过命令adb
shell "dumpsys meminfo %curProcessName%" 得到。

注意２：假设想在代码中同一时候得到多个进程的内存使用或非本进程的内存使用情况请使用ActivityManager的MemoryInfo[]
getProcessMemoryInfo(int[] pids)，
否则Debug的getMemoryInfo(Debug.MemoryInfo
memoryInfo)就能够了。

注意３：能够通过ActivityManager的List<<a
href="http://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo.html" rel="nofollow" style="color: rgb(207, 121, 28); text-decoration: none;">ActivityManager.RunningAppProcessInfo> getRunningAppProcesses()得到当前全部执行的进程信息。

ActivityManager.RunningAppProcessInfo中就有进程的id。名字以及该进程包含的全部apk包名列表等。
注意4：数据的单位是KB.
方式4、使用Debug的getNativeHeapSize
()。getNativeHeapAllocatedSize ()。getNativeHeapFreeSize ()方法。

该方式仅仅能得到Native堆的内存大概情况，数据单位为字节。
static
long getNativeHeapAllocatedSize() 
Returns the amount
of allocated memory in the native heap.
返回的是当前进程navtive堆中已使用的内存大小

static long getNativeHeapFreeSize()

Returns the amount of free memory in the native heap.
返回的是当前进程navtive堆中已经剩余的内存大小

static long getNativeHeapSize()

Returns the size of the native heap.
返回的是当前进程navtive堆本身总的内存大小
演示样例代码：
          Log.i(tag,"NativeHeapSizeTotal:"+(Debug.getNativeHeapSize()>>10));
          Log.i(tag,"NativeAllocatedHeapSize:"+(Debug.getNativeHeapAllocatedSize()>>10));
          Log.i(tag,"NativeAllocatedFree:"+(Debug.getNativeHeapFreeSize()>>10));
注意：DEBUG中竟然没有与上面相相应的关于dalvik的函数。

方式五、使用dumpsys
meminfo命令。
我们能够在adb shell 中执行dumpsys
meminfo命令来得到进程的内存信息。

在该命令的后面要加上进程的名字。以确定是哪个进程。

比方"adb
shell dumpsys meminfo com.teleca.robin.test" 将得到com.teleca.robin.test进程使用的内存的信息: 
Applications Memory Usage (kB):
Uptime: 12101826 Realtime: 270857936

** MEMINFO in pid 3407 [com.teleca.robin.test] **
                    native   dalvik    other    total
            size:
    3456     3139      N/A     6595
       allocated:
    3432     2823      N/A     6255
            free:
      23      316      N/A      339
           (Pss):
     724     1101     1070     2895
  (shared dirty):
    1584     4540     1668     7792
    (priv dirty):
     644      608      688     1940
 
 Objects
           Views:        0        ViewRoots:        0
     AppContexts:        0       Activities:        0
          Assets:        3    AssetManagers:        3
   Local Binders:        5    Proxy Binders:       11
Death Recipients:        0
 OpenSSL Sockets:        0
 
 SQL
            heap:        0       memoryUsed:        0
pageCacheOverflo:        0  largestMemAlloc:        0
 
 
 Asset Allocations
    zip:/data/app/com.teleca.robin.test-1.apk:/resources.arsc: 1K
 "size" 表示的是总内存大小（kb）。

, "allocated" 表示的是已使用了的内存大小（kb），, "free"表示的是剩余的内存大小（kb）, 很多其它的能够參照方式三和方式四中的描写叙述

如今已经有了自己主动提取汇总dumpsys
meminfo信息的工具，详细请參照《Android内存泄露利器（内存统计篇）》及其系列文章。
方式六、使用 "adb
shell procrank"命令
假设你想查看全部进程的内存使用情况。能够使用"adb
shell procrank"命令。命令返回将例如以下：
  PID      Vss      Rss      Pss      Uss  cmdline
  188   75832K   51628K   24824K   19028K  system_server
  308   50676K   26476K    9839K    6844K  system_server
 2834   35896K   31892K    9201K    6740K  com.sec.android.app.twlauncher
  265   28536K   28532K    7985K    5824K  com.android.phone
  100   29052K   29048K    7299K    4984K  zygote
  258   27128K   27124K    7067K    5248K  com.swype.android.inputmethod
  270   25820K   25816K    6752K    5420K  com.android.kineto
 1253   27004K   27000K    6489K    4880K  com.google.android.voicesearch
 2898   26620K   26616K    6204K    3408K  com.google.android.apps.maps:FriendService
  297   26180K   26176K    5886K    4548K  com.google.process.gapps
 3157   24140K   24136K    5191K    4272K  android.process.acore
 2854   23304K   23300K    4067K    2788K  com.android.vending
 3604   22844K   22840K    4036K    3060K  com.wssyncmldm
  592   23372K   23368K    3987K    2812K  com.google.android.googlequicksearchbox
 3000   22768K   22764K    3844K    2724K  com.tmobile.selfhelp
  101    8128K    8124K    3649K    2996K  /system/bin/mediaserver
 3473   21792K   21784K    3103K    2164K  com.android.providers.calendar
 3407   22092K   22088K    2982K    1980K  com.teleca.robin.test
 2840   21380K   21376K    2953K    1996K  com.sec.android.app.controlpanel
......................................................................................................................
关于VSS,RSS,PSS,USS的意义请參考《Android内存之VSS/RSS/PSS/USS》
注意1：这里的PSS和方式四PSS的total并不一致，有细微的区别。

为什么呢？这是由于procrank
命令和meminfo命令使用的内核机制不太一样，所以结果会有细微区别

注意2：这里的Uss 和方式四的Priv
Dirtyd的total差点儿相等.他们似乎表示的是同一个意义。

可是如今得到的关于它们的意义的解释却不太同样。难道这里Private的都是dirty(这里指不能换页)? Puzzle!

方式七、使用"adb
shell cat /proc/meminfo" 命令。
该方式仅仅能得出系统整个内存的大概使用情况。

MemTotal:         395144 kB 
MemFree:          184936 kB 
Buffers:             880 kB 
Cached:            84104 kB 
SwapCached:            0 kB 
................................................................................................
MemTotal ：可供系统和用户使用的总内存大小 (它比实际的物理内存要小，由于还有些内存要用于radio,
DMA buffers, 等). 
MemFree：剩余的可用内存大小。这里该值比較大。实际上一般Android
system 的该值通常都非常小，由于我们尽量让进程都保持执行。这样会耗掉大量内存。
Cached: 这个是系统用于文件缓冲等的内存.
通常systems须要20MB 以避免bad paging states;。

当内存紧张时。the Android out of memory killer将杀死一些background进程。以避免他们消耗过多的cached
RAM ，当然假设下次再用到他们，就须要paging. 那么是说background进程的内存包括在该项中吗？

方式八，使用“adb shell ps -x”命令
该方式主要得到的是内存信息是VSIZE 和RSS。
USER     PID   PPID  VSIZE  RSS     WCHAN    PC
        NAME
.........................省略.................................
app_70    3407  100   267104 22056 ffffffff afd0eb18 S com.teleca.robin.test
(u:55, s:12)
app_7     3473  100   268780 21784 ffffffff afd0eb18 S com.android.providers.calendar (u:16, s:8)
radio     3487  100   267980 21140 ffffffff afd0eb18 S com.osp.app.signin (u:11, s:12)
system    3511  100   273232 22024 ffffffff afd0eb18 S com.android.settings (u:11, s:4)
app_15    3546  100   267900 20300 ffffffff afd0eb18 S com.sec.android.providers.drm (u:15, s:6)
app_59    3604  100   272028 22856 ffffffff afd0eb18 S com.wssyncmldm (u:231, s:54)
root      4528  2     0      0     c0141e4c 00000000 S flush-138:13
(u:0, s:0)
root      4701  152   676    336   c00a68c8 afd0e7cc S /system/bin/sh (u:0,
s:0)
root      4702  4701  820    340   00000000 afd0d8bc R ps (u:0, s:5)
VSZIE:意义临时不明。

VSS：请參考《Android内存之VSS/RSS/PSS/USS》
注意1：因为RSS的价值不是非常大。所以一般不用。
注意2：通过该命令提取RSS，已经有了工具，详细參照《Android内存泄露利器（RSS内存统计篇）》及其系列。
 

实例1

int cnt=0;

final static int kBufferMinSize=1000;

final static int kBufferMaxSize=2000;

StringBuffer strBuffer=new StringBuffer(kBufferMinSize);

StringBuffer strBuffer2=new StringBuffer(kBufferMinSize);

StringBuffer strBuffer3=new StringBuffer(kBufferMinSize);

StringBuffer strBufferNativePss=new StringBuffer(kBufferMinSize);

StringBuffer strBufferDalvikPss=new StringBuffer(kBufferMinSize);

StringBuffer strBufferOtherPss=new StringBuffer(kBufferMinSize);

Debug.MemoryInfo memoryInfo=new Debug.MemoryInfo();

final static String tag="robin";

void printMemory()

{

long totalMemory=Runtime.getRuntime().totalMemory();

long freeMemory=Runtime.getRuntime().freeMemory();

long usedMemory=(totalMemory-freeMemory)>>10;

totalMemory=totalMemory>>10;

freeMemory=freeMemory>>10;

if(strBuffer.length()>kBufferMaxSize)

{

strBuffer.delete(0,strBuffer.length());

strBuffer2.delete(0,strBuffer2.length());

strBuffer3.delete(0,strBuffer3.length());

strBufferNativePss.delete(0,strBufferNativePss.length());

strBufferDalvikPss.delete(0,strBufferDalvikPss.length());

}

strBuffer.append(usedMemory+",");

strBuffer2.append(totalMemory+",");

strBuffer3.append((Debug.getNativeHeapSize()>>10)+",");

Debug.getMemoryInfo(memoryInfo);

strBufferNativePss.append((memoryInfo.nativePss)+",");

strBufferDalvikPss.append((memoryInfo.dalvikPss)+",");

if(cnt++==0)

{

Log.i(tag,"usedMemory:"+strBuffer.toString());

Log.i(tag,"totalMemory:"+strBuffer2.toString());

Log.i(tag,"NativeHeapSize:"+strBuffer3.toString());

Log.i(tag,"Native PSS:"+strBufferNativePss.toString());

Log.i(tag,"Dalvik PSS:"+strBufferDalvikPss.toString());

}

}

注意。对于输出的内存信息日志，我们稍作编辑就能够用于在excel产中图表。比便更直观的进行分析。

版权声明：本文博主原创文章，博客，未经同意不得转载。

【Android先进】查看手机记忆库状态和应用方法的更多相关文章

  1. Android开发华为手机无法看log日志解决方法

    Android开发华为手机无法看log日志解决方法 上班的时候,由于开发工具由Eclipse改成Android Studio后,原本的华为手机突然无法查看崩溃日志了,大家都知道,若是无法查看日志要它毛 ...

  2. Android中activity保存数据和状态在哪个方法实现

    以前只知道在Activity销毁之前,要把数据保存在 onSaveInstanceState(Bundle)方法中,后来学习了别人的微博,学到了很多细节问题,所以整理了一下,希望能帮到大家. 如果看官 ...

  3. Android Studio 查看手机CPU信息

    在Android开发中,我们想要获取手机是什么CPU架构,可以通过下面方式: 1.进入adb 终端 adb shell 2.进入proc目录 cd /proc/ 3.查看cpu信息 cat cpuin ...

  4. Android 监听手机GPS打开状态

    转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/70854942 本文出自[赵彦军的博客] GPS_Presenter package ...

  5. 朝花夕拾-android 获取当前手机的内存卡状态和网络连接状态

    序言: 人的一生是一个选择的过程. 如果脚下只有一条路,只要一往无前即可,不用担心走错.即使是错也别无它法.然而人是不安分的,况且安于独木桥的行走,其目的地由于没有蜿蜒曲折去遮挡行路人的视线,一往无前 ...

  6. Android加载手机磁盘上的资源---decodeFile方法的使用

    一般在写Android程序时,通常会将图片资源放在/res/drawable/文件夹下,读取时,通过R.drawable.imageId即可读取图片内容,但用户在使用时,一般会想要读取存放在存储卡上的 ...

  7. Android下查看共享库依赖项

    Android下查看共享库依赖项 [时间:2017-02] [状态:Open] [关键词:android,共享库依赖项,so,ndk,objdump,readelf] 起因 近期在处理Android下 ...

  8. Android之监测手机网络状态的广播

    Android之监测手机网络状态的广播 Android 监控网络状态 Android利用广播监听设备网络连接(断网)的变化情况

  9. Android开发——监听Android手机的网络状态

    0. 前言 在Android开发中监听手机的网络状态是一个常见的功能,比如在没网的状态下进行提醒并引导用户打开网络设置,或者在非wifi状态下开启无图模式等等.因此本篇将网上的资料进行了整理总结,方便 ...

随机推荐

  1. GCC编译优化指南【作者：金步国】

    GCC编译优化指南[作者:金步国] GCC编译优化指南 作者:金步国 版权声明 本文作者是一位自由软件爱好者,所以本文虽然不是软件,但是本着 GPL 的精神发布.任何人都可以自由使用.转载.复制和再分 ...

  2. [Android学习笔记]jackson库的使用

    Jackson库一般用于序列化和反序列化操作,通常会涉及到的操作是: 1. Java Object -> Json String 2. Java Object -> Xml String ...

  3. Direct UI

    在界面开发中,眼下DirectUI是个热门的技术名称,由于众多的知名公司都是用DirectUI方式作出了非常炫丽的界面.而对于大多数熟悉Win32控件,熟悉MFC开发的开发者来说,我们应该做何选择? ...

  4. Android中特殊图形的生成样例

    import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Color; impor ...

  5. Oracle Cursor的使用

    When Oracle Database executes a SQL statement, it stores the result set and processing information i ...

  6. hdu4612（双连通缩点+树的直径）

    传送门:Warm up 题意:询问如何加一条边,使得剩下的桥的数目最少,输出数目. 分析:tarjan缩点后,重新建图得到一棵树,树上所有边都为桥,那么找出树的直径两个端点连上,必定减少的桥数量最多, ...

  7. c#抓取动态页面WebBrowser

    在ajax横行的年代,很多网页的内容都是动态加载的,而我们的小爬虫抓取的仅仅是web服务器返回给我们的html,这其中就 跳过了js加载的部分,也就是说爬虫抓取的网页是残缺的,不完整的,下面可以看下博 ...

  8. A Game of Thrones(10) - Jon

    Jon climbed the steps slowly, trying not to think that this might be the last time ever. Ghost padde ...

  9. PSD 学位涵义 　　Poor, Smart and Deep desire to become rich 的缩写，不是真正的学位认证，是对一种心理状态的形容，所谓PSD学位是形容那些贫穷，但是很聪明，很深…_●.×

    PSD 学位涵义 Poor, Smart and Deep desire to become rich 的缩写,不是真正的学位认证,是对一种心理状态的形容,所谓PSD学位是形容那些贫穷,但是很聪明,很 ...

  10. hdu 4747【线段树-成段更新】.cpp

    题意: 给出一个有n个数的数列,并定义mex(l, r)表示数列中第l个元素到第r个元素中第一个没有出现的最小非负整数. 求出这个数列中所有mex的值. 思路: 可以看出对于一个数列,mex(r, r ...