ViewPager 可左右滑动和缩放的图片浏览

最近因为要做一个项目，需要使用到图片的浏览。我就自己在网上找了些资料，然后加以修改整理后出来一个demo，希望可以帮助到需要的人。同时这也是我第一个技术博客。

在做之前首先需要了解一下什么是ViewPager，怎么使用ViewPager。我这里提供一篇文章给大家  http://www.2cto.com/kf/201411/353975.html   我这里不在赘述了。

好了  了解完可以开始了

PS  我不知道怎么制作那种动态的效果图，如果有谁知道请告诉我  我将万分感谢

一步一步来

首先先要写个布局 ViewPager的布局   activity_main.xml

 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
     android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
     android:paddingRight="@dimen/activity_horizontal_margin"
     android:paddingTop="@dimen/activity_vertical_margin"
     android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity"
     android:orientation="vertical">

     <LinearLayout
         android:id="@+id/linearlayout"
         android:layout_width="300dp"
         android:layout_height="300dp"
         android:background="@drawable/bg_common_frames"
         android:layout_gravity="center"
         >

         <android.support.v4.view.ViewPager
             android:id="@+id/viewpager"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_gravity="center"
             />

     </LinearLayout>

 </LinearLayout>

对应的效果是这样的 请看 有点丑 不管啦。用了一张底图  在上面代码中的 LinearLayout

然后是图片详情布局     image_details.xml

 <?xml version="1.0" encoding="utf-8"?>
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="match_parent">

     <android.support.v4.view.ViewPager
         android:id="@+id/view_pager"
         android:layout_width="match_parent"
         android:layout_height="match_parent">
     </android.support.v4.view.ViewPager>

     <TextView
         android:id="@+id/page_text"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_alignParentBottom="true"
         android:layout_centerHorizontal="true"
         android:layout_marginBottom="10dp"
         android:textColor="#fff"
         android:textSize="18sp" />

 </RelativeLayout>

最后一个布局是缩放的布局  zoom_image_layout.xml

 <?xml version="1.0" encoding="utf-8"?>
 <com.higgs.mviewpager.ZoomImageView xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/zoom_image_view"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:background="#000000" >

 </com.higgs.mviewpager.ZoomImageView>

基本的布局我们完成了

再看代码吧

我这里因为迎合大部分朋友的需求 ，改成了从网络上下载图片的方式作为图片来源

先模拟一个图片URL的类

 package com.higgs.mviewpager;

 public class Images {

     public final static String[] imageUrls = new String[]{
             "http://img.my.csdn.net/uploads/201309/01/1378037235_3453.jpg",
             "http://img.my.csdn.net/uploads/201309/01/1378037235_7476.jpg",
             "http://img.my.csdn.net/uploads/201309/01/1378037235_9280.jpg",
             "http://img.my.csdn.net/uploads/201309/01/1378037234_3539.jpg",
             "http://img.my.csdn.net/uploads/201309/01/1378037234_6318.jpg",
     };
 }

然后就是实现代码了

