一 : 多图片少文字的网站首页如何做好SEO优化

　　在当下做网站都有一个统一的趋势，就是在视觉上给人有极大的冲击力，其实达到这样的目的很多时候都是使用优质的图片来辅助的。诸如游戏网站和提供艺术服务的企业官网等类型的网站就经常可以看到首页靠大量的图片来妆点。而大家都清楚的是搜索引擎是不能识别到图片上面的内容，当然也许在将来有这样的能力，但至少当下还没做到;大家也知道搜索引擎喜欢的是能快速加载并让自己顺利抓取数据，同时更加提倡增加用户体验。

　　我们之所以在一个首页放很多图片其实就是为了增加用户体验，满足用户的感官享受，比如我们需要表现出来的意思有时候非得用一些图片展示出来，甚至使用普通用户电脑里没有的字体来描述，也一般采用把文字写在图片里边。下面我就从几个方面更加详细的谈谈我个人的一些看法。

　　第一，加ALT、切图等常规优化方式。这个大家也清楚，因为搜索引擎不能抓取图片上的内容，但可以识别图片的ALT信息，而我们把需要给搜索引擎看的文字内容写在ALT信息中也成了大家常用的做法了，也正是因为这样我这里就不必多说了。至于切图等方式就是为了在不影响整体视觉情况下减小网页总体积和请求数提升网站加载速度，而这不管是对用户还是搜索引擎来说都是非常好的。除此之外使用更加优质的服务器也算是一种很好的SEO优化方式。

　　第二，给搜索引擎和用户不同的东西。这种方式其实我是从某个开源网站程序中得到的灵感，大家都知道启用伪静态是为了让搜索引擎更好地收录，当然目前来说搜索引擎已经解决了动态URL收录问题;而那个程序内置一个功能就是区分搜索引擎和用户，如果是搜索引擎就使用伪静态URL，而如果是自然用户就使用默认动态的URL，从而减轻服务器负载。而在这里我们也是同样的道理，比如我们的一些特别美观的字体只能写在图片上面，当然在CSS3中开始支持服务器字体，但那样处理不仅会让用户客户机首次访问的时候要下载对应的字体文件，这样影响速度，更重要的是很多用户的浏览器并不支持该新属性。而图片上的文字是给用户看的，搜索引擎是看不到的;因此我们得另外弄一个搜索引擎看得到用户看不到的就好了。那就是在图片的位置，加一个DIV，而在里面写上我们想给搜索引擎看到的内容，然后把相关的height设为0。这样就可以避免ALT信息有作弊嫌疑了，因为这样做也不影响用户的体验。

　　第三，使用TAB切换显示文字内容。在很多商城首页我们看到的基本上都是一些图片加上一个非常短的标题，而对于很多小企业的商城来说可能自己的商品是很少更新的，商城里面的一些文章却是频繁更新的，但是我们又发现不可能在商城首页像做门户网站一样到处放上很多文章聚合块，而通常只会有一块地方展现文章内容，这时候我们在这个有限大小的位置为了展示更多的文章信息，那么采用TAB切换技术就不失为一种明智的选择了，这样不管对用还是我们做SEO优化都是有帮助的。因为这样可以在不影响整体感觉的基础上增加展示的内容，当然这样会增加一点点代码，但跟随便一张图片相比那只是九牛一毛了。

　　第四，规范网页编码。其实这个也应归到第一种方式当中，也算是一种常规的处理方法，但之所以单独列出，就是因为在这样的多图片少文字的网页中本来天生就对SEO不是太好的，如果这时候连网页编码也是乱七八糟的，那不是雪上加霜了。比如我们在使用H标签的时候要非常谨慎，logo处使用了H1标签就不能在一个商品的标题上也使用H1标签了，这样就极大分散权重了。要知道规范的编码方式也是搜索引擎考察网页质量的一个方面哦。

　　这种网站本质上就是让用户看到更多具有视觉冲击的元素，就是我们通俗讲的很多装饰的东西，对于搜索引擎来说没有实在的文字信息，而当下搜索引擎最喜欢的依然是文字信息，而这时候我们得区别对待了，也就是创造让搜索引擎也能像用户那样看到的信息。当然我不得不提醒大家，必须有一个度，如果造了两者看到的很不一致的内容，那么反而被认为是为了做SEO而采取作弊措施。

　　本文来源卡七七游戏网转载请注明出处!

二 : android 开发如何做内存优化

网上看的一篇很好的文章;http://www.gforetell.com/?/question/id-111__uid-focus

