1.自定义CircleImageView，加载即可使用

    import android.content.Context;  
    import android.content.res.TypedArray;  
    import android.graphics.Bitmap;  
    import android.graphics.BitmapShader;  
    import android.graphics.Canvas;  
    import android.graphics.Color;  
    import android.graphics.Matrix;  
    import android.graphics.Paint;  
    import android.graphics.RectF;  
    import android.graphics.Shader;  
    import android.graphics.drawable.BitmapDrawable;  
    import android.graphics.drawable.ColorDrawable;  
    import android.graphics.drawable.Drawable;  
    import android.net.Uri;  
    import android.util.AttributeSet;  
    import android.widget.ImageView;  
      
    public class CircleImageView extends ImageView {  
      
        private static final ScaleType SCALE_TYPE = ScaleType.CENTER_CROP;  
      
        private static final Bitmap.Config BITMAP_CONFIG = Bitmap.Config.ARGB_8888;  
        private static final int COLORDRAWABLE_DIMENSION = 1;  
      
        private static final int DEFAULT_BORDER_WIDTH = 0;  
        private static final int DEFAULT_BORDER_COLOR = Color.BLACK;  
      
        private final RectF mDrawableRect = new RectF();  
        private final RectF mBorderRect = new RectF();  
      
        private final Matrix mShaderMatrix = new Matrix();  
        private final Paint mBitmapPaint = new Paint();  
        private final Paint mBorderPaint = new Paint();  
      
        private int mBorderColor = DEFAULT_BORDER_COLOR;  
        private int mBorderWidth = DEFAULT_BORDER_WIDTH;  
      
        private Bitmap mBitmap;  
        private BitmapShader mBitmapShader;  
        private int mBitmapWidth;  
        private int mBitmapHeight;  
      
        private float mDrawableRadius;  
        private float mBorderRadius;  
      
        private boolean mReady;  
        private boolean mSetupPending;  
      
        public static final int CircleImageView_border_width = 0;  
        public static final int CircleImageView_border_color = 1;  
        public static final int[] CircleImageView = { 0x7f010000, 0x7f010001 };  
      
        public CircleImageView(Context context) {  
            super(context);  
            init();  
        }  
      
        public CircleImageView(Context context, AttributeSet attrs) {  
            this(context, attrs, 0);  
        }  
      
        public CircleImageView(Context context, AttributeSet attrs, int defStyle) {  
            super(context, attrs, defStyle);  
      
            TypedArray a = context.obtainStyledAttributes(attrs, CircleImageView,defStyle, 0);  
            mBorderWidth = a.getDimensionPixelSize(0, DEFAULT_BORDER_WIDTH);  
            mBorderColor = a.getColor(CircleImageView_border_color,DEFAULT_BORDER_COLOR);  
            a.recycle();  
            init();  
        }  
      
        private void init() {  
            super.setScaleType(SCALE_TYPE);  
            mReady = true;  
      
            if (mSetupPending) {  
                setup();  
                mSetupPending = false;  
            }  
        }  
      
        @Override  
        protected void onDraw(Canvas canvas) {  
            if (getDrawable() == null) {  
                return;  
            }  
            canvas.drawCircle(getWidth() / 2, getHeight() / 2, mDrawableRadius,  
                    mBitmapPaint);  
            if (mBorderWidth != 0) {  
                canvas.drawCircle(getWidth() / 2, getHeight() / 2, mBorderRadius,  
                        mBorderPaint);  
            }  
        }  
      
        @Override  
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
            super.onSizeChanged(w, h, oldw, oldh);  
            setup();  
        }  
      
        public int getBorderColor() {  
            return mBorderColor;  
        }  
      
        public void setBorderColor(int borderColor) {  
            if (borderColor == mBorderColor) {  
                return;  
            }  
      
            mBorderColor = borderColor;  
            mBorderPaint.setColor(mBorderColor);  
            invalidate();  
        }  
      
        public int getBorderWidth() {  
            return mBorderWidth;  
        }  
      
        public void setBorderWidth(int borderWidth) {  
            if (borderWidth == mBorderWidth) {  
                return;  
            }  
            mBorderWidth = borderWidth;  
            setup();  
        }  
      
        @Override  
        public void setImageBitmap(Bitmap bm) {  
            super.setImageBitmap(bm);  
            mBitmap = bm;  
            setup();  
        }  
      
        @Override  
        public void setBackgroundResource(int resid) {  
            super.setBackgroundResource(resid);  
            mBitmap = getBitmapFromDrawable(getDrawable());  
            setup();  
        }  
      
        @Override  
        public void setImageDrawable(Drawable drawable) {  
            super.setImageDrawable(drawable);  
            mBitmap = getBitmapFromDrawable(drawable);  
            setup();  
        }  
      
        @Override  
        public void setImageResource(int resId) {  
            super.setImageResource(resId);  
            mBitmap = getBitmapFromDrawable(getDrawable());  
            setup();  
        }  
      
        @Override  
        public void setImageURI(Uri uri) {  
            super.setImageURI(uri);  
            mBitmap = getBitmapFromDrawable(getDrawable());  
            setup();  
        }  
      
        private Bitmap getBitmapFromDrawable(Drawable drawable) {  
            if (drawable == null) {  
                return null;  
            }  
      
            if (drawable instanceof BitmapDrawable) {  
                return ((BitmapDrawable) drawable).getBitmap();  
            }  
      
            try {  
                Bitmap bitmap;  
      
                if (drawable instanceof ColorDrawable) {  
                    bitmap = Bitmap.createBitmap(COLORDRAWABLE_DIMENSION,  
                            COLORDRAWABLE_DIMENSION, BITMAP_CONFIG);  
                } else {  
                    bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),  
                            drawable.getIntrinsicHeight(), BITMAP_CONFIG);  
                }  
      
                Canvas canvas = new Canvas(bitmap);  
                drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());  
                drawable.draw(canvas);  
                return bitmap;  
            } catch (OutOfMemoryError e) {  
                return null;  
            }  
        }  
      
        private void setup() {  
            if (!mReady) {  
                mSetupPending = true;  
                return;  
            }  
      
            if (mBitmap == null) {  
                return;  
            }  
      
            mBitmapShader = new BitmapShader(mBitmap, Shader.TileMode.CLAMP,  
                    Shader.TileMode.CLAMP);  
      
            mBitmapPaint.setAntiAlias(true);  
            mBitmapPaint.setShader(mBitmapShader);  
      
            mBorderPaint.setStyle(Paint.Style.STROKE);  
            mBorderPaint.setAntiAlias(true);  
            mBorderPaint.setColor(mBorderColor);  
            mBorderPaint.setStrokeWidth(mBorderWidth);  
      
            mBitmapHeight = mBitmap.getHeight();  
            mBitmapWidth = mBitmap.getWidth();  
      
            mBorderRect.set(0, 0, getWidth(), getHeight());  
            mBorderRadius = Math.min((mBorderRect.height() - mBorderWidth) / 2,  
                    (mBorderRect.width() - mBorderWidth) / 2);  
      
            mDrawableRect.set(mBorderWidth, mBorderWidth, mBorderRect.width()  
                    - mBorderWidth, mBorderRect.height() - mBorderWidth);  
            mDrawableRadius = Math.min(mDrawableRect.height() / 2,  
                    mDrawableRect.width() / 2);  
      
            updateShaderMatrix();  
            invalidate();  
        }  
      
        private void updateShaderMatrix() {  
            float scale;  
            float dx = 0;  
            float dy = 0;  
      
            mShaderMatrix.set(null);  
      
            if (mBitmapWidth * mDrawableRect.height() > mDrawableRect.width()  
                    * mBitmapHeight) {  
                scale = mDrawableRect.height() / (float) mBitmapHeight;  
                dx = (mDrawableRect.width() - mBitmapWidth * scale) * 0.5f;  
            } else {  
                scale = mDrawableRect.width() / (float) mBitmapWidth;  
                dy = (mDrawableRect.height() - mBitmapHeight * scale) * 0.5f;  
            }  
      
            mShaderMatrix.setScale(scale, scale);  
            mShaderMatrix.postTranslate((int) (dx + 0.5f) + mBorderWidth,  
                    (int) (dy + 0.5f) + mBorderWidth);  
      
            mBitmapShader.setLocalMatrix(mShaderMatrix);  
        }  
    }  