说一下思路， 先获取ViewPager 然后往ViewPager 添加图片，但是图片是网络上的 所以要先下载后在添加进去，这里处于防止加载比较多的图片时造成OOM问题 所以引入了 LruCache 类缓存技术。先讲下载的图片存入手机里并缓存下来，一为了节省用户的数据流量，二为了之后的加载速度。有了缓冲下次就不用在重复去网络上下载了。  代码如下

 package com.higgs.mviewpager;

 import android.app.Activity;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Environment;
 import android.support.v4.view.PagerAdapter;
 import android.support.v4.view.ViewPager;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.Toast;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.ArrayList;

 public class MainActivity extends Activity {

     private static final String TAG = "MainActivity";
     private ImageLoader  imageLoader = ImageLoader.getInstance();  //获取图片进行管理的工具类实例。

     private ViewPager viewpager;
     private ArrayList<View> viewList;
 //    private ImageView imageView1;
 //    private ImageView imageView2;
 //    private ImageView imageView3;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         initView();
     }

     private void initView() {
         viewpager = (ViewPager) findViewById(R.id.viewpager); //获取viewpager
         viewList = new ArrayList<View>();   //保存view，用于PagerAdapter
         for(int i = 0; i<Images.imageUrls.length; i++){
             new DownLoadPic().execute(i);//图片有几张就下载几张
         }

 //
 //        imageView1 = new ImageView(this);
 //        imageView2 = new ImageView(this);
 //        imageView3 = new ImageView(this);
 //        imageView1.setImageResource(R.drawable.b);
 //        imageView2.setImageResource(R.drawable.c);
 //        imageView3.setImageResource(R.drawable.d);
 //
 //        viewList.add(imageView1);
 //        viewList.add(imageView2);
 //        viewList.add(imageView3);

         viewpager.setAdapter(pagerAdapter);  //加入适配器
         Log.e("TAG1", "" + viewList.size());

     }

     /**
      * 图片异步下载内部类
      */

     class DownLoadPic extends AsyncTask<Integer,Void,Bitmap>{

         /**
          * 记录每个图片对应的位置
          */
         private int mposition;

         @Override
         protected Bitmap doInBackground(Integer... params) {

             mposition = params[0];//获取传过来的图片position （下标）
             String strurl = Images.imageUrls[mposition];  //通过下标获得图片URL
             File imageFile = new File(getImagePath(strurl)); //获取图片在本地手机中的位置路径
             if (!imageFile.exists()) {  //判断是否存在手机里
                 doPost(strurl);//如果没有就下载图片
             }
             if (strurl != null) {
                 Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
                         290);  //压缩图片  我这里写的是290
                 if (bitmap != null) {
                     imageLoader.addBitmapToMemoryCache(strurl, bitmap); //将图片加入缓冲  LruCache中
                     return bitmap;
                 }
             }

             return null;
         }

         @Override
         protected void onPostExecute(Bitmap o) {
             ImageView imageView = new ImageView(MainActivity.this);
             imageView.setImageBitmap(o);
             imageView.setOnClickListener(new View.OnClickListener() {
                 @Override
                 public void onClick(View v) {

                     Intent intent = new Intent(MainActivity.this, ImageDetailsActivity.class);//打开图片详情类
                     intent.putExtra("image_position", mposition);
                     MainActivity.this.startActivity(intent);
                 }
             });

             viewList.add(imageView);
             pagerAdapter.notifyDataSetChanged();  //这句话一定不能少  ，不然会有异常
             Log.e("TAG2", "" + viewList.size());

         }

     }

     /**
      * ViewPager的适配器  重写下面几个方法就可以了
      */

     PagerAdapter pagerAdapter = new PagerAdapter() {

         @Override
         public int getCount() {

             return viewList.size();
         }

         @Override
         public boolean isViewFromObject(View view, Object object) {
             return view == object;
         }

         @Override
         public void destroyItem(ViewGroup container, int position,
                                 Object object) {
             container.removeView(viewList.get(position));

         }

         @Override
         public int getItemPosition(Object object) {

             return super.getItemPosition(object);
         }

         @Override
         public Object instantiateItem(ViewGroup container, int position) {
             container.addView(viewList.get(position));
             return viewList.get(position);
         }

     };

     /**
      * 下载图片方法  并将图片缓冲至手机指定位置中
      * @param urlstr  图片URL
      */
     public void doPost(String urlstr){
         if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
             Log.d("TAG", "monted sdcard");
         } else {
             Log.d("TAG", "has no sdcard");
         }
         HttpURLConnection con = null;
         FileOutputStream fos = null;
         BufferedOutputStream bos = null;
         BufferedInputStream bis = null;
         File imageFile = null;
         try {
             URL url = new URL(urlstr);
             con = (HttpURLConnection) url.openConnection();
             con.setConnectTimeout(5 * 1000);
             con.setReadTimeout(15 * 1000);
             con.setDoInput(true);
             con.setDoOutput(true);
             bis = new BufferedInputStream(con.getInputStream());
             imageFile = new File(getImagePath(urlstr));
             fos = new FileOutputStream(imageFile);
             bos = new BufferedOutputStream(fos);
             byte[] b = new byte[1024];
             int length;
             while ((length = bis.read(b)) != -1) {// 写入手机中
                 bos.write(b, 0, length);
                 bos.flush();
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 if (bis != null) {
                     bis.close();
                 }
                 if (bos != null) {
                     bos.close();
                 }
                 if (con != null) {
                     con.disconnect();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         if (imageFile != null) {
             Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
                     290);
             if (bitmap != null) {
                 imageLoader.addBitmapToMemoryCache(urlstr, bitmap);
             }
         }
     }

     /**
      * 获取图片的本地存储路径。
      *
      * @param imageUrl
      *            图片的URL地址。
      * @return 图片的本地存储路径。
      */
     private String getImagePath(String imageUrl) {
         int lastSlashIndex = imageUrl.lastIndexOf("/");
         String imageName = imageUrl.substring(lastSlashIndex + 1);
         String imageDir = Environment.getExternalStorageDirectory().getPath()
                 + "/pwxceshibao/";
         File file = new File(imageDir);
         if (!file.exists()) {
             file.mkdirs();
         }
         String imagePath = imageDir + imageName;
         return imagePath;
     }

 }

