Java 如何在URLEncode过程后加载图像

在我的

onPostExecute

过程中，我使用以下方法从服务器获取图像路径：

String image = c.getString(Constants.TAG_Image);

在字符串

image

中，我得到如下数据：bertho joris.png或我的名字bertho.jpg

String encodedURL = URLEncoder.encode(image,"UTF-8");
String validImage = "http://www.example.com/image/"+encodedURL;

但是当我使用

urlcoder

函数时，我的图像不会显示在listview上。我使用类

ImageLoader

：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;

import com.berthojoris.bacaberita.R;

public class ImageLoader {

    MemoryCache memoryCache=new MemoryCache();
    FileCache fileCache;
    private Map<ImageView, String> imageViews=Collections.synchronizedMap(new WeakHashMap<ImageView, String>());
    ExecutorService executorService;

    public ImageLoader(Context context){
        fileCache=new FileCache(context);
        executorService=Executors.newFixedThreadPool(5);
    }

    final int stub_id = R.drawable.not_found;
    public void DisplayImage(String url, ImageView imageView)
    {
        imageViews.put(imageView, url);
        Bitmap bitmap=memoryCache.get(url);
        if(bitmap!=null)
            imageView.setImageBitmap(bitmap);
        else
        {
            queuePhoto(url, imageView);
            imageView.setImageResource(stub_id);
        }
    }

    private void queuePhoto(String url, ImageView imageView)
    {
        PhotoToLoad p=new PhotoToLoad(url, imageView);
        executorService.submit(new PhotosLoader(p));
    }

    private Bitmap getBitmap(String url)
    {
        File f=fileCache.getFile(url);

        //from SD cache
        Bitmap b = decodeFile(f);
        if(b!=null)
            return b;

        //from web
        try {
            Bitmap bitmap=null;
            URL imageUrl = new URL(url);
            HttpURLConnection conn = (HttpURLConnection)imageUrl.openConnection();
            conn.setConnectTimeout(30000);
            conn.setReadTimeout(30000);
            conn.setInstanceFollowRedirects(true);
            InputStream is=conn.getInputStream();
            OutputStream os = new FileOutputStream(f);
            Utils.CopyStream(is, os);
            os.close();
            bitmap = decodeFile(f);
            return bitmap;
        } catch (Exception ex){
           ex.printStackTrace();
           return null;
        }
    }

    //decodes image and scales it to reduce memory consumption
    private Bitmap decodeFile(File f){
        try {
            //decode image size
            BitmapFactory.Options o = new BitmapFactory.Options();
            o.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(new FileInputStream(f),null,o);

            //Find the correct scale value. It should be the power of 2.
            final int REQUIRED_SIZE=70;
            int width_tmp=o.outWidth, height_tmp=o.outHeight;
            int scale=1;
            while(true){
                if(width_tmp/2<REQUIRED_SIZE || height_tmp/2<REQUIRED_SIZE)
                    break;
                width_tmp/=2;
                height_tmp/=2;
                scale*=2;
            }

            //decode with inSampleSize
            BitmapFactory.Options o2 = new BitmapFactory.Options();
            o2.inSampleSize=scale;
            return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
        } catch (FileNotFoundException e) {}
        return null;
    }

    //Task for the queue
    private class PhotoToLoad
    {
        public String url;
        public ImageView imageView;
        public PhotoToLoad(String u, ImageView i){
            url=u;
            imageView=i;
        }
    }

    class PhotosLoader implements Runnable {
        PhotoToLoad photoToLoad;
        PhotosLoader(PhotoToLoad photoToLoad){
            this.photoToLoad=photoToLoad;
        }

        @Override
        public void run() {
            if(imageViewReused(photoToLoad))
                return;
            Bitmap bmp=getBitmap(photoToLoad.url);
            memoryCache.put(photoToLoad.url, bmp);
            if(imageViewReused(photoToLoad))
                return;
            BitmapDisplayer bd=new BitmapDisplayer(bmp, photoToLoad);
            Activity a=(Activity)photoToLoad.imageView.getContext();
            a.runOnUiThread(bd);
        }
    }

