图片加载框架之Picasso

最新推荐文章于 2024-04-03 01:23:27 发布
最新推荐文章于 2024-04-03 01:23:27 发布
阅读量661 收藏
点赞数
分类专栏： Android图片加载框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haoranli/article/details/79615299
版权

一、简介

Picasso是Square公司出品的一个强大的图片下载和缓存图片库

1）在adapter中需要取消已经不在视野范围的ImageView图片资源的加载，否则会导致图片错位，Picasso已经解决了这个问题。

2）使用复杂的图片压缩转换来尽可能的减少内存消耗

3）自带内存和硬盘二级缓存功能

二、下载地址

点击下载链接

三、功能

1）基本用法

Picasso.with(context).load(imageUrl).into(imageView);

2）图片路径load()

    load SD卡资源：load("file://"+ Environment.getExternalStorageDirectory().getPath()+"/test.jpg")

    load assets资源：load("file:///android_asset/f003.gif")

   load drawable资源：load("android.resource://com.frank.glide/drawable/news")

  load http资源：load("http:www.123.com/1234567890.jpg")

3）资源加载的方法

- placeholder(xxx). 设置资源加载过程中的显示的Drawable。

- error(xxx).设置load失败时显示的Drawable。

- into(xxx) 设置资源加载到的目标 包括ImageView Target等

4）图片裁剪

Picasso.with(this).load("http://n.sinaimg.cn/translate/20160819/9BpA-fxvcsrn8627957.jpg")  
                .resizeDimen(R.dimen.iv_width,R.dimen.iv_height)  

                .into(iv);

四、使用步骤

（1）导入jar包或在module的gradle文件中添加

 compile 'com.squareup.picasso:picasso:2.5.2'

五、例子

1）基本用法

普通加载

 Picasso.with(PicassoActivity.this)
                .load("http://n.sinaimg.cn/translate/20160819/9BpA-fxvcsrn8627957.jpg")
                .into(ivPicassoResult1);

裁剪

        // 裁剪的方式加载图片
        Picasso.with(PicassoActivity.this)
                .load("http://n.sinaimg.cn/translate/20160819/9BpA-fxvcsrn8627957.jpg")
                .resize(100,100)
                .into(ivPicassoResult2);

旋转180度

        // 选择180度
        Picasso.with(PicassoActivity.this)
                .load("http://n.sinaimg.cn/translate/20160819/9BpA-fxvcsrn8627957.jpg")
                .rotate(180)
                .into(ivPicassoResult3);

2）listview中使用

        // 初始化listview
        PicassoListviewAdapter picassoListviewAdapter = new PicassoListviewAdapter(this);

        lvPicasso.setAdapter(picassoListviewAdapter);
public class PicassoListviewAdapter extends BaseAdapter {

    private Context mContext;

    public PicassoListviewAdapter(Context context) {
        mContext = context;
    }

    @Override
    public int getCount() {
        return Constants.IMAGES.length;
    }

    @Override
    public Object getItem(int position) {
        return null;
    }

    @Override
    public long getItemId(int position) {
        return 0;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder holder;
        if(convertView == null) {
            convertView = View.inflate(mContext, R.layout.item_picasso_listview,null);

            holder = new ViewHolder(convertView);

            convertView.setTag(holder);
        }else {
            holder = (ViewHolder) convertView.getTag();
        }

        // 名称
        holder.name.setText("item"+(position+1));

        // 加载图片
        Picasso.with(mContext)
                .load(Constants.IMAGES[position])
                .placeholder(R.drawable.atguigu_logo)
                .error(R.drawable.atguigu_logo)
                .into(holder.iv);

        return convertView;
    }

    class ViewHolder{
        @Bind(R.id.iv_picasso_item)
        ImageView iv;

        @Bind(R.id.tv_picasso_name)
        TextView name;

        public ViewHolder(View view) {
            ButterKnife.bind(this,view);
        }
    }
}


 3）转换案例

 private void initData() {
        // 标题
        tvTitle.setText("Picasso的转换操作");

        List<String> data = new ArrayList<>();

        for (int i = 1; i<= 36; i++){
            data.add(i+"");
        }

        // 初始化listview
        PicassoTransformationsAdapter picassoTransformationsAdapter = new PicassoTransformationsAdapter(PicassoTransfromationsActivity.this,data);

        lvPicassoTransfromations.setAdapter(picassoTransformationsAdapter);
    }