下面是几个工具类。是我从网上找的。个人觉得非常有用。所以就拿过来了。注意了，下面几个工具类都用上了，所以不能少哦

在这里要感谢 http://blog.csdn.net/sziicool/article/details/18728187  博主，我是站在他的肩膀上修改的。

第一个是查看大图类  就是图片详情类

 package com.higgs.mviewpager;

 import android.app.Activity;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.os.Bundle;
 import android.os.Environment;
 import android.support.v4.view.PagerAdapter;
 import android.support.v4.view.ViewPager;
 import android.support.v4.view.ViewPager.OnPageChangeListener;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.Window;
 import android.widget.TextView;

 import java.io.File;

 /**
  * 查看大图的Activity界面。
  *
  * @author guolin
  */
 public class ImageDetailsActivity extends Activity implements
         OnPageChangeListener {

     /**
      * 用于管理图片的滑动
      */
     private ViewPager viewPager;

     /**
      * 显示当前图片的页数
      */
     private TextView pageText;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         setContentView(R.layout.image_details);
         int imagePosition = getIntent().getIntExtra("image_position", 0);
         pageText = (TextView) findViewById(R.id.page_text);
         viewPager = (ViewPager) findViewById(R.id.view_pager);
         ViewPagerAdapter adapter = new ViewPagerAdapter();
         viewPager.setAdapter(adapter);
         viewPager.setCurrentItem(imagePosition);
         viewPager.setOnPageChangeListener(this);
         viewPager.setEnabled(false);
         // 设定当前的页数和总页数
         pageText.setText((imagePosition + 1) + "/" + Images.imageUrls.length);
     }

     /**
      * ViewPager的适配器
      *
      * @author guolin
      */
     class ViewPagerAdapter extends PagerAdapter {

         @Override
         public Object instantiateItem(ViewGroup container, int position) {
             String imagePath = getImagePath(Images.imageUrls[position]);
             Bitmap bitmap = BitmapFactory.decodeFile(imagePath);
             if (bitmap == null) {
                 bitmap = BitmapFactory.decodeResource(getResources(),
                         R.drawable.empty_photo);
             }
             View view = LayoutInflater.from(ImageDetailsActivity.this).inflate(
                     R.layout.zoom_image_layout, null);
             ZoomImageView zoomImageView = (ZoomImageView) view
                     .findViewById(R.id.zoom_image_view);
             zoomImageView.setImageBitmap(bitmap);
             container.addView(view);
             return view;
         }

         @Override
         public int getCount() {
             return Images.imageUrls.length;
         }

         @Override
         public boolean isViewFromObject(View arg0, Object arg1) {
             return arg0 == arg1;
         }

         @Override
         public void destroyItem(ViewGroup container, int position, Object object) {
             View view = (View) object;
             container.removeView(view);
         }

     }

     /**
      * 获取图片的本地存储路径。
      *
      * @param imageUrl
      *            图片的URL地址。
      * @return 图片的本地存储路径。
      */
     private String getImagePath(String imageUrl) {
         int lastSlashIndex = imageUrl.lastIndexOf("/");
         String imageName = imageUrl.substring(lastSlashIndex + 1);
         String imageDir = Environment.getExternalStorageDirectory().getPath()
                 + "/pwxceshibao/";
         File file = new File(imageDir);
         if (!file.exists()) {
             file.mkdirs();
         }
         String imagePath = imageDir + imageName;
         return imagePath;
     }

     @Override
     public void onPageScrollStateChanged(int arg0) {

     }

     @Override
     public void onPageScrolled(int arg0, float arg1, int arg2) {

     }

     @Override
     public void onPageSelected(int currentPage) {
         // 每当页数发生改变时重新设定一遍当前的页数和总页数
         pageText.setText((currentPage + 1) + "/" + Images.imageUrls.length);
     }

 }