不少人认为JAVA程序，因为有垃圾回收机制，应该没有内存泄露。[www.61k.com]其实如果我们一个程序中，已经不再使用某个对象，但是因为仍然有引用指向它，垃圾回收器就无法回收它，当然该对象占用的内存就无法被使用，这就造成了内存泄露。如果我们的java运行很久,而这种内存泄露不断的发生，最后就没内存可用了。当然java的，内存泄漏和C/C++是不一样的。如果java程序完全结束后，它所有的对象就都不可达了，系统就可以对他们进行垃圾回收，它的内存泄露仅仅限于它本身，而不会影响整个系统的。C/C++的内存泄露就比较糟糕了，它的内存泄露是系统级，即使该C/C++程序退出，它的泄露的内存也无法被系统回收，永远不可用了，除非重启机器。
Android的一个应用程序的内存泄露对别的应用程序影响不大。为了能够使得Android应用程序安全且快速的运行，Android的每个应用程序都会使用一个专有的Dalvik虚拟机实例来运行，它是由Zygote服务进程孵化出来的，也就是说每个应用程序都是在属于自己的进程中运行的。Android为不同类型的进程分配了不同的内存使用上限，如果程序在运行过程中出现了内存泄漏的而造成应用进程使用的内存超过了这个上限，则会被系统视为内存泄漏，从而被kill掉，这使得仅仅自己的进程被kill掉，而不会影响其他进程（如果是system_process等系统进程出问题的话，则会引起系统重启）。
一、引用没释放造成的内存泄露
1.1注册没取消造成的内存泄露
这种Android的内存泄露比纯java的内存泄露还要严重，因为其他一些Android程序可能引用我们的Anroid程序的对象（比如注册机制）。即使我们的Android程序已经结束了，但是别的引用程序仍然还有对我们的Android程序的某个对象的引用，泄露的内存依然不能被垃圾回收。
比如示例1:
假设我们希望在锁屏界面(LockScreen)中，监听系统中的电话服务以获取一些信息(如信号强度等)，则可以在LockScreen中定义一个PhoneStateListener的对象，同时将它注册到TelephonyManager服务中。对于LockScreen对象，当需要显示锁屏界面的时候就会创建一个LockScreen对象，而当锁屏界面消失的时候LockScreen对象就会被释放掉。
但是如果在释放LockScreen对象的时候忘记取消我们之前注册的PhoneStateListener对象，则会导致LockScreen无法被垃圾回收。如果不断的使锁屏界面显示和消失，则最终会由于大量的LockScreen对象没有办法被回收而引起OutOfMemory,使得system_process进程挂掉。
虽然有些系统程序，它本身好像是可以自动取消注册的（当然不及时），但是我们还是应该在我们的程序中明确的取消注册，程序结束时应该把所有的注册都取消掉。
1.2集合中对象没清理造成的内存泄露
我们通常把一些对象的引用加入到了集合中，当我们不需要该对象时，并没有把它的引用从集合中清理掉，这样这个集合就会越来越大。如果这个集合是static的话，那情况就更严重了。
二、资源对象没关闭造成的内存泄露
资源性对象比如（Cursor，File文件等）往往都用了一些缓冲，我们在不使用的时候，应该及时关闭它们，以便它们的缓冲及时回收内存。它们的缓冲不仅存在于java虚拟机内，还存在于java虚拟机外。如果我们仅仅是把它的引用设置为null,而不关闭它们，往往会造成内存泄露。因为有些资源性对象，比如SQLiteCursor（在析构函数finalize（）,如果我们没有关闭它，它自己会调close()关闭），如果我们没有关闭它，系统在回收它时也会关闭它，但是这样的效率太低了。因此对于资源性对象在不使用的时候，应该调用它的close()函数，将其关闭掉，然后才置为null.在我们的程序退出时一定要确保我们的资源性对象已经关闭。
程序中经常会进行查询数据库的操作，但是经常会有使用完毕Cursor后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会复现内存问题，这样就会给以后的测试和问题排查带来困难和风险。
三、一些不良代码成内存压力
有些代码并不造成内存泄露，但是它们，或是对没使用的内存没进行有效及时的释放，或是没有有效的利用已有的对象而是频繁的申请新内存，对内存的回收和分配造成很大影响的，容易迫使虚拟机不得不给该应用进程分配更多的内存，造成不必要的内存开支。
3.1，Bitmap没调用recycle()
Bitmap对象在不使用时,我们应该先调用recycle()释放内存，然后才它设置为null.虽然recycle()从源码上看，调用它应该能立即释放Bitmap的主要内存，但是测试结果显示它并没能立即释放内存。但是我它应该还是能大大的加速Bitmap的主要内存的释放。
3.2，构造Adapter时，没有使用缓存的 convertView
以构造ListView的BaseAdapter为例，在BaseAdapter中提共了方法：
public View getView(int position, View convertView, ViewGroup parent)来向ListView提供每一个item所需要的view对象。初始时ListView会从BaseAdapter中根据当前的屏幕布局实例化一定数量的view对象，同时ListView会将这些view对象缓存起来。当向上滚动ListView时，原先位于最上面的list item的view对象会被回收，然后被用来构造新出现的最下面的list item。这个构造过程就是由getView()方法完成的，getView()的第二个形参 View convertView就是被缓存起来的list item的view对象(初始化时缓存中没有view对象则convertView是null)。
由此可以看出，如果我们不去使用convertView，而是每次都在getView()中重新实例化一个View对象的话，即浪费时间，也造成内存垃圾，给垃圾回收增加压力，如果垃圾回收来不及的话，虚拟机将不得不给该应用进程分配更多的内存，造成不必要的内存开支。ListView回收list item的view对象的过程可以查看:
view plaincopy to clipboardprint?
android.widget.AbsListView.java --> void addScrapView(View scrap) 方法。