public class PicassoTransformationsAdapter extends BaseAdapter {
    private Context mContext;
    private List<String> mData;

    public PicassoTransformationsAdapter(Context context, List<String> data) {
        mContext = context;
        mData = data;
    }

    @Override
    public int getCount() {
        return mData == null ? 0 : mData.size();
    }

    @Override
    public Object getItem(int position) {
        return null;
    }

    @Override
    public long getItemId(int position) {
        return 0;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {

        ViewHolder holder;
        if(convertView == null) {
            convertView = View.inflate(mContext, R.layout.item_picasso_transformations,null);

            holder = new ViewHolder(convertView);

            convertView.setTag(holder);
        }else {
            holder = (ViewHolder) convertView.getTag();
        }

        // 显示名称
        holder.name.setText("item"+(position + 1));

        int integer = Integer.parseInt(mData.get(position));

        switch (integer) {

            case 1: {
                int width = Utils.dip2px(mContext, 133.33f);
                int height = Utils.dip2px(mContext, 126.33f);
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .resize(width, height)
                        .centerCrop()
                        .transform((new MaskTransformation(mContext, R.drawable.mask_starfish)))
                        .into(holder.image);
                break;
            }
            case 2: {
                int width = Utils.dip2px(mContext, 150.0f);
                int height = Utils.dip2px(mContext, 100.0f);
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .resize(width, height)
                        .centerCrop()
                        .transform(new MaskTransformation(mContext, R.drawable.chat_me_mask))
                        .into(holder.image);
                break;
            }
            case 3:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.LEFT,
                                CropTransformation.GravityVertical.TOP))
                        .into(holder.image);
                break;
            case 4:
                Picasso.with(mContext).load(R.drawable.demo)
                        // 300, 100, CropTransformation.GravityHorizontal.LEFT, CropTransformation.GravityVertical.CENTER))
                        .transform(new CropTransformation(300, 100)).into(holder.image);
                break;
            case 5:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.LEFT,
                                CropTransformation.GravityVertical.BOTTOM))
                        .into(holder.image);
                break;
            case 6:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.TOP))
                        .into(holder.image);
                break;
            case 7:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100))
                        .into(holder.image);
                break;
            case 8:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.BOTTOM))
                        .into(holder.image);
                break;
            case 9:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.RIGHT,
                                CropTransformation.GravityVertical.TOP))
                        .into(holder.image);
                break;
            case 10:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.RIGHT,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 11:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(300, 100, CropTransformation.GravityHorizontal.RIGHT,
                                CropTransformation.GravityVertical.BOTTOM))
                        .into(holder.image);
                break;
            case 12:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation((float) 16 / (float) 9,
                                CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 13:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation((float) 4 / (float) 3,
                                CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 14:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(3, CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 15:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(3, CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.TOP))
                        .into(holder.image);
                break;
            case 16:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation(1, CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 17:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation((float) 0.5, (float) 0.5,
                                CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 18:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation((float) 0.5, (float) 0.5,
                                CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.TOP))
                        .into(holder.image);
                break;
            case 19:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation((float) 0.5, (float) 0.5,
                                CropTransformation.GravityHorizontal.RIGHT,
                                CropTransformation.GravityVertical.BOTTOM))
                        .into(holder.image);
                break;
            case 20:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropTransformation((float) 0.5, 0, (float) 4 / (float) 3,
                                CropTransformation.GravityHorizontal.CENTER,
                                CropTransformation.GravityVertical.CENTER))
                        .into(holder.image);
                break;
            case 21:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropSquareTransformation())
                        .into(holder.image);
                break;
            case 22:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new CropCircleTransformation())
                        .into(holder.image);
                break;
            case 23:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new ColorFilterTransformation(Color.argb(80, 255, 0, 0)))
                        .into(holder.image);
                break;
            case 24:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new GrayscaleTransformation())
                        .into(holder.image);
                break;
            case 25:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new RoundedCornersTransformation(30, 0,
                                RoundedCornersTransformation.CornerType.BOTTOM_LEFT))
                        .into(holder.image);
                break;
            case 26:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new BlurTransformation(mContext, 25, 1))
                        .into(holder.image);
                break;
            case 27:
                Picasso.with(mContext)
                        .load(R.drawable.demo)
                        .transform(new ToonFilterTransformation(mContext))
                        .into(holder.image);
                break;
            case 28:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new SepiaFilterTransformation(mContext))
                        .into(holder.image);
                break;
            case 29:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new ContrastFilterTransformation(mContext, 2.0f))
                        .into(holder.image);
                break;
            case 30:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new InvertFilterTransformation(mContext))
                        .into(holder.image);
                break;
            case 31:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new PixelationFilterTransformation(mContext, 20))
                        .into(holder.image);
                break;
            case 32:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new SketchFilterTransformation(mContext))
                        .into(holder.image);
                break;
            case 33:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new SwirlFilterTransformation(mContext, 0.5f, 1.0f, new PointF(0.5f, 0.5f)))
                        .into(holder.image);

                break;
            case 34:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new BrightnessFilterTransformation(mContext, 0.5f))
                        .into(holder.image);
                break;
            case 35:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new KuwaharaFilterTransformation(mContext, 25))
                        .into(holder.image);
                break;
            case 36:
                Picasso.with(mContext)
                        .load(R.drawable.check)
                        .transform(new VignetteFilterTransformation(mContext, new PointF(0.5f, 0.5f),
                                new float[]{0.0f, 0.0f, 0.0f}, 0f, 0.75f))
                        .into(holder.image);
                break;
        }
        
        return convertView;
    }

    class ViewHolder{

        @Bind(R.id.iv_picasso)
        ImageView image;

        @Bind(R.id.tv_picasso)
        TextView name;

        public ViewHolder(View view) {

            ButterKnife.bind(this, view);
        }
    }
}