第二个是图片缩放工具类

 package com.higgs.mviewpager;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Matrix;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.View;

 /**
  * 自定义的ImageView控制，可对图片进行多点触控缩放和拖动
  *
  * @author guolin
  */
 public class ZoomImageView extends View {

     /**
      * 初始化状态常量
      */
     public static final int STATUS_INIT = 1;

     /**
      * 图片放大状态常量
      */
     public static final int STATUS_ZOOM_OUT = 2;

     /**
      * 图片缩小状态常量
      */
     public static final int STATUS_ZOOM_IN = 3;

     /**
      * 图片拖动状态常量
      */
     public static final int STATUS_MOVE = 4;

     /**
      * 用于对图片进行移动和缩放变换的矩阵
      */
     private Matrix matrix = new Matrix();

     /**
      * 待展示的Bitmap对象
      */
     private Bitmap sourceBitmap;

     /**
      * 记录当前操作的状态，可选值为STATUS_INIT、STATUS_ZOOM_OUT、STATUS_ZOOM_IN和STATUS_MOVE
      */
     private int currentStatus;

     /**
      * ZoomImageView控件的宽度
      */
     private int width;

     /**
      * ZoomImageView控件的高度
      */
     private int height;

     /**
      * 记录两指同时放在屏幕上时，中心点的横坐标值
      */
     private float centerPointX;

     /**
      * 记录两指同时放在屏幕上时，中心点的纵坐标值
      */
     private float centerPointY;

     /**
      * 记录当前图片的宽度，图片被缩放时，这个值会一起变动
      */
     private float currentBitmapWidth;

     /**
      * 记录当前图片的高度，图片被缩放时，这个值会一起变动
      */
     private float currentBitmapHeight;

     /**
      * 记录上次手指移动时的横坐标
      */
     private float lastXMove = -1;

     /**
      * 记录上次手指移动时的纵坐标
      */
     private float lastYMove = -1;

     /**
      * 记录手指在横坐标方向上的移动距离
      */
     private float movedDistanceX;

     /**
      * 记录手指在纵坐标方向上的移动距离
      */
     private float movedDistanceY;

     /**
      * 记录图片在矩阵上的横向偏移值
      */
     private float totalTranslateX;

     /**
      * 记录图片在矩阵上的纵向偏移值
      */
     private float totalTranslateY;

     /**
      * 记录图片在矩阵上的总缩放比例
      */
     private float totalRatio;

     /**
      * 记录手指移动的距离所造成的缩放比例
      */
     private float scaledRatio;

     /**
      * 记录图片初始化时的缩放比例
      */
     private float initRatio;

     /**
      * 记录上次两指之间的距离
      */
     private double lastFingerDis;

     /**
      * ZoomImageView构造函数，将当前操作状态设为STATUS_INIT。
      *
      * @param context
      * @param attrs
      */
     public ZoomImageView(Context context, AttributeSet attrs) {
         super(context, attrs);
         currentStatus = STATUS_INIT;
     }

     /**
      * 将待展示的图片设置进来。
      *
      * @param bitmap
      *            待展示的Bitmap对象
      */
     public void setImageBitmap(Bitmap bitmap) {
         sourceBitmap = bitmap;
         invalidate();
     }

     @Override
     protected void onLayout(boolean changed, int left, int top, int right,
             int bottom) {
         super.onLayout(changed, left, top, right, bottom);
         if (changed) {
             // 分别获取到ZoomImageView的宽度和高度
             width = getWidth();
             height = getHeight();
         }
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         if (initRatio == totalRatio) {
             getParent().requestDisallowInterceptTouchEvent(false);
         } else {
             getParent().requestDisallowInterceptTouchEvent(true);
         }
         switch (event.getActionMasked()) {
         case MotionEvent.ACTION_POINTER_DOWN:
             if (event.getPointerCount() == 2) {
                 // 当有两个手指按在屏幕上时，计算两指之间的距离
                 lastFingerDis = distanceBetweenFingers(event);
             }
             break;
         case MotionEvent.ACTION_CANCEL:
         case MotionEvent.ACTION_MOVE:
             if (event.getPointerCount() == 1) {
                 // 只有单指按在屏幕上移动时，为拖动状态
                 float xMove = event.getX();
                 float yMove = event.getY();
                 if (lastXMove == -1 && lastYMove == -1) {
                     lastXMove = xMove;
                     lastYMove = yMove;
                 }
                 currentStatus = STATUS_MOVE;
                 movedDistanceX = xMove - lastXMove;
                 movedDistanceY = yMove - lastYMove;
                 // 进行边界检查，不允许将图片拖出边界
                 if (totalTranslateX + movedDistanceX > 0) {
                     movedDistanceX = 0;
                 } else if (width - (totalTranslateX + movedDistanceX) > currentBitmapWidth) {
                     movedDistanceX = 0;
                 }
                 if (totalTranslateY + movedDistanceY > 0) {
                     movedDistanceY = 0;
                 } else if (height - (totalTranslateY + movedDistanceY) > currentBitmapHeight) {
                     movedDistanceY = 0;
                 }
                 // 调用onDraw()方法绘制图片
                 invalidate();
                 lastXMove = xMove;
                 lastYMove = yMove;
             } else if (event.getPointerCount() == 2) {
                 // 有两个手指按在屏幕上移动时，为缩放状态
                 centerPointBetweenFingers(event);
                 double fingerDis = distanceBetweenFingers(event);
                 if (fingerDis > lastFingerDis) {
                     currentStatus = STATUS_ZOOM_OUT;
                 } else {
                     currentStatus = STATUS_ZOOM_IN;
                 }
                 // 进行缩放倍数检查，最大只允许将图片放大4倍，最小可以缩小到初始化比例
                 if ((currentStatus == STATUS_ZOOM_OUT && totalRatio < 4 * initRatio)
                         || (currentStatus == STATUS_ZOOM_IN && totalRatio > initRatio)) {
                     scaledRatio = (float) (fingerDis / lastFingerDis);
                     totalRatio = totalRatio * scaledRatio;
                     if (totalRatio > 4 * initRatio) {
                         totalRatio = 4 * initRatio;
                     } else if (totalRatio < initRatio) {
                         totalRatio = initRatio;
                     }
                     // 调用onDraw()方法绘制图片
                     invalidate();
                     lastFingerDis = fingerDis;
                 }
             }
             break;
         case MotionEvent.ACTION_POINTER_UP:
             if (event.getPointerCount() == 2) {
                 // 手指离开屏幕时将临时值还原
                 lastXMove = -1;
                 lastYMove = -1;
             }
             break;
         case MotionEvent.ACTION_UP:
             // 手指离开屏幕时将临时值还原
             lastXMove = -1;
             lastYMove = -1;
             break;
         default:
             break;
         }
         return true;
     }

     /**
      * 根据currentStatus的值来决定对图片进行什么样的绘制操作。
      */
     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         switch (currentStatus) {
         case STATUS_ZOOM_OUT:
         case STATUS_ZOOM_IN:
             zoom(canvas);
             break;
         case STATUS_MOVE:
             move(canvas);
             break;
         case STATUS_INIT:
             initBitmap(canvas);
         default:
             if (sourceBitmap != null) {
                 canvas.drawBitmap(sourceBitmap, matrix, null);
             }
             break;
         }
     }

     /**
      * 对图片进行缩放处理。
      *
      * @param canvas
      */
     private void zoom(Canvas canvas) {
         matrix.reset();
         // 将图片按总缩放比例进行缩放
         matrix.postScale(totalRatio, totalRatio);
         float scaledWidth = sourceBitmap.getWidth() * totalRatio;
         float scaledHeight = sourceBitmap.getHeight() * totalRatio;
         float translateX = 0f;
         float translateY = 0f;
         // 如果当前图片宽度小于屏幕宽度，则按屏幕中心的横坐标进行水平缩放。否则按两指的中心点的横坐标进行水平缩放
         if (currentBitmapWidth < width) {
             translateX = (width - scaledWidth) / 2f;
         } else {
             translateX = totalTranslateX * scaledRatio + centerPointX
                     * (1 - scaledRatio);
             // 进行边界检查，保证图片缩放后在水平方向上不会偏移出屏幕
             if (translateX > 0) {
                 translateX = 0;
             } else if (width - translateX > scaledWidth) {
                 translateX = width - scaledWidth;
             }
         }
         // 如果当前图片高度小于屏幕高度，则按屏幕中心的纵坐标进行垂直缩放。否则按两指的中心点的纵坐标进行垂直缩放
         if (currentBitmapHeight < height) {
             translateY = (height - scaledHeight) / 2f;
         } else {
             translateY = totalTranslateY * scaledRatio + centerPointY
                     * (1 - scaledRatio);
             // 进行边界检查，保证图片缩放后在垂直方向上不会偏移出屏幕
             if (translateY > 0) {
                 translateY = 0;
             } else if (height - translateY > scaledHeight) {
                 translateY = height - scaledHeight;
             }
         }
         // 缩放后对图片进行偏移，以保证缩放后中心点位置不变
         matrix.postTranslate(translateX, translateY);
         totalTranslateX = translateX;
         totalTranslateY = translateY;
         currentBitmapWidth = scaledWidth;
         currentBitmapHeight = scaledHeight;
         canvas.drawBitmap(sourceBitmap, matrix, null);
     }

     /**
      * 对图片进行平移处理
      *
      * @param canvas
      */
     private void move(Canvas canvas) {
         matrix.reset();
         // 根据手指移动的距离计算出总偏移值
         float translateX = totalTranslateX + movedDistanceX;
         float translateY = totalTranslateY + movedDistanceY;
         // 先按照已有的缩放比例对图片进行缩放
         matrix.postScale(totalRatio, totalRatio);
         // 再根据移动距离进行偏移
         matrix.postTranslate(translateX, translateY);
         totalTranslateX = translateX;
         totalTranslateY = translateY;
         canvas.drawBitmap(sourceBitmap, matrix, null);
     }

     /**
      * 对图片进行初始化操作，包括让图片居中，以及当图片大于屏幕宽高时对图片进行压缩。
      *
      * @param canvas
      */
     private void initBitmap(Canvas canvas) {
         if (sourceBitmap != null) {
             matrix.reset();
             int bitmapWidth = sourceBitmap.getWidth();
             int bitmapHeight = sourceBitmap.getHeight();
             if (bitmapWidth > width || bitmapHeight > height) {
                 if (bitmapWidth - width > bitmapHeight - height) {
                     // 当图片宽度大于屏幕宽度时，将图片等比例压缩，使它可以完全显示出来
                     float ratio = width / (bitmapWidth * 1.0f);
                     matrix.postScale(ratio, ratio);
                     float translateY = (height - (bitmapHeight * ratio)) / 2f;
                     // 在纵坐标方向上进行偏移，以保证图片居中显示
                     matrix.postTranslate(0, translateY);
                     totalTranslateY = translateY;
                     totalRatio = initRatio = ratio;
                 } else {
                     // 当图片高度大于屏幕高度时，将图片等比例压缩，使它可以完全显示出来
                     float ratio = height / (bitmapHeight * 1.0f);
                     matrix.postScale(ratio, ratio);
                     float translateX = (width - (bitmapWidth * ratio)) / 2f;
                     // 在横坐标方向上进行偏移，以保证图片居中显示
                     matrix.postTranslate(translateX, 0);
                     totalTranslateX = translateX;
                     totalRatio = initRatio = ratio;
                 }
                 currentBitmapWidth = bitmapWidth * initRatio;
                 currentBitmapHeight = bitmapHeight * initRatio;
             } else {
                 // 当图片的宽高都小于屏幕宽高时，直接让图片居中显示
                 float translateX = (width - sourceBitmap.getWidth()) / 2f;
                 float translateY = (height - sourceBitmap.getHeight()) / 2f;
                 matrix.postTranslate(translateX, translateY);
                 totalTranslateX = translateX;
                 totalTranslateY = translateY;
                 totalRatio = initRatio = 1f;
                 currentBitmapWidth = bitmapWidth;
                 currentBitmapHeight = bitmapHeight;
             }
             canvas.drawBitmap(sourceBitmap, matrix, null);
         }
     }

     /**
      * 计算两个手指之间的距离。
      *
      * @param event
      * @return 两个手指之间的距离
      */
     private double distanceBetweenFingers(MotionEvent event) {
         float disX = Math.abs(event.getX(0) - event.getX(1));
         float disY = Math.abs(event.getY(0) - event.getY(1));
         return Math.sqrt(disX * disX + disY * disY);
     }

     /**
      * 计算两个手指之间中心点的坐标。
      *
      * @param event
      */
     private void centerPointBetweenFingers(MotionEvent event) {
         float xPoint0 = event.getX(0);
         float yPoint0 = event.getY(0);
         float xPoint1 = event.getX(1);
         float yPoint1 = event.getY(1);
         centerPointX = (xPoint0 + xPoint1) / 2;
         centerPointY = (yPoint0 + yPoint1) / 2;
     }

 }