示例代码： 

1 public View getView(int position, View convertView, ViewGroup parent) { 2 3 View view = new Xxx(...); 4 5 ... ... 6 7 return view; 8 9 }

修正示例代码： 

Android内存管理

1 public View getView(int position, View convertView, ViewGroup parent) { 2 3 View view = null; 4 5 if (convertView != null) { 6 7 view = convertView; 8 9 populate(view, getItem(position)); 10 11 ... 12 13 } else { 14 15 view = new Xxx(...); 16 17 ... 18 19 } 20 21 return view; 22 23 }

概述：
在android的开发中，要时刻主要内存的分配和垃圾回收，因为系统为每一个dalvik虚拟机分配的内存是有限的，在google的G1中，分配的最大堆大小只有16M，后来的机器一般都为24M，实在是少的可怜。这样就需要我们在开发过程中要时刻注意。不要因为自己的代码问题而造成OOM错误。
JAVA的内存管理：
大家都知道，android应用层是由java开发的，android的davlik虚拟机与jvm也类似，只不过它是基于寄存器的。因此要了解android的内存管理就必须得了解java的内存分配和垃圾回收机制。
在java中，是通过new关键字来为对象分配内存的，而内存的释放是由垃圾收集器（GC）来回收的，工程师在开发的过程中，不需要显式的去管理内存。但是这样有可能在不知不觉中就会浪费了很多内存，最终导致java虚拟机花费很多时间去进行垃圾回收，更严重的是造成JVM的OOM。因此，java工程师还是有必要了解JAVA的内存分配和垃圾回收机制。

内存结构 file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-6926.png 上面这张图是JVM的结构图，它主要四个部分组成：Class Loader子系统和执行引擎，运行时方法区和本地方法区，我们主要来看下RUNTIME DATA AREA区，也就是我们常说的JVM内存。从图中可以看出，RUNTIMEDATA AREA区主要由5个部分组成： · Method Area:被装载的class的元信息存储在Method Area中，它是线程共享的 · Heap(堆)：一个java虚拟机实例中只存在一个堆空间，存放一些对象信息，它是线程共享的 · Java栈： java虚拟机直接对java栈进行两种操作，以帧为单位的压栈和出栈（非线程共享） · 程序计数器（非线程共享） · 本地方法栈（非线程共享） JVM的垃圾回收（GC） file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-12485.png JVM的垃圾原理是这样的，它把对象分为年轻代（Young）、年老代（Tenured）、持久代（Perm），对不同生命周期的对象使用不同的垃圾回收算法。 · 年轻代(Young) 年轻代分为三个区，一个eden区，两个Survivor区。程序中生成的大部分新的对象都在Eden区中，当Eden区满时，还存活的对象将被复制到其中一个Survivor区，当此Survivor区的对象占用空间满了时，此区存活的对象又被复制到另外一个Survivor区，当这个Survivor区也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制到年老代。 · 年老代（Tenured） 年老代存放的是上面年轻代复制过来的对象，也就是在年轻代中还存活的对象，并且区满了复制过来的。一般来说，年老代中的对象生命周期都比较长。 · 持久代（Perm） 用于存放静态的类和方法，持久代对垃圾回收没有显著的影响。 Android中内存泄露监测 在了解了JVM的内存管理后，我们再回过头来看看，在android中应该怎样来监测内存，从而看在应用中是否存在内存分配和垃圾回收问题而造成内存泄露情况。 在android中，有一个相对来说还不错的工具，可以用来监测内存是否存在泄露情况：DDMS—Heap file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-22715.png 使用方法比较简单： · 选择DDMS视图，并打开Devices视图和Heap视图 · 点击选择要监控的进程，比如：上图中我选择的是system_process · 选中Devices视图界面上的"update heap" 图标 · 点击Heap视图中的"Cause GC" 按钮（相当于向虚拟机发送了一次GC请求的操作） 在Heap视图中选择想要监控的Type，一般我们会观察dataobject的 total size的变化，正常情况下total size的值会稳定在一个有限的范围内，也就说程序中的代码良好，没有造成程序中的对象不被回收的情况。如果代码中存在没有释放对象引用的情况，那么data object的total size在每次GC之后都不会有明显的回落，随着操作次数的增加而total size也在不断的增加。（说明：选择好data object后，不断的操作应用，这样才可以看出total size的变化）。如果totalsize确实是在不断增加而没有回落，说明程序中有没有被释放的资源引用。那么我们应该怎么来定位呢？ Android中内存泄露定位 Mat(memory analyzer tools)是我们常用的用来定位内存泄露的工具，如果你使用ADT，并且安装了MAT的eclipse插件，你需要做的是进入DDMS视图的Devices视图： file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-2165.png 点击"dump HPROF file"按钮，然后使用MAT分析下载下来的文件。 file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-6565.png

 下面列出了存在的问题，点击detail进去，会列出详细的，可能会存在问题的代码：