工具类

public class Utils {
    public static int dip2px(Context context, float dp) {
        float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dp * scale + 0.5f);
    }
}

提供一个工具类

public class PicassoUtil {
    //加载本地图片
    public static void setImg(Context context, int resId, ImageView imgView){
        Picasso.with(context)
                .load(resId)
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .fit()
                .into(imgView);
    }
    //按照一定的宽高加载本地图片，带有加载错误和默认图片
    public static void setImg(Context context,int resId,ImageView imgView,int weight,int height){
        Picasso.with(context)
                .load(resId)//加载本地图片
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .resize(weight,height)//设置图片的宽高
                .into(imgView);//把图片加载到控件上
    }
    //加载网络图片到imgview,带有加载错误和默认图片
    public static void setImg(Context context, String imgurl, int resId, ImageView imgView){
        Picasso.with(context)
                .load(imgurl)//加载网络图片的url
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .placeholder(resId)//默认图片
                .error(resId)//加载错误的图片
                .fit()//图片的宽高等于控件的宽高
                .into(imgView);//把图片加载到控件上
    }
    public static void setImg(Context context, String imgurl, ImageView imgView){
        Picasso.with(context)
                .load(imgurl)//加载网络图片的url
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .fit()//图片的宽高等于控件的宽高
                .into(imgView);//把图片加载到控件上
    }
    //加载网络图片到Viewpager
    public static void setImg(Context context, String imgurl, ViewPager imgView){
        Picasso.with(context)
                .load(imgurl)//加载网络图片的url
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .fit()//图片的宽高等于控件的宽高
                .into((Target) imgView);//把图片加载到控件上
    }
    //加载网络图片到Viewpager，带有加载错误和默认图片
    public static void setImg(Context context, String imgurl, int resId, ViewPager imgView){
        Picasso.with(context)
                .load(imgurl)//加载网络图片的url
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .placeholder(resId)//默认图片
                .error(resId)//加载错误的图片
                .fit()//图片的宽高等于控件的宽高
                .into((Target) imgView);//把图片加载到控件上
    }
    //按照设定的宽高加载网络图片到imgview
    public static void setImg(Context context, String imgurl,ImageView imgView,int weight,int height){
        Picasso.with(context)
                .load(imgurl)//加载网络图片的url
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .resize(weight,height)//设置图片的宽高
                .into(imgView);//把图片加载到控件上
    }
    //按照设定的宽高加载网络图片到imgview，带有加载错误和默认图片
    public static void setImg(Context context, String imgurl, int resId,int weight,int height, ImageView imgView){
        Picasso.with(context)
                .load(imgurl)//加载网络图片的url
                .config(Bitmap.Config.RGB_565)//8位RGB位图
                .placeholder(resId)//默认图片
                .error(resId)//加载错误的图片
                .resize(weight,height)//设置图片的宽高
                .into(imgView);//把图片加载到控件上
    }
}