最后一个是图片管理工具类  也是缓存核心类   这个就是上面提到的防止加载过多的图片时产生OOM

 package com.higgs.mviewpager;

 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.util.LruCache;

 /**
  * 对图片进行管理的工具类。
  *
  * @author Tony
  */
 public class ImageLoader {

     /**
      * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。
      */
     private static LruCache<String, Bitmap> mMemoryCache;

     /**
      * ImageLoader的实例。
      */
     private static ImageLoader mImageLoader;

     private ImageLoader() {
         // 获取应用程序最大可用内存
         int maxMemory = (int) Runtime.getRuntime().maxMemory();
         int cacheSize = maxMemory / 8;
         // 设置图片缓存大小为程序最大可用内存的1/8
         mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
             @Override
             protected int sizeOf(String key, Bitmap bitmap) {
                 return bitmap.getByteCount();
             }
         };
     }

     /**
      * 获取ImageLoader的实例。
      *
      * @return ImageLoader的实例。
      */
     public static ImageLoader getInstance() {
         if (mImageLoader == null) {
             mImageLoader = new ImageLoader();
         }
         return mImageLoader;
     }

     /**
      * 将一张图片存储到LruCache中。
      *
      * @param key
      *            LruCache的键，这里传入图片的URL地址。
      * @param bitmap
      *            LruCache的键，这里传入从网络上下载的Bitmap对象。
      */
     public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
         if (getBitmapFromMemoryCache(key) == null) {
             mMemoryCache.put(key, bitmap);
         }
     }

     /**
      * 从LruCache中获取一张图片，如果不存在就返回null。
      *
      * @param key
      *            LruCache的键，这里传入图片的URL地址。
      * @return 对应传入键的Bitmap对象，或者null。
      */
     public Bitmap getBitmapFromMemoryCache(String key) {
         return mMemoryCache.get(key);
     }

     public static int calculateInSampleSize(BitmapFactory.Options options,
             int reqWidth) {
         // 源图片的宽度
         final int width = options.outWidth;
         int inSampleSize = 1;
         if (width > reqWidth) {
             // 计算出实际宽度和目标宽度的比率
             final int widthRatio = Math.round((float) width / (float) reqWidth);
             inSampleSize = widthRatio;
         }
         return inSampleSize;
     }

     public static Bitmap decodeSampledBitmapFromResource(String pathName,
             int reqWidth) {
         // 第一次解析将inJustDecodeBounds设置为true，来获取图片大小
         final BitmapFactory.Options options = new BitmapFactory.Options();
         options.inJustDecodeBounds = true;
         BitmapFactory.decodeFile(pathName, options);
         // 调用上面定义的方法计算inSampleSize值
         options.inSampleSize = calculateInSampleSize(options, reqWidth);
         // 使用获取到的inSampleSize值再次解析图片
         options.inJustDecodeBounds = false;
         return BitmapFactory.decodeFile(pathName, options);
     }

 }

好了  大家照着自己做做就可以出来效果了，因为我已经把全部的源码贴出来了，如果你懒得连代码都不想敲。我觉得此文章对你没有什么作用。只有自己敲了就理解了

第一次写博客，感觉思路很乱，很多都没有讲明白。一个是时间不够，二是关键点都有注释，代码都贴上来了。共勉~~~~