    boolean imageViewReused(PhotoToLoad photoToLoad){
        String tag=imageViews.get(photoToLoad.imageView);
        if(tag==null || !tag.equals(photoToLoad.url))
            return true;
        return false;
    }

    //Used to display bitmap in the UI thread
    class BitmapDisplayer implements Runnable
    {
        Bitmap bitmap;
        PhotoToLoad photoToLoad;
        public BitmapDisplayer(Bitmap b, PhotoToLoad p){bitmap=b;photoToLoad=p;}
        public void run()
        {
            if(imageViewReused(photoToLoad))
                return;
            if(bitmap!=null)
                photoToLoad.imageView.setImageBitmap(bitmap);
            else
                photoToLoad.imageView.setImageResource(stub_id);
        }
    }

    public void clearCache() {
        memoryCache.clear();
        fileCache.clear();
    }

}

导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.net.HttpURLConnection；
导入java.net.URL；
导入java.util.Collections；
导入java.util.Map；
导入java.util.WeakHashMap；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入android.app.Activity；
导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.widget.ImageView；
进口公司berthojoris.bacaberita.R；
公共类图像加载器{
MemoryCache MemoryCache=新的MemoryCache（）；
文件缓存文件缓存；
private Map ImageView=Collections.synchronizedMap（新的WeakHashMap（））；
执行服务执行服务；
公共图像加载器（上下文）{
fileCache=新的fileCache（上下文）；
executorService=Executors.newFixedThreadPool（5）；
}
最终int stub_id=R.drawable.not_found；
public void DisplayImage（字符串url，ImageView）
{
put（imageView，url）；
位图位图=memoryCache.get（url）；
if（位图！=null）
设置图像位图（位图）；
其他的
{
队列照片（url、imageView）；
setImageResource（存根id）；
}
}
私有void队列照片（字符串url，ImageView）
{
PhotoToLoad p=新的PhotoToLoad（url，imageView）；
executorService.submit（新的PhotoLoader（p））；
}
私有位图getBitmap（字符串url）
{
文件f=fileCache.getFile（url）；
//从SD缓存
位图b=解码文件（f）；
如果（b！=null）
返回b；
//从网络
试一试{
位图=空；
URL imageUrl=新URL（URL）；
HttpURLConnection conn=（HttpURLConnection）imageUrl.openConnection（）；
连接设置连接超时（30000）；
连接设置读取超时（30000）；
conn.setInstanceFollowRedirects（真）；
InputStream is=conn.getInputStream（）；
OutputStream os=新文件OutputStream（f）；
Utils.CopyStream（is，os）；
os.close（）；
位图=解码文件（f）；
返回位图；
}捕获（例外情况除外）{
例如printStackTrace（）；
返回null；
}
}
//对图像进行解码和缩放以减少内存消耗
私有位图解码文件（文件f）{
试一试{
//解码图像大小
BitmapFactory.Options o=新的BitmapFactory.Options（）；
o、 inJustDecodeBounds=true；
解码流（新的FileInputStream（f），null，o）；
//找到正确的刻度值。它应该是2的幂。
所需的最终int_尺寸=70；
内部宽度=o.向外宽度，高度=o.向外高度；
int标度=1；
while（true）{
如果（width_tmp/2我使用了这个类，它正在工作

您是否在
Async
.class的
onPostExecute
函数中调用此函数（
loader.DisplayImage（url，imageView）

如果可以，请检查您的图像URL（请在日志中写入图像URL并控制它，因为我有一次犯了这个错误）。
图像是以延迟方式加载的，因此您需要添加延迟加载适配器以获取图像信息

互联网上有多种解决方案，但速度快且易于使用

这是一个虚拟数据，用于获取图像信息

Aquery mAQuery 

mAquery=new AQuery(getApplicationContext());

mAquery.id(ImageVie).image(string of your imageview,true,true,400,0,null,0,0.0f);

我建议您将毕加索用于android，并检查无限列表视图API。