jlhaoran
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android图片加载框架之Picasso非常好的图片加载缓存库
03-15
**Android图片加载框架 Picasso** 在Android应用开发中，图片加载是一项至关重要的任务，尤其是在处理大量图片数据时，如社交应用、电商应用等。为了解决这个问题，开发者们通常会使用图片加载库，其中Picasso是一...
图片加载框架－Picasso最详细的使用指南
weixin_34378922的博客
02-26 723
写在前面 Android 中有几个比较有名的图片加载框架，Universal ImageLoader、Picasso、Glide和Fresco。它们各有优点，以前一直用的是ImageLoader 做项目中的图片加载，由于作者宣布ImageLoader 不会在更新了，因此新的项目打算换一个图片加载框架－Picasso, Picasso 是Square 公司开源的Android 端的图片加载和缓存框架...
Picasso图片加载框架源码解析
我的博客
06-29 644
众所周知，由于的手机的内部存储比较小，因此手机中运行的app一般能得到的分配的内存也很小，因此app开发中
图片加载利器之Picasso（四）源码解析
landptf的博客
03-10 400
看到了这里，相信大家对Picasso的使用已经比较熟悉了，本篇博客中将从基本的用法着手，逐步的深入了解其设计原理。Picasso的代码量在众多的开源框架中算得上非常少的一个了，一共只有35个class文件，但是麻雀虽小，五脏俱全。好了下面跟随我的脚步，出发了～～～基本用法Picasso.with(this).load(imageUrl).into(imageView);with(t
图片加载框架－Picasso最详细的使用指南，Android高级工程师面试题-字节跳动
最新发布
芯_v_648374雨馨博客
04-03 338
其实客户端开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。（以下体系的复习资料是我从各路大佬收集整理好的）《Android开发七大模块核心知识笔记》《960全网最全Android开发笔记》《379页Android开发面试宝典》历时半年，我们整理了这份市面上最全面的安卓面试题解析大全包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。
picasso源码简单解析
枯水的博客
10-22 177
只分析最常用的使用方式Picasso.with(MainActivity.this).load(uri).into(img); 这里只分析该语句涉及的部分，至于图形变换等其他操作不分析。   public static Picasso with(Context context) {   if (singleton == null) {     synchronized (Picasso.cl
Android图片加载利器之Picasso基本用法
08-31
在Android开发中，图片加载是一个非常重要的方面，因而出现了许多图片加载框架，例如UniversalImageLoader、Picasso、Glide、Fresco等。其中，Picasso是Square公司出品的图片加载框架，具有使用简单、扩展性强等特点...
Android-很简单的android图片加载框架Picasso
08-13
**Android 图片加载框架 Picasso 深度解析** 在 Android 应用开发中，图片的加载、缓存和展示是一项非常重要的任务。Picasso 是一个由 Square 公司开发的简单易用的图片加载库，它极大地简化了 Android 应用中的...
Android中图片加载框架Picasso的使用
05-08
Picasso是一个由Square公司开发的流行图片加载库，它简化了图片的加载、缓存和显示过程。本文将深入探讨Picasso在Android中的使用方法，以及如何利用它来优化图片处理。 首先，我们来看一下Picasso的基本用法。在...
Picasso
蜕变的快乐
07-20 647
Picasso的使用及其原理介绍 如下就是Picasso最简单的例子，我们在使用的时候就是这么简单，直接with、load、into // 普通加载图片 Picasso.with(PicassoActivity.this) .load("http://n.sinaimg.cn/transl
图片加载之Picasso使用
一花一世界的博客
05-18 9436
简介 Picasso是Square公司开源的一个Android图形缓存库，可以实现图片下载和缓存功能。 主要有以下一些特性： 在Adapter中回收和取消已经不在视野范围图片资源的加载，防止可能出现的图片错位； 使用复杂的图片压缩转换来尽可能的减少内存消耗； 使用最少的内存完成复杂的图形转换操作； 自带内存和硬盘缓存； 可加载网络或本地资源。 GitHub地址： https:
Android 使用Picasso加载图片,并获取到图片,加载图片监听
sungeAndroid的博客
03-01 3608
图片加载框架Picasso都很熟悉,也很好用一行代码就加载到图片了 Picasso.with(Context).load(url).into(显示图片的控件); 这样是没办法获取到加载的图片的,因为是异步的不知道什么时候图片加载成功了 Picasso.with(mContext).load(path).into(mTarget); private Target mTarge
Android-Picasso 库中找不到 .with() 方法
圆号本号
05-28 2230
今天学习了 Frasco Glide 等开源库的用法，结果用到 Picasso 的时候卡壳了，其他库都是用 .with() 方法，获得调用他们的活动，偏偏 Picasso 死活出不来这方法 网上查了一通都是没问题的，于是推测应该是版本更新了，于是查了下官方文档：https：//github.com/square/picasso/commit/e7e919232fe2b15772a7fc...
Android 图片加载框架之Picasso
weixin_39492854的博客
04-01 810
一、简介 Picasso是Square公司出品的一个强大的图片下载和缓存图片库 1）在adapter中需要取消已经不在视野范围的ImageView图片资源的加载，否则会导致图片错位，Picasso已经解决了这个问题。 2）使用复杂的图片压缩转换来尽可能的减少内存消耗 3）自带内存和硬盘二级缓存功能 二、下载地址 ...
安卓图片处理Picasso的解析使用
Losileeya
01-31 1万+
前言今天来学习使用一下毕加索（Picasso），Picasso是个什么鬼？有什么作用？ Picasso其实是Android系统的图片下载和缓存类库，是Square开源的一个用于Android系统下载和缓存图片的项目。下面我们就来讲讲在Android开发中，Picasso有哪些特性及如何使用。简介： Picasso是Square公司开源的一个Android图形缓存库。可以实现图片
图片下载框架Picasso实现原理解析（上）
scholarSu
07-20 2646
Picasso框架解析 一.Picasso功能：   图片加载 二.Picasso使用： 最简单的是Picasso.with(Context).load(Url).into(ImageView)，Context是环境（不管是什么Context，在Picasso里都会转  化为application的context），URL则为要下载的图片地址，ImageView是要显示图片的view。
Picasso使用示例（四种来源途径下加载图片，附demo）
热门推荐
打工仔的博客
10-15 1万+
一.直接上代码（四种来源途径下加载图片） 1》 package com.zhc.picasso; import java.io.File; import com.squareup.picasso.Picasso; import android.net.Uri; import android.os.Bundle; import android.os.Environment; import
android-------非常好的图片加载框架和缓存库(Picasso)
weixin_33965305的博客
03-15 117
2019独角兽企业重金招聘Python工程师标准>>> ...
Picasso的详细使用
qq_28152841的博客
03-09 486
先扯下淡，还记得前年下半年的时候我开始接触并使用Glide。 使用Glide的原因很简单，网络上各种夸Glide怎么怎么好，比如加载图片省内存，比如可以加载GIF图片，谷歌推荐使用等等。可是现在我又发现一个比较怪异的现象，网上大批的人开始说picasso怎么怎么好了，比如内存也可以很小，而且包小方法数少，可以减少发生64k的问题。先说说我当时使用glide的时候发生的问题，比如缓存到本地的图片根本
Picasso：Android高效图片加载指南
本书专注于讲解Picasso图片加载框架，旨在帮助开发者快速构建图像丰富的应用程序。Picasso是Android平台上的一款流行且功能强大的图片加载库，它简化了图片加载过程，提供了高效、易用的接口。 本书主要包含以下几...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值