file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-32625.png
file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-21158.png
关于MAT的使用可以参考：http://www.blogjava.net/rosen/ ... .html
这位兄弟写的比较详细。

总结

不管是java还是android，都应该了解内存分配和垃圾回收机制，工程师要做到写的代码中没有bad code很难，关键是在出现问题的时候该怎么去排查Android内存优化
一、 Android的内存机制
Android的程序由Java语言编写，所以Android的内存管理与Java的内存管理相似。程序员通过new为对象分配内存，所有对象在java堆内分配空间；然而对象的释放是由垃圾回收器来完成的。C／C++中的内存机制是“谁污染，谁治理”，java的就比较人性化了，给我们请了一个专门的清洁工（GC）。
那么GC怎么能够确认某一个对象是不是已经被废弃了呢？Java采用了有向图的原理。Java将引用关系考虑为图的有向边，有向边从引用者指向引用对象。线程对象可以作为有向图的起始顶点，该图就是从起始顶点开始的一棵树，根顶点可以到达的对象都是有效对象，GC不会回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意，该图为有向图)，那么我们认为这个(这些)对象不再被引用，可以被GC回收。
二、Android的内存溢出
Android的内存溢出是如何发生的?
Android的虚拟机是基于寄存器的Dalvik，它的最大堆大小一般是16M，有的机器为24M。因此我们所能利用的内存空间是有限的。如果我们的内存占用超过了一定的水平就会出现OutOfMemory的错误。
为什么会出现内存不够用的情况呢？我想原因主要有两个：

由于我们程序的失误，长期保持某些资源（如Context）的引用，造成内存泄露，资源造成得不到释放。

保存了多个耗用内存过大的对象（如Bitmap），造成内存超出限制。

三、万恶的static
static是Java中的一个关键字，当用它来修饰成员变量时，那么该变量就属于该类，而不是该类的实例。所以用static修饰的变量，它的生命周期是很长的，如果用它来引用一些资源耗费过多的实例（Context的情况最多），这时就要谨慎对待了。