2.绘制现有图片

private Bitmap cicleImage(int id) {  
        // 加载现有图片  
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), id);  
        int width = bitmap.getWidth();  
        int height = bitmap.getHeight();  
  
        // 构造新图纸  
        Bitmap output = Bitmap.createBitmap(width, height,  
                Bitmap.Config.ARGB_8888);  
        Canvas canvas = new Canvas(output);  
  
        Paint paint = new Paint();  
        paint.setAntiAlias(true); // 抗锯齿  
        canvas.drawARGB(0, 0, 0, 0); // 将背景绘制成黑色  
  
        // 画一个灰色的实心园  
        paint.setColor(0xff424242);  
        canvas.drawCircle(width / 2, height / 2, width / 2, paint);  
  
        /* [Sa * Da, Sc * Da] */  
        // 取两层绘制交集，显示上层，本例下层是刚绘制的实心园，上层是即将绘制  
        // 的图片，两者的交集就是个园，显示上层，就把图片中的园形部分显示出来了  
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));  
  
        // 绘制现有图片  
        Rect src = new Rect(0, 0, width, width);  
        Rect dst = new Rect(0, 0, width, height);  
        //Rect src: 是对图片进行裁截，若是空null则显示整个图片  
        //Rect dst：是图片在Canvas画布中显示的区域，大于src则把src的裁截区放大， 小于src则把src的裁截区缩小。  
        canvas.drawBitmap(bitmap, src, dst, paint);  
        return output;  
    }