1 public class ClassName { 2 3 private static Context mContext; 4 5 //省略 6 7 }

以上的代码是很危险的，如果将Activity赋值到么mContext的话。那么即使该Activity已经onDestroy，但是由于仍有对象保存它的引用，因此该Activity依然不会被释放。
我们举Android文档中的一个例子。

private static Drawable sBackground; @Override protected void onCreate(Bundle state) { super.onCreate(state); TextView label = new TextView(this); label.setText("Leaks are bad"); if (sBackground == null) { sBackground = getDrawable(R.drawable.large_bitmap); } label.setBackgroundDrawable(sBackground); setContentView(label); }

sBackground是一个静态的变量，但是我们发现，我们并没有显式的保存Contex的引用，但是，当Drawable与View连接之后，Drawable就将View设置为一个回调，由于View中是包含Context的引用的，所以，实际上我们依然保存了Context的引用。这个引用链如下：
Drawable->TextView->Context
所以，最终该Context也没有得到释放，发生了内存泄露。
如何才能有效的避免这种引用的发生呢？

应该尽量避免static成员变量引用资源耗费过多的实例，比如Context。

Context尽量使用Application Context，因为Application的Context的生命周期比较长，引用它不会出现内存泄露的问题。

使用WeakReference代替强引用。比如可以使用WeakReference<Context> mContextRef;

该部分的详细内容也可以参考Android文档中Article部分。
四、都是线程惹的祸
线程也是造成内存泄露的一个重要的源头。线程产生内存泄露的主要原因在于线程生命周期的不可控。我们来考虑下面一段代码。

1 public class MyActivity extends Activity { 2 3 @Override 4 5 public void onCreate(Bundle savedInstanceState) { 6 7 super.onCreate(savedInstanceState); 8 9 setContentView(R.layout.main); 10 11 new MyThread().start(); 12 13 } 14 15 16 private class MyThread extends Thread{ 17 18 @Override 19 20 public void run() { 21 22 super.run(); 23 24 //do somthing 25 26 } 27 28 } 29 30 }

这段代码很平常也很简单，是我们经常使用的形式。我们思考一个问题：假设MyThread的run函数是一个很费时的操作，当我们开启该线程后，将设备的横屏变为了竖屏，一般情况下当屏幕转换时会重新创建Activity，按照我们的想法，老的Activity应该会被销毁才对，然而事实上并非如此。
由于我们的线程是Activity的内部类，所以MyThread中保存了Activity的一个引用，当MyThread的run函数没有结束时，MyThread是不会被销毁的，因此它所引用的老的Activity也不会被销毁，因此就出现了内存泄露的问题。
file:///C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/ksohtml/wps_clip_image-6439.png
有些人喜欢用Android提供的AsyncTask，但事实上AsyncTask的问题更加严重，Thread只有在run函数不结束时才出现这种内存泄露问题，然而AsyncTask内部的实现机制是运用了ThreadPoolExcutor,该类产生的Thread对象的生命周期是不确定的，是应用程序无法控制的，因此如果AsyncTask作为Activity的内部类，就更容易出现内存泄露的问题。
这种线程导致的内存泄露问题应该如何解决呢？

将线程的内部类，改为静态内部类。

在线程内部采用弱引用保存Context引用。

解决的模型如下：

1 public abstract class WeakAsyncTask<Params, Progress, Result, WeakTarget> extends 2 AsyncTask<Params, Progress, Result> { 3 protected WeakReference<WeakTarget> mTarget; 4 5 public WeakAsyncTask(WeakTarget target) { 6 mTarget = new WeakReference<WeakTarget>(target); 7 } 8 9 /** {@inheritDoc} */ 10 @Override 11 protected final void onPreExecute() { 12 final WeakTarget target = mTarget.get(); 13 if (target != null) { 14 this.onPreExecute(target); 15 } 16 } 17 18 /** {@inheritDoc} */ 19 @Override 20 protected final Result doInBackground(Params... params) { 21 final WeakTarget target = mTarget.get(); 22 if (target != null) { 23 return this.doInBackground(target, params); 24 } else { 25 return null; 26 } 27 } 28 29 /** {@inheritDoc} */ 30 @Override 31 protected final void onPostExecute(Result result) { 32 final WeakTarget target = mTarget.get(); 33 if (target != null) { 34 this.onPostExecute(target, result); 35 } 36 } 37 38 protected void onPreExecute(WeakTarget target) { 39 // No default action 40 } 41 42 protected abstract Result doInBackground(WeakTarget target, Params... params); 43 44 protected void onPostExecute(WeakTarget target, Result result) { 45 // No default action 46 } 47 }

事实上，线程的问题并不仅仅在于内存泄露，还会带来一些灾难性的问题。由于本文讨论的是内存问题，所以在此不做讨论。

由于51cto不让我一次传完，说我的字数太多了，所以分开传了。
五、超级大胖子Bitmap
可以说出现OutOfMemory问题的绝大多数人，都是因为Bitmap的问题。因为Bitmap占用的内存实在是太多了，它是一个“超级大胖子”，特别是分辨率大的图片，如果要显示多张那问题就更显著了。
如何解决Bitmap带给我们的内存问题？

及时的销毁。

虽然，系统能够确认Bitmap分配的内存最终会被销毁，但是由于它占用的内存过多，所以很可能会超过java堆的限制。因此，在用完Bitmap时，要及时的recycle掉。recycle并不能确定立即就会将Bitmap释放掉，但是会给虚拟机一个暗示：“该图片可以释放了”。

设置一定的采样率。

有时候，我们要显示的区域很小，没有必要将整个图片都加载出来，而只需要记载一个缩小过的图片，这时候可以设置一定的采样率，那么就可以大大减小占用的内存。如下面的代码：

1 private ImageView preview;  2 3 4 BitmapFactory.Options options = new BitmapFactory.Options();  5 6 7 options.inSampleSize = 2;//图片宽高都为原来的二分之一，即图片为原来的四分之一  8 9 Bitmap bitmap = BitmapFactory.decodeStream(cr.openInputStream(uri), null, options); 10 11 12 preview.setImageBitmap(bitmap);

巧妙的运用软引用（SoftRefrence）

有些时候，我们使用Bitmap后没有保留对它的引用，因此就无法调用Recycle函数。这时候巧妙的运用软引用，可以使Bitmap在内存快不足时得到有效的释放。如下例：
/**本例子为博主随手一写，来说明用法，并未验证*/ 

1 private class MyAdapter extends BaseAdapter { 2 3 private ArrayList<SoftReference<Bitmap>> mBitmapRefs = new ArrayList<SoftReference<Bitmap>>(); 4 private ArrayList<Value> mValues; 5 private Context mContext; 6 private LayoutInflater mInflater; 7 8 MyAdapter(Context context, ArrayList<Value> values) { 9 mContext = context; 10 mValues = values; 11 mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); 12 } 13 public int getCount() { 14 return mValues.size(); 15 } 16 public Object getItem(int i) { 17 return mValues.get(i); 18 } 19 20 public long getItemId(int i) { 21 return i; 22 } 23 24 public View getView(int i, View view, ViewGroup viewGroup) { 25 View newView = null; 26 if(view != null) { 27 newView = view; 28 } else { 29 newView =(View)mInflater.inflate(R.layout.image_view, false); 30 } 31 32 Bitmap bitmap = BitmapFactory.decodeFile(mValues.get(i).fileName); 33 mBitmapRefs.add(new SoftReference<Bitmap>(bitmap)); //此处加入ArrayList 34 ((ImageView)newView).setImageBitmap(bitmap); 35 36 return newView; 37 } 38 }

 六、行踪诡异的Cursor
Cursor是Android查询数据后得到的一个管理数据集合的类，正常情况下，如果查询得到的数据量较小时不会有内存问题，而且虚拟机能够保证Cusor最终会被释放掉。
然而如果Cursor的数据量特表大，特别是如果里面有Blob信息时，应该保证Cursor占用的内存被及时的释放掉，而不是等待GC来处理。并且Android明显是倾向于编程者手动的将Cursor close掉，因为在源代码中我们发现，如果等到垃圾回收器来回收时，会给用户以错误提示。
所以我们使用Cursor的方式一般如下：

1 Cursor cursor = null; 2 try { 3 cursor = mContext.getContentResolver().query(uri,null, null,null,null); 4 if(cursor != null) { 5 cursor.moveToFirst(); 6 //do something 7 } 8 } catch (Exception e) { 9 e.printStackTrace(); 10 } finally { 11 if (cursor != null) { 12 cursor.close(); 13 } 14 }

有一种情况下，我们不能直接将Cursor关闭掉，这就是在CursorAdapter中应用的情况，但是注意，CursorAdapter在Acivity结束时并没有自动的将Cursor关闭掉，因此，你需要在onDestroy函数中，手动关闭。

1 protected void onDestroy() { 2 3 if (mAdapter != null && mAdapter.getCurosr() != null) { 4 5 mAdapter.getCursor().close(); 6 7 } 8 9 super.onDestroy(); 10 11 }

CursorAdapter中的changeCursor函数，会将原来的Cursor释放掉，并替换为新的Cursor，所以你不用担心原来的Cursor没有被关闭。
你可能会想到使用Activity的managedQuery来生成Cursor，这样Cursor就会与Acitivity的生命周期一致了，多么完美的解决方法！然而事实上managedQuery也有很大的局限性。
managedQuery生成的Cursor必须确保不会被替换，因为可能很多程序事实上查询条件都是不确定的，因此我们经常会用新查询的Cursor来替换掉原先的Cursor。因此这种方法适用范围也是很小。
七、其它要说的。
其实，要减小内存的使用，其实还有很多方法和要求。比如不要使用整张整张的图，尽量使用9path图片。Adapter要使用convertView等等，好多细节都可以节省内存。这些都需要我们去挖掘，谁叫Android的内存不给力来着。

三 : SEO优化如何做好文章更新

“内容为王，外链为皇”。内容是网站的灵魂，对于网站是非常重要的。网站没有内容就没有可读性，想要增加网站流量，增加用户体验，只有丰富网站内容，运用SEO操作手法来提高网站吸引度。

网站内容是数量还是质量？

SEO优化是需要坚持的，需要每天更新网站内容，搜索引擎更喜欢原创性文章，但对于每天需要的更新文章，很多站长都是为了轻松省事，利用采集工具采集文章。虽然省事省力，但文章的质量难以得到保证，得不到搜索引擎蜘蛛的信任，甚至引起反感。下面就介绍采集的弊端：

一、文章重复高很难收录

随着百度不断的算法更新，文章是否原创，现在可以比较轻松的判断。百度对于重复率高的文章是直接不收录的，或者就算收录也会剔除，特别不喜欢权重低的网站，采集别人的文章，收录会很差！！有些网站转载收录的不错，那是因为对方网站的权重比较高！！！

二、文章可读性很差

采集的文章不仅让搜索引擎反感，而且对于用户体验也是很差的，跳出率会很高。网站内容不丰富，没有新鲜感，得不到用户喜爱，别人进入你的网站，不能够留住访客。

三、网站权重不能保证

被采集的网站有很好的关键字排名，从而可以有很高的权重，甚至可以达到秒录的效果！！但只要疏于更新，就会很容易掉下去了！！随着百度算法的不断更新，会让关键字排名波动很大，所以想要长久的关键字排名，只能不断的更新文章和加强外链来维持。

四、网站收录不稳定

站长都很关注网站内页收录，无论新站还是新站，收录良好，带来更多的长尾关键词的排名。从而增加更多的流量！！虽然采集的网站收录可以非常庞大，但其实是昙花一现，今天收录几万，明天就可能几千，收录很容易减少！！

不能随便什么网站都去采集

想让自己的网站有比较好的收录，就不能什么网站都去采集，很多垃圾网站充斥着互联网内，采集垃圾文章对于网站收录无异于噩梦，很容易被百度K掉。希望利用自己的网站盈利，提高网站的流量，需要良好的方法与心态，踏实的做好每一步，才会有好的收获。

怎么样才能提升网站的内容质量？

网站构建以后，应该坚持每天更新原创性文章，并且是手动更新网站的数据，尽量不用工具作为跟新数据，只能作为辅助功能来使用。新站内容更新内容，质量比数量更重要，每天哪怕只能写一篇原创，也比每天更新十几篇伪原创质量不好的文章要好很多。想让网站长期发展，前期必须考原创性文章支撑，原创性文章，百度搜索引擎是非常喜欢的！！虽然百度有个考察期，但对于以后网站有个比较好的指标！！

网站的质量 是非常重要的，不要去采集文章，虽然省时省力，但长期来说，对于网站相当有害，宁愿每天原创性文章较少，但可以保证网站收录！！踏实的走好每一步，一布一个脚印，一分耕耘一分成果！！！

四 : 如何利用免费博客平台做SEO优化

常见免费博客平台：

新浪博客、搜狐博客、和讯博客、凤凰博客、天涯博客、百度空间、博客大巴、企业博客，博客中国、csdn博客。(www.61k.com］

如何培养博客?

我们知道博客都是靠养的，一开始博客收录朝阳网文章可能没那么快，所以前期在养博客的时候尽量不要带一些链接或者锚文本。等博客慢慢养起来以后，收录稳定以后，就可以加链接了!而博客目前来说新浪的效果可能会好一些，科技类的博客其实也有很多，我知道的csdn博客是秒收的。大家可以注册下试试。

博客如何优化?

再培养博客的时候，最好是选择长尾关键词，再写作的时候，可以把要优化的关键词加粗，现在新浪博客这块还可以增加相关文章，这样也是非常有利于优化的可以提高相关性。同时，大家在建目录的时候一定要注意，如果你这个目录是网站建设的，那你写的文章标题最好带有网站建设。这样可以增加博客目录的权重。其实跟我们网站是一样的，目录下面多发一些相关的文章，就能带动目录的权重了。

博客链轮

大家可能都听说过链轮这个词，但是不知道有没有人操作过。我给大家说一下操作的思路，就是选一个主博客，比如是新浪博客。然后，博客都可以自己挂友链的，假如你用了网易、搜狐等等免费博客平台。你可以做两个朝阳网友情链接，一个链接跟网易博客做单项链接，一个链链接到新浪博客，其他的免费博客一次类推。也就是所有的博客都会有一个单项链接指向新浪博客。而他们之间是一个循环，网易博客指向天涯博客、天涯博客指向csdn博客、csdb博客再指向网易。

免费博客的优点和缺点：

免费博客最大的有点莫过于是免费的了!再者免费博客发帖自己可控，不需要别人审核。相对来说稍微自由一些。免费博客的缺点就是发的广告多的话，容易被封。伟伟SEO就有好几个博客养了很长一段时间被封的。如果是个人运营的话，流量上来的话，不能加一些联盟广告。盈利是个问题!但是，作为品牌推广还是可以的!还有就是选择博客领域就是窄一点，比如就做深圳Seo优化，这种地域+关键词的。相对来说比较容易优化一点!

更多信息请访问：朝阳网www.aichaoyang.top

五 : 网站导航如何做SEO优化呢?

　　网站导航在整个网站中起着不可替代的作用，让访客在网站中不会迷失方向，但目前大多数网站的导航都千篇一律，甚至有的为了美观或者单方面的个人需求而放上去，不仅没有节约客户浏览时间，还增加不必要的垃圾页面，那么网站导航如何优化呢?重点要快要准。　　

　　先来认识一下网站导航是什么吧?网站导航就是把网站的所有内容整理分类展现给客户的选择，帮助用户快速获取想要的内容的枢纽，而导航的优化也很简单，给用户想看的内容，对用户没有价值的内容就别放在上面，会影响权重的集中和停留时间。而网站导航又分为三种：顶部导航、底部导航、面包屑导航。这三种导航的优化方式也不尽相同，在后期会详细介绍。

　　如何优化网站导航呢?主要从以下几点来阐述：

　　1.导航最好使用长尾关键词来命名

　　做SEO的人都知道，标题的权重最高，其次是内容，而导航在整个网站的权重分配到多少呢?简单来说仅次于标题，因此在导航上合理的放上一些长尾关键词是非常有必要的，技能让搜索引擎快速知道网站是做什么的，又能了解网站的核心关键词是什么。

　　举个例子说明吧，就拿SEO来说，如果我的核心关键词是【SEO】，那么我的导航就会布局成【SEO优化基础】【SEO视频教程】【SEO培训】【SEO工具】等，一般新手可以通过相关搜索和下拉框进行筛选，在这里就不做过多说明了。

　　2.导航宜简不宜炫

　　相信很多人都遇到过，看到某个网站的导航很花哨炫丽，就感觉高端大气上档次的样子，其实大多炫丽的导航都是JS或者flash制作而成，或者就是一张图片替换而成，搜索引擎抓取的时候根本无法识别这类元素，一旦搜索引擎无法识别内容，就不会在往下一级栏目进行抓取，之前有个朋友就是拿着这样的一个网站来问笔者，笔者只是让他把导航修改一下，开始千般不愿意，认为网站没点特效就不大气了，经过几个小时的讲解，他才不情愿的去修改，不出一个月，收录暴涨了很多，至于案例就不展示在这里了。

　　3、面包屑导航一定要有

　　面包屑导航是内链优化的一大关键，不管是出于什么原因，面包屑导航的作用都是非常大的，目的是告诉用户浏览的地方是什么，不然用户无法找回原来的位置，就会直接关闭网页，用户也是有脾气的。

　　4.导航的内容要符合用户的需求和搜索

　　导航的内容一定要符合用户的搜索需求，这也是标题中所说的“准”，让用户看了就不会在打开其他地方看，很多网站总喜欢把【诚聘英才】等不相关的内容放在导航上，既不是用户关心的，也对自己促成合作没有半点关系，用户看了也不会点击，放上去等于是画蛇添足，但有的人会问了，我想招聘人怎么办，发在我网站上，来看的人就会知道我在招聘，从而面试啊!看似很有道理的一句话，却透着无知，看你网站的人除了同行和客户还有谁看你的网站?要招聘不知道去赶集网或者58同城发布信息吗?何必拿来导航上影响优化呢。

　　5.导航的内容应“左重右轻”

　　导航上的内容除了符合用户的需求外，还要注重布局的位置，一般都是“左重右轻”的布局方式，把用户最关心的内容从左到右依次布局，用户在浏览的时候也能很快的找到自己想要的内容，这也是标题中所说的“快”，在优化的同时，一定要想方设法为用户节约时间，当然这属于浏览优化的范畴了，在这里不做过多说明。

　　总结：以上就是笔者为大家分享的网站导航做SEO优化的几个要点，虽说现在大多SEO都明白，但聪明一世糊涂一时，希望本文能对广大SEO朋友有所帮助。

　　来源：http://www.seo8.org/

本文标题：如何做seo优化-多图片少文字的网站首页如何做好SEO优化
本文地址： http://www.61k.com/1055050.html