u013718120
u013718120

Android瀑布流照片墙实现，体验不规则排列的美感



本文转载于：http://blog.csdn.net/guolin_blog/article/details/10470797

传统界面的布局方式总是行列分明、坐落有序的，这种布局已是司空见惯，在不知不觉中大家都已经对它产生了审美疲劳。这个时候瀑布流布局的出现，就给人带来了耳目一新的感觉，这种布局虽然看上去貌似毫无规律，但是却有一种说不上来的美感，以至于涌现出了大批的网站和应用纷纷使用这种新颖的布局来设计界面。

记得我在之前已经写过一篇关于如何在Android上实现照片墙功能的文章了，但那个时候是使用的GridView来进行布局的，这种布局方式只适用于“墙”上的每张图片大小都相同的情况，如果图片的大小参差不齐，在GridView中显示就会非常的难看。而使用瀑布流的布局方式就可以很好地解决这个问题，因此今天我们也来赶一下潮流，看看如何在Android上实现瀑布流照片墙的功能。

首先还是讲一下实现原理，瀑布流的布局方式虽然看起来好像排列的很随意，其实它是有很科学的排列规则的。整个界面会根据屏幕的宽度划分成等宽的若干列，由于手机的屏幕不是很大，这里我们就分成三列。每当需要添加一张图片时，会将这张图片的宽度压缩成和列一样宽，再按照同样的压缩比例对图片的高度进行压缩，然后在这三列中找出当前高度最小的一列，将图片添加到这一列中。之后每当需要添加一张新图片时，都去重复上面的操作，就会形成瀑布流格局的照片墙，示意图如下所示。

                                        Android瀑布流照片墙实现，体验不规则排列的美感_第1张图片

Center.jpg (22.93 KB, 下载次数: 427)

下载附件  保存到相册

2013-9-6 13:52 上传

听我这么说完后，你可能会觉得瀑布流的布局非常简单嘛，只需要使用三个LinearLayout平分整个屏幕宽度，然后动态地addView()进去就好了。确实如此，如果只是为了实现功能的话，就是这么简单。可是别忘了，我们是在手机上进行开发，如果不停地往LinearLayout里添加图片，程序很快就会OOM。因此我们还需要一个合理的方案来对图片资源进行释放，这里仍然是准备使用LruCache算法，对这个算法不熟悉的朋友可以先参考Android高效加载大图、多图方案，有效避免程序OOM。

下面我们就来开始实现吧，新建一个Android项目，起名叫PhotoWallFallsDemo，并选择4.0的API。

第一个要考虑的问题是，我们到哪儿去收集这些大小参差不齐的图片呢？这里我事先在百度上搜索了很多张风景图片，并且为了保证它们访问的稳定性，我将这些图片都上传到了我的CSDN相册里，因此只要从这里下载图片就可以了。新建一个Images类，将所有相册中图片的网址都配置进去，代码如下所示：

  1. <font color="#333333"><font face="Arial">public class Images {

  3.         public final static String[] imageUrls = new String[] {
  4.                         "http://img.my.csdn.net/uploads/201309/01/1378037235_3453.jpg",
  5.                         "http://img.my.csdn.net/uploads/201309/01/1378037235_7476.jpg",
  6.                         "http://img.my.csdn.net/uploads/201309/01/1378037235_9280.jpg",
  7.                         "http://img.my.csdn.net/uploads/201309/01/1378037234_3539.jpg",
  8.                         "http://img.my.csdn.net/uploads/201309/01/1378037234_6318.jpg",
  9.                         "http://img.my.csdn.net/uploads/201309/01/1378037194_2965.jpg",
  10.                         "http://img.my.csdn.net/uploads/201309/01/1378037193_1687.jpg",
  11.                         "http://img.my.csdn.net/uploads/201309/01/1378037193_1286.jpg",
  12.                         "http://img.my.csdn.net/uploads/201309/01/1378037192_8379.jpg",
  13.                         "http://img.my.csdn.net/uploads/201309/01/1378037178_9374.jpg",
  14.                         "http://img.my.csdn.net/uploads/201309/01/1378037177_1254.jpg",
  15.                         "http://img.my.csdn.net/uploads/201309/01/1378037177_6203.jpg",
  16.                         "http://img.my.csdn.net/uploads/201309/01/1378037152_6352.jpg",
  17.                         "http://img.my.csdn.net/uploads/201309/01/1378037151_9565.jpg",
  18.                         "http://img.my.csdn.net/uploads/201309/01/1378037151_7904.jpg",
  19.                         "http://img.my.csdn.net/uploads/201309/01/1378037148_7104.jpg",
  20.                         "http://img.my.csdn.net/uploads/201309/01/1378037129_8825.jpg",
  21.                         "http://img.my.csdn.net/uploads/201309/01/1378037128_5291.jpg",
  22.                         "http://img.my.csdn.net/uploads/201309/01/1378037128_3531.jpg",
  23.                         "http://img.my.csdn.net/uploads/201309/01/1378037127_1085.jpg",
  24.                         "http://img.my.csdn.net/uploads/201309/01/1378037095_7515.jpg",
  25.                         "http://img.my.csdn.net/uploads/201309/01/1378037094_8001.jpg",
  26.                         "http://img.my.csdn.net/uploads/201309/01/1378037093_7168.jpg",
  27.                         "http://img.my.csdn.net/uploads/201309/01/1378037091_4950.jpg",
  28.                         "http://img.my.csdn.net/uploads/201308/31/1377949643_6410.jpg",
  29.                         "http://img.my.csdn.net/uploads/201308/31/1377949642_6939.jpg",
  30.                         "http://img.my.csdn.net/uploads/201308/31/1377949630_4505.jpg",
  31.                         "http://img.my.csdn.net/uploads/201308/31/1377949630_4593.jpg",
  32.                         "http://img.my.csdn.net/uploads/201308/31/1377949629_7309.jpg",
  33.                         "http://img.my.csdn.net/uploads/201308/31/1377949629_8247.jpg",
  34.                         "http://img.my.csdn.net/uploads/201308/31/1377949615_1986.jpg",
  35.                         "http://img.my.csdn.net/uploads/201308/31/1377949614_8482.jpg",
  36.                         "http://img.my.csdn.net/uploads/201308/31/1377949614_3743.jpg",
  37.                         "http://img.my.csdn.net/uploads/201308/31/1377949614_4199.jpg",
  38.                         "http://img.my.csdn.net/uploads/201308/31/1377949599_3416.jpg",
  39.                         "http://img.my.csdn.net/uploads/201308/31/1377949599_5269.jpg",
  40.                         "http://img.my.csdn.net/uploads/201308/31/1377949598_7858.jpg",
  41.                         "http://img.my.csdn.net/uploads/201308/31/1377949598_9982.jpg",
  42.                         "http://img.my.csdn.net/uploads/201308/31/1377949578_2770.jpg",
  43.                         "http://img.my.csdn.net/uploads/201308/31/1377949578_8744.jpg",
  44.                         "http://img.my.csdn.net/uploads/201308/31/1377949577_5210.jpg",
  45.                         "http://img.my.csdn.net/uploads/201308/31/1377949577_1998.jpg",
  46.                         "http://img.my.csdn.net/uploads/201308/31/1377949482_8813.jpg",
  47.                         "http://img.my.csdn.net/uploads/201308/31/1377949481_6577.jpg",
  48.                         "http://img.my.csdn.net/uploads/201308/31/1377949480_4490.jpg",
  49.                         "http://img.my.csdn.net/uploads/201308/31/1377949455_6792.jpg",
  50.                         "http://img.my.csdn.net/uploads/201308/31/1377949455_6345.jpg",
  51.                         "http://img.my.csdn.net/uploads/201308/31/1377949442_4553.jpg",
  52.                         "http://img.my.csdn.net/uploads/201308/31/1377949441_8987.jpg",
  53.                         "http://img.my.csdn.net/uploads/201308/31/1377949441_5454.jpg",
  54.                         "http://img.my.csdn.net/uploads/201308/31/1377949454_6367.jpg",
  55.                         "http://img.my.csdn.net/uploads/201308/31/1377949442_4562.jpg" };
  56. }</font></font>
复制代码
然后新建一个ImageLoader类，用于方便对图片进行管理，代码如下所示：
  1. <font color="#333333"><font face="Arial">public class ImageLoader {

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

  8.         /**
  9.          * ImageLoader的实例。
  10.          */
  11.         private static ImageLoader mImageLoader;

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

  26.         /**
  27.          * 获取ImageLoader的实例。
  28.          *
  29.          * @return ImageLoader的实例。
  30.          */
  31.         public static ImageLoader getInstance() {
  32.                 if (mImageLoader == null) {
  33.                         mImageLoader = new ImageLoader();
  34.                 }
  35.                 return mImageLoader;
  36.         }

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

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

  63.         public static int calculateInSampleSize(BitmapFactory.Options options,
  64.                         int reqWidth) {
  65.                 // 源图片的宽度
  66.                 final int width = options.outWidth;
  67.                 int inSampleSize = 1;
  68.                 if (width > reqWidth) {
  69.                         // 计算出实际宽度和目标宽度的比率
  70.                         final int widthRatio = Math.round((float) width / (float) reqWidth);
  71.                         inSampleSize = widthRatio;
  72.                 }
  73.                 return inSampleSize;
  74.         }

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

  89. }</font></font>
复制代码
这里我们将ImageLoader类设成单例，并在构造函数中初始化了LruCache类，把它的最大缓存容量设为最大可用内存的1/8。然后又提供了其它几个方法可以操作LruCache，以及对图片进行压缩和读取。接下来新建MyScrollView继承自ScrollView，代码如下所示：
  1. public class MyScrollView extends ScrollView implements OnTouchListener {

  3.         /**
  4.          * 每页要加载的图片数量
  5.          */
  6.         public static final int PAGE_SIZE = 15;

  8.         /**
  9.          * 记录当前已加载到第几页
  10.          */
  11.         private int page;

  13.         /**
  14.          * 每一列的宽度
  15.          */
  16.         private int columnWidth;

  18.         /**
  19.          * 当前第一列的高度
  20.          */
  21.         private int firstColumnHeight;

  23.         /**
  24.          * 当前第二列的高度
  25.          */
  26.         private int secondColumnHeight;

  28.         /**
  29.          * 当前第三列的高度
  30.          */
  31.         private int thirdColumnHeight;

  33.         /**
  34.          * 是否已加载过一次layout，这里onLayout中的初始化只需加载一次
  35.          */
  36.         private boolean loadOnce;

  38.         /**
  39.          * 对图片进行管理的工具类
  40.          */
  41.         private ImageLoader imageLoader;

  43.         /**
  44.          * 第一列的布局
  45.          */
  46.         private LinearLayout firstColumn;

  48.         /**
  49.          * 第二列的布局
  50.          */
  51.         private LinearLayout secondColumn;

  53.         /**
  54.          * 第三列的布局
  55.          */
  56.         private LinearLayout thirdColumn;

  58.         /**
  59.          * 记录所有正在下载或等待下载的任务。
  60.          */
  61.         private static Set<LoadImageTask> taskCollection;

  63.         /**
  64.          * MyScrollView下的直接子布局。
  65.          */
  66.         private static View scrollLayout;

  68.         /**
  69.          * MyScrollView布局的高度。
  70.          */
  71.         private static int scrollViewHeight;

  73.         /**
  74.          * 记录上垂直方向的滚动距离。
  75.          */
  76.         private static int lastScrollY = -1;

  78.         /**
  79.          * 记录所有界面上的图片，用以可以随时控制对图片的释放。
  80.          */
  81.         private List<ImageView> imageViewList = new ArrayList<ImageView>();

  83.         /**
  84.          * 在Handler中进行图片可见性检查的判断，以及加载更多图片的操作。
  85.          */
  86.         private static Handler handler = new Handler() {

  88.                 public void handleMessage(android.os.Message msg) {
  89.                         MyScrollView myScrollView = (MyScrollView) msg.obj;
  90.                         int scrollY = myScrollView.getScrollY();
  91.                         // 如果当前的滚动位置和上次相同，表示已停止滚动
  92.                         if (scrollY == lastScrollY) {
  93.                                 // 当滚动的最底部，并且当前没有正在下载的任务时，开始加载下一页的图片
  94.                                 if (scrollViewHeight + scrollY >= scrollLayout.getHeight()
  95.                                                 && taskCollection.isEmpty()) {
  96.                                         myScrollView.loadMoreImages();
  97.                                 }
  98.                                 myScrollView.checkVisibility();
  99.                         } else {
  100.                                 lastScrollY = scrollY;
  101.                                 Message message = new Message();
  102.                                 message.obj = myScrollView;
  103.                                 // 5毫秒后再次对滚动位置进行判断
  104.                                 handler.sendMessageDelayed(message, 5);
  105.                         }
  106.                 };

  108.         };

  110.         /**
  111.          * MyScrollView的构造函数。
  112.          *
  113.          * @param context
  114.          * @param attrs
  115.          */
  116.         public MyScrollView(Context context, AttributeSet attrs) {
  117.                 super(context, attrs);
  118.                 imageLoader = ImageLoader.getInstance();
  119.                 taskCollection = new HashSet<LoadImageTask>();
  120.                 setOnTouchListener(this);
  121.         }

  123.         /**
  124.          * 进行一些关键性的初始化操作，获取MyScrollView的高度，以及得到第一列的宽度值。并在这里开始加载第一页的图片。
  125.          */
  126.         @Override
  127.         protected void onLayout(boolean changed, int l, int t, int r, int b) {
  128.                 super.onLayout(changed, l, t, r, b);
  129.                 if (changed && !loadOnce) {
  130.                         scrollViewHeight = getHeight();
  131.                         scrollLayout = getChildAt(0);
  132.                         firstColumn = (LinearLayout) findViewById(R.id.first_column);
  133.                         secondColumn = (LinearLayout) findViewById(R.id.second_column);
  134.                         thirdColumn = (LinearLayout) findViewById(R.id.third_column);
  135.                         columnWidth = firstColumn.getWidth();
  136.                         loadOnce = true;
  137.                         loadMoreImages();
  138.                 }
  139.         }

  141.         /**
  142.          * 监听用户的触屏事件，如果用户手指离开屏幕则开始进行滚动检测。
  143.          */
  144.         @Override
  145.         public boolean onTouch(View v, MotionEvent event) {
  146.                 if (event.getAction() == MotionEvent.ACTION_UP) {
  147.                         Message message = new Message();
  148.                         message.obj = this;
  149.                         handler.sendMessageDelayed(message, 5);
  150.                 }
  151.                 return false;
  152.         }

  154.         /**
  155.          * 开始加载下一页的图片，每张图片都会开启一个异步线程去下载。
  156.          */
  157.         public void loadMoreImages() {
  158.                 if (hasSDCard()) {
  159.                         int startIndex = page * PAGE_SIZE;
  160.                         int endIndex = page * PAGE_SIZE + PAGE_SIZE;
  161.                         if (startIndex < Images.imageUrls.length) {
  162.                                 Toast.makeText(getContext(), "正在加载...", Toast.LENGTH_SHORT)
  163.                                                 .show();
  164.                                 if (endIndex > Images.imageUrls.length) {
  165.                                         endIndex = Images.imageUrls.length;
  166.                                 }
  167.                                 for (int i = startIndex; i < endIndex; i++) {
  168.                                         LoadImageTask task = new LoadImageTask();
  169.                                         taskCollection.add(task);
  170.                                         task.execute(Images.imageUrls[i]);
  171.                                 }
  172.                                 page++;
  173.                         } else {
  174.                                 Toast.makeText(getContext(), "已没有更多图片", Toast.LENGTH_SHORT)
  175.                                                 .show();
  176.                         }
  177.                 } else {
  178.                         Toast.makeText(getContext(), "未发现SD卡", Toast.LENGTH_SHORT).show();
  179.                 }
  180.         }

  182.         /**
  183.          * 遍历imageViewList中的每张图片，对图片的可见性进行检查，如果图片已经离开屏幕可见范围，则将图片替换成一张空图。
  184.          */
  185.         public void checkVisibility() {
  186.                 for (int i = 0; i < imageViewList.size(); i++) {
  187.                         ImageView imageView = imageViewList.get(i);
  188.                         int borderTop = (Integer) imageView.getTag(R.string.border_top);
  189.                         int borderBottom = (Integer) imageView
  190.                                         .getTag(R.string.border_bottom);
  191.                         if (borderBottom > getScrollY()
  192.                                         && borderTop < getScrollY() + scrollViewHeight) {
  193.                                 String imageUrl = (String) imageView.getTag(R.string.image_url);
  194.                                 Bitmap bitmap = imageLoader.getBitmapFromMemoryCache(imageUrl);
  195.                                 if (bitmap != null) {
  196.                                         imageView.setImageBitmap(bitmap);
  197.                                 } else {
  198.                                         LoadImageTask task = new LoadImageTask(imageView);
  199.                                         task.execute(imageUrl);
  200.                                 }
  201.                         } else {
  202.                                 imageView.setImageResource(R.drawable.empty_photo);
  203.                         }
  204.                 }
  205.         }

  207.         /**
  208.          * 判断手机是否有SD卡。
  209.          *
  210.          * @return 有SD卡返回true，没有返回false。
  211.          */
  212.         private boolean hasSDCard() {
  213.                 return Environment.MEDIA_MOUNTED.equals(Environment
  214.                                 .getExternalStorageState());
  215.         }

  217.         /**
  218.          * 异步下载图片的任务。
  219.          *
  220.          * @author guolin
  221.          */
  222.         class LoadImageTask extends AsyncTask<String, Void, Bitmap> {

  224.                 /**
  225.                  * 图片的URL地址
  226.                  */
  227.                 private String mImageUrl;

  229.                 /**
  230.                  * 可重复使用的ImageView
  231.                  */
  232.                 private ImageView mImageView;

  234.                 public LoadImageTask() {
  235.                 }

  237.                 /**
  238.                  * 将可重复使用的ImageView传入
  239.                  *
  240.                  * @param imageView
  241.                  */
  242.                 public LoadImageTask(ImageView imageView) {
  243.                         mImageView = imageView;
  244.                 }

  246.                 @Override
  247.                 protected Bitmap doInBackground(String... params) {
  248.                         mImageUrl = params[0];
  249.                         Bitmap imageBitmap = imageLoader
  250.                                         .getBitmapFromMemoryCache(mImageUrl);
  251.                         if (imageBitmap == null) {
  252.                                 imageBitmap = loadImage(mImageUrl);
  253.                         }
  254.                         return imageBitmap;
  255.                 }

  257.                 @Override
  258.                 protected void onPostExecute(Bitmap bitmap) {
  259.                         if (bitmap != null) {
  260.                                 double ratio = bitmap.getWidth() / (columnWidth * 1.0);
  261.                                 int scaledHeight = (int) (bitmap.getHeight() / ratio);
  262.                                 addImage(bitmap, columnWidth, scaledHeight);
  263.                         }
  264.                         taskCollection.remove(this);
  265.                 }

  267.                 /**
  268.                  * 根据传入的URL，对图片进行加载。如果这张图片已经存在于SD卡中，则直接从SD卡里读取，否则就从网络上下载。
  269.                  *
  270.                  * @param imageUrl
  271.                  *            图片的URL地址
  272.                  * @return 加载到内存的图片。
  273.                  */
  274.                 private Bitmap loadImage(String imageUrl) {
  275.                         File imageFile = new File(getImagePath(imageUrl));
  276.                         if (!imageFile.exists()) {
  277.                                 downloadImage(imageUrl);
  278.                         }
  279.                         if (imageUrl != null) {
  280.                                 Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(
  281.                                                 imageFile.getPath(), columnWidth);
  282.                                 if (bitmap != null) {
  283.                                         imageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
  284.                                         return bitmap;
  285.                                 }
  286.                         }
  287.                         return null;
  288.                 }

  290.                 /**
  291.                  * 向ImageView中添加一张图片
  292.                  *
  293.                  * @param bitmap
  294.                  *            待添加的图片
  295.                  * @param imageWidth
  296.                  *            图片的宽度
  297.                  * @param imageHeight
  298.                  *            图片的高度
  299.                  */
  300.                 private void addImage(Bitmap bitmap, int imageWidth, int imageHeight) {
  301.                         LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
  302.                                         imageWidth, imageHeight);
  303.                         if (mImageView != null) {
  304.                                 mImageView.setImageBitmap(bitmap);
  305.                         } else {
  306.                                 ImageView imageView = new ImageView(getContext());
  307.                                 imageView.setLayoutParams(params);
  308.                                 imageView.setImageBitmap(bitmap);
  309.                                 imageView.setScaleType(ScaleType.FIT_XY);
  310.                                 imageView.setPadding(5, 5, 5, 5);
  311.                                 imageView.setTag(R.string.image_url, mImageUrl);
  312.                                 findColumnToAdd(imageView, imageHeight).addView(imageView);
  313.                                 imageViewList.add(imageView);
  314.                         }
  315.                 }

  317.                 /**
  318.                  * 找到此时应该添加图片的一列。原则就是对三列的高度进行判断，当前高度最小的一列就是应该添加的一列。
  319.                  *
  320.                  * @param imageView
  321.                  * @param imageHeight
  322.                  * @return 应该添加图片的一列
  323.                  */
  324.                 private LinearLayout findColumnToAdd(ImageView imageView,
  325.                                 int imageHeight) {
  326.                         if (firstColumnHeight <= secondColumnHeight) {
  327.                                 if (firstColumnHeight <= thirdColumnHeight) {
  328.                                         imageView.setTag(R.string.border_top, firstColumnHeight);
  329.                                         firstColumnHeight += imageHeight;
  330.                                         imageView.setTag(R.string.border_bottom, firstColumnHeight);
  331.                                         return firstColumn;
  332.                                 }
  333.                                 imageView.setTag(R.string.border_top, thirdColumnHeight);
  334.                                 thirdColumnHeight += imageHeight;
  335.                                 imageView.setTag(R.string.border_bottom, thirdColumnHeight);
  336.                                 return thirdColumn;
  337.                         } else {
  338.                                 if (secondColumnHeight <= thirdColumnHeight) {
  339.                                         imageView.setTag(R.string.border_top, secondColumnHeight);
  340.                                         secondColumnHeight += imageHeight;
  341.                                         imageView
  342.                                                         .setTag(R.string.border_bottom, secondColumnHeight);
  343.                                         return secondColumn;
  344.                                 }
  345.                                 imageView.setTag(R.string.border_top, thirdColumnHeight);
  346.                                 thirdColumnHeight += imageHeight;
  347.                                 imageView.setTag(R.string.border_bottom, thirdColumnHeight);
  348.                                 return thirdColumn;
  349.                         }
  350.                 }

  352.                 /**
  353.                  * 将图片下载到SD卡缓存起来。
  354.                  *
  355.                  * @param imageUrl
  356.                  *            图片的URL地址。
  357.                  */
  358.                 private void downloadImage(String imageUrl) {
  359.                         HttpURLConnection con = null;
  360.                         FileOutputStream fos = null;
  361.                         BufferedOutputStream bos = null;
  362.                         BufferedInputStream bis = null;
  363.                         File imageFile = null;
  364.                         try {
  365.                                 URL url = new URL(imageUrl);
  366.                                 con = (HttpURLConnection) url.openConnection();
  367.                                 con.setConnectTimeout(5 * 1000);
  368.                                 con.setReadTimeout(15 * 1000);
  369.                                 con.setDoInput(true);
  370.                                 con.setDoOutput(true);
  371.                                 bis = new BufferedInputStream(con.getInputStream());
  372.                                 imageFile = new File(getImagePath(imageUrl));
  373.                                 fos = new FileOutputStream(imageFile);
  374.                                 bos = new BufferedOutputStream(fos);
  375.                                 byte[] b = new byte[1024];
  376.                                 int length;
  377.                                 while ((length = bis.read(b)) != -1) {
  378.                                         bos.write(b, 0, length);
  379.                                         bos.flush();
  380.                                 }
  381.                         } catch (Exception e) {
  382.                                 e.printStackTrace();
  383.                         } finally {
  384.                                 try {
  385.                                         if (bis != null) {
  386.                                                 bis.close();
  387.                                         }
  388.                                         if (bos != null) {
  389.                                                 bos.close();
  390.                                         }
  391.                                         if (con != null) {
  392.                                                 con.disconnect();
  393.                                         }
  394.                                 } catch (IOException e) {
  395.                                         e.printStackTrace();
  396.                                 }
  397.                         }
  398.                         if (imageFile != null) {
  399.                                 Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(
  400.                                                 imageFile.getPath(), columnWidth);
  401.                                 if (bitmap != null) {
  402.                                         imageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
  403.                                 }
  404.                         }
  405.                 }

  407.                 /**
  408.                  * 获取图片的本地存储路径。
  409.                  *
  410.                  * @param imageUrl
  411.                  *            图片的URL地址。
  412.                  * @return 图片的本地存储路径。
  413.                  */
  414.                 private String getImagePath(String imageUrl) {
  415.                         int lastSlashIndex = imageUrl.lastIndexOf("/");
  416.                         String imageName = imageUrl.substring(lastSlashIndex + 1);
  417.                         String imageDir = Environment.getExternalStorageDirectory()
  418.                                         .getPath() + "/PhotoWallFalls/";
  419.                         File file = new File(imageDir);
  420.                         if (!file.exists()) {
  421.                                 file.mkdirs();
  422.                         }
  423.                         String imagePath = imageDir + imageName;
  424.                         return imagePath;
  425.                 }
  426.         }

  428. }
复制代码
MyScrollView是实现瀑布流照片墙的核心类，这里我来重点给大家介绍一下。首先它是继承自ScrollView的，这样就允许用户可以通过滚动的方式来浏览更多的图片。这里提供了一个loadMoreImages()方法，是专门用于加载下一页的图片的，因此在onLayout()方法中我们要先调用一次这个方法，以初始化第一页的图片。然后在onTouch方法中每当监听到手指离开屏幕的事件，就会通过一个handler来对当前ScrollView的滚动状态进行判断，如果发现已经滚动到了最底部，就会再次调用loadMoreImages()方法去加载下一页的图片。那我们就要来看一看loadMoreImages()方法的内部细节了。在这个方法中，使用了一个循环来加载这一页中的每一张图片，每次都会开启一个LoadImageTask，用于对图片进行异步加载。然后在LoadImageTask中，首先会先检查一下这张图片是不是已经存在于SD卡中了，如果还没存在，就从网络上下载，然后把这张图片存放在LruCache中。接着将这张图按照一定的比例进行压缩，并找出当前高度最小的一列，把压缩后的图片添加进去就可以了。另外，为了保证照片墙上的图片都能够合适地被回收，这里还加入了一个可见性检查的方法，即checkVisibility()方法。这个方法的核心思想就是检查目前照片墙上的所有图片，判断出哪些是可见的，哪些是不可见。然后将那些不可见的图片都替换成一张空图，这样就可以保证程序始终不会占用过高的内存。当这些图片又重新变为可见的时候，只需要再从LruCache中将这些图片重新取出即可。如果某张图片已经从LruCache中被移除了，就会开启一个LoadImageTask，将这张图片重新加载到内存中。然后打开或新建activity_main.xml，在里面设置好瀑布流的布局方式，如下所示：
  1. <com.example.photowallfallsdemo.MyScrollView xmlns:android="http://schemas.android.com/apk/res/android"
  2.     android:id="@+id/my_scroll_view"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent" >

  6.     <LinearLayout
  7.         android:layout_width="match_parent"
  8.         android:layout_height="wrap_content"
  9.         android:orientation="horizontal" >

  11.         <LinearLayout
  12.             android:id="@+id/first_column"
  13.             android:layout_width="0dp"
  14.             android:layout_height="wrap_content"
  15.             android:layout_weight="1"
  16.             android:orientation="vertical" >
  17.         </LinearLayout>

  19.         <LinearLayout
  20.             android:id="@+id/second_column"
  21.             android:layout_width="0dp"
  22.             android:layout_height="wrap_content"
  23.             android:layout_weight="1"
  24.             android:orientation="vertical" >
  25.         </LinearLayout>

  27.         <LinearLayout
  28.             android:id="@+id/third_column"
  29.             android:layout_width="0dp"
  30.             android:layout_height="wrap_content"
  31.             android:layout_weight="1"
  32.             android:orientation="vertical" >
  33.         </LinearLayout>
  34.     </LinearLayout>

  36. </com.example.photowallfallsdemo.MyScrollView>
复制代码
可以看到，这里我们使用了刚才编写好的MyScrollView作为根布局，然后在里面放入了一个直接子布局LinearLayout用于统计当前滑动布局的高度，然后在这个布局下又添加了三个等宽的LinearLayout分别作为第一列、第二列和第三列的布局，这样在MyScrollView中就可以动态地向这三个LinearLayout里添加图片了。
最后，由于我们使用到了网络和SD卡存储的功能，因此还需要在AndroidManifest.xml中添加以下权限：
  1.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  2.     <uses-permission android:name="android.permission.INTERNET" />
复制代码
这样我们所有的编码工作就已经完成了，现在可以尝试运行一下，效果如下图所示：                                

20130904201515703.jpg (1.72 MB, 下载次数: 463)

下载附件  保存到相册

2013-9-6 13:52 上传


瀑布流模式的照片墙果真非常美观吧，而且由于我们有非常完善的资源释放机制，不管你在照片墙上添加了多少图片，程序占用内存始终都会保持在一个合理的范围内

你可能感兴趣的:(android,内存,图片,布局)

  • HarmonyNext实战：基于ArkTS的高性能数据流处理系统开发 harmonyos-next
    HarmonyNext实战：基于ArkTS的高性能数据流处理系统开发引言在HarmonyNext生态系统中，数据流处理是一个关键的技术领域。本文将深入探讨如何使用ArkTS构建一个高性能的数据流处理系统，重点讲解流式数据处理、并发模型、内存管理以及性能优化等高级主题。我们将通过一个实际的案例——实时日志分析系统，来展示如何将这些技术应用到实际工程中。系统架构设计我们的实时日志分析系统需要处理来自多
  • 鸿蒙Next，图片上传01（扩展02截图保存到相册）-组件截图另通过沙箱保存到相册 harmonyos
    1.componentSnapShot组件截图的get方法，得到PixelMap像素图像数据@ohos.arkui.componentSnapshot(组件截图)-UI界面-ArkTSAPI-ArkUI（方舟UI框架）-应用框架-华为HarmonyOS开发者//进行截图constpixelMap=awaitcomponentSnapshot.get('share')2.ImagePacker打包P
  • 元戎启行最新战略RoadAGI：所有移动智能体都将被AI驱动 量子位
    2025年3月18日（北京时间），元戎启行作为国内人工智能企业代表，出席由NVIDIA主办的GTC大会。会上，公司CEO周光发表了技术主题演讲，展示了公司的最新战略布局RoadAGI，并发布道路通用人工智能平台——AISpark（以下简称”Spark平台”）。RoadAGI是元戎启行实现物理世界通用人工智能的关键一步，旨在让包括智能驾驶汽车在内的移动智能体，都具有在道路上自主行驶、与物理世界深度交
  • 【python】可变、不可变数据类型 qianx77 pythonpythonnumpy开发语言
    文章目录python可变、不可变数据类型一、什么是可变和不可变的数据类型？二、不可变类型1.数字2.字符3.元组三、可变类型4.列表需要注意的点5.集合5.字典6.补充-深拷贝和浅拷贝总结python可变、不可变数据类型用于记录python数据类型python我个人常用的数据就是数字、字符串、元组、列表、集合、字典，分为可变类型和不可变类型。一、什么是可变和不可变的数据类型？可变就是说在相同内存地
  • HarmonyOS NEXT 用户首选项（Preferences）在应用开发中的应用与机制 架构教育
    在移动应用开发中，用户首选项（Preferences）是一种常见的数据存储方式，用于保存用户的个性化设置或应用的配置信息。类似于Android中的SharedPreferences，Preferences以键值对（Key-Value）的形式将数据存储在应用的内存和本地文件中。本文将详细介绍Preferences的概念、运作机制、API使用以及相关的限制。一、用户首选项（Preferences）的概
  • ComPDFKit PDF SDK V1.6.0 新功能: 直接编辑PDF内的文字和图片! pdfsdkedittext
    支持的平台:iOSAndroidWindows新功能：编辑文字:添加、修改、删除PDF文件中的文字，支持设置PDF文件中原文字的大小、位置、颜色、对齐方式等Addedtextalignmentintextediting,includinglefttextalignment,righttextalignment,centertextalignment,andjustifytextalignment.
  • 基于android平台的斗地主AI 清源Eamonmon cocos2d-x学习笔记
    本软件是基于android平台的斗地主AI，我们在源代码的基础之上，旨在改进AI的算法，使玩家具有更丰富的体验感，让NPC可以更为智能。（一）玩法解析：（1）发牌和叫牌：一副扑克54张，先为每个人发17张，剩下的3张作为底牌，玩家视自己手中的牌来确定自己是否叫牌。按顺序叫牌，谁出的分多谁就是地主，一般分数有1分，2分，3分。地主的底牌需要给其他玩家看过后才能拿到手中，最后地主20张牌，农民分别17
  • YashanDB资源类型 数据库
    ashanDB资源管理通过配置物理资源（CPU、内存等）的分配规则，以满足不同用户或程序对资源的需求：CPU资源管理适用于单机部署（非级联备）和分布式部署，且适用于LINUX和ARM平台，不适用于docker容器。内存资源管理适用于单机部署（非级联备）和分布式部署。并行执行资源适用于单机部署（非级联备）和分布式部署。CPU资源管理YashanDB的CPU资源管理用于保证数据库在稳定运行的前提下，保
  • C++ 类和对象 友元 内部类 this指针 默认成员函数 初始化列表…… azaz_plus C++c++类和对象this指针默认成员函数友元初始化列表内部类
    1.类和对象的基本概念类：用户自定义的数据类型，包含数据成员（属性）和成员函数（方法）。对象：类的实例，占用内存空间，具有类中定义的属性和方法。示例：classDog{//定义类public:std::stringname;//属性intage;voidbark(){//方法std::coutdraw();//输出：Drawingacircle（多态）deleteshape;return0;}4.
  • 小米5miui10android,小米又一款手机适配Android 10！MIUI开发版暂停，米粉别着急！... weixin_39843677
    2020年3月看到市场上的智能手机又要迎来一波新形势，更多厂家开始在手机的外观、形态、材质上下功夫。2月发布的小米10系列，几次开卖总是遇到抢购无货状态，看来雷军的高端手机市场卓有成效。除了硬件之外，手机系统其实还是挺重要的，日常体验才是王道。看到iOS最近几次测试版的更新不如人意，bug太多就是日常应用也会有适配兼容难的现象，卡顿闪退带来的效果总是不太好，影响用户去正常使用手机。再看看安卓阵营，
  • 使用multiprocessing实现进程间共享内存 培根芝士 Pythonpython
    在Python中，可以使用多种方法来实现几个进程之间的通信。简单消息传递：使用multiprocessing.Queue或multiprocessing.Pipe。共享简单数据：使用multiprocessing.Value或multiprocessing.Array。共享复杂数据：使用multiprocessing.Manager。进程间信号控制：使用multiprocessing.Event。
  • Jetpack组件在MVVM架构中的应用 Ya-Jun 架构android
    Jetpack组件在MVVM架构中的应用一、引言Jetpack是Android官方推出的一套开发组件工具集，它能够帮助开发者构建高质量、可维护的Android应用。本文将深入探讨Jetpack核心组件在MVVM架构中的应用。二、ViewModel组件2.1ViewModel基本原理ViewModel是MVVM架构中最重要的组件之一，它具有以下特点：生命周期感知数据持久化避免内存泄漏2.2ViewM
  • 嵌入式八股，为什么单片机中不使用malloc函数 skeete 单片机嵌入式硬件
    1.资源限制单片机的内存资源通常非常有限，尤其是RAM的大小可能只有几KB到几十KB。在这种情况下，使用malloc进行动态内存分配可能会导致内存碎片化，使得程序在运行过程中逐渐耗尽可用内存。2.内存碎片问题malloc函数在分配和释放内存时容易产生内存碎片。内存碎片分为外部碎片和内部碎片：外部碎片：即使总空闲空间足够，但由于碎片化，无法分配足够大的连续内存块。内部碎片：分配的内存块可能比实际需求
  • 自动生成二维码（根据文本内容）——CAD c#二次开发 山水CAD筑梦人 CADC#二次开发c#数据库服务器
    用户输入文本内容，运行插件生成二维码（jpg图片格式），扫码即可显示文本内容。※※※也可根据excel文件内容批量一键生成上万个二维码。※※※效果如下：首先需要引用库usingZXing;部分代码如下：publicclass二维码{internalstaticListtempFiles=newList();privatestaticPoint3dcurrentInsertPoint=newPoin
  • python 使用Nginx和uWSGI来运行Python应用 weixin_33738555 运维python操作系统
    参考：http://zmrenwu.com/post/20/uWSGI是一个Web应用服务器，它具有应用服务器，代理，进程管理及应用监控等功能。它支持WSGI协议，同时它也支持自有的uWSGI协议，该协议据说性能非常高，而且内存占用率低，为mod_wsgi的一半左右，我没有实测过。它还支持多应用的管理及应用的性能监控。虽然uWSGI本身就可以直接用来当Web服务器，但一般建议将其作为应用服务器配合
  • Python中常见的抓取图片的方法 qq_31397725 python开发语言
    在Python中，抓取图片的方法可以根据你的具体需求和使用场景有所不同。以下是一些常见的方法：使用requests库从URL下载图片：这是最常见的方法，适用于从网络上的URL下载图片。你可以使用requests库发送HTTP请求，然后将响应的内容保存到本地文件中。使用selenium库抓取网页中的图片：如果你需要从一个动态加载的网页中抓取图片，selenium可以帮助你模拟浏览器行为，等待页面加载
  • 如何运用python爬虫爬取图片素材网站的图片？（附完整代码） 大懒猫软件 vue.jspython网络爬虫图像处理bash
    在当今数字化时代，高质量的图片资源对于设计师、开发者以及任何需要视觉素材的用户来说都至关重要。壁纸社作为一个提供丰富壁纸资源的网站，涵盖了从普通高清到4K、5K甚至8K超高清的多种分辨率，满足了不同用户的需求。然而，手动下载这些壁纸不仅耗时，而且效率低下。因此，开发一个自动化爬虫程序，批量下载高质量壁纸，不仅能节省时间，还能提高工作效率。本文将详细介绍如何使用Python爬虫技术从壁纸社爬取并保存
  • 【网络爬虫】(2) requests模块，案例：网络图片爬取，附Python代码 立Sir 网络爬虫爬虫python
    1.基本原理1.1requests模块requests是Python中一个非常流行的HTTP客户端库，用于发送所有的HTTP请求类型。它基于urllib，但比urllib更易用。中文文档地址：Requests:让HTTP服务人类—Requests2.18.1文档（1）requests.get(url,**kwargs)requests.get()函数是requests库中用于发送HTTPGET请求
  • 如何绕开浏览器批量下载的限制 露露在前端 前端javascripthtml状态模式学习面试vue.js
    前言最近遇到一个需求，需要将批量选择的图片，批量一个个下载。触发单个下载在浏览器中触发下载，我们可以借用a元素来触发。constdownloadFile=async(url:string,name:string)=>{constres=awaitfetch(url);constblob=awaitres.blob();conststrList=url.split('.');consttype=st
  • Linux运维技术之Linux云计算架构 极客事纪 Linux《Linux一学就会》程序员linux运维服务器
    我以下图为基础，说明Linux的架构(architecture)。最内层是硬件，最外层是用户常用的应用，比如说firefox浏览器，evolution查看邮件，一个计算流体模型等等。硬件是物质基础，而应用提供服务。但在两者之间，还要经过一番周折。还记得Linux启动。Linux首先启动内核(kernel)，内核是一段计算机程序，这个程序直接管理管理硬件，包括CPU、内存空间、硬盘接口、网络接口等等
  • 三分钟让你搞懂云计算中的CDN是什么？ 云上的阿七 云计算
    随着互联网的快速发展，网站的访问速度和稳定性越来越受到重视。而在众多提升网站性能的技术中，CDN（内容分发网络）无疑是一个非常重要的工具。今天，我们就来聊聊云计算中的CDN是什么，以及它是如何为网站带来显著好处的。CDN是什么？CDN，全称ContentDeliveryNetwork，翻译过来就是“内容分发网络”。它是一种分布式的网络架构，通过将网站的静态资源（如图片、视频、JavaScript文
  • 高可用Keepalived在Linux中的应用 「已注销」 linux运维服务器高可用集群keepalivedcentos
    目录一、高可用1.高可用介绍（1）普通理解（2）专业理解2.高可用目的3.高可用实现1.介绍2.特点三、Keepalived1.介绍2.Keepalived核心组件（1）VRRPstack（2）NetLink接口（3）IPVSWrapper（4）checkers（5）systemcall（6）SMTP（7）watchDog3.控制组件4.内存管理四、Keepalived核心概念1.虚拟路由器2.m
  • 北约人工智能战略举措与影响分析 岛屿旅人 网络安全人工智能行业分析人工智能网络网络安全web安全安全
    文章目录前言一、顶层规划，明确发展方向（一）发布《人工智能战略》，明确AI发展方向和行动指南（二）适应当前需求，适时更新《人工智能战略》（三）制定《数据利用框架政策》，提供政策指导和基础支持二、政策配套，推动细化落实（一）成立北约数据和审查委员会，推动人工智能转化应用（二）成立新兴和颠覆技术咨询小组，指导创新与成果转化（三）成立北约创新委员会，引领前沿技术研究三、加强投资，促进生态布局（一）启动北
  • C语言的数据：变量、常量、数据类型及其使用 c++
    目录引言变量与常量1.1变量1.2常量数据类型关键字C语言基本数据类型3.1整型（int）3.1.1定义与含义3.1.2内存占用和取值范围3.1.3声明和初始化3.1.4运算操作3.1.5实际应用场景3.2浮点型（float和double）3.2.1定义与含义3.2.2内存占用和取值范围3.2.3声明和初始化3.2.4运算操作3.2.5实际应用场景3.3字符型（char）3.3.1定义与含义3.3
  • 124.HarmonyOS NEXT 数字滚动动画详解(四)：性能优化指南 harmonyos-next
    温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT数字滚动动画详解(四)：性能优化指南效果演示1.性能优化概述数字滚动组件的性能优化主要从以下几个方面考虑：渲染性能动画性能内存管理状态更新2.渲染优化2.1ForEach优化//优化写法：使用ForEachForEach(this.cu
  • RTX3060帧率优化与电竞级配置实战 智能计算研究中心 其他
    内容概要《RTX3060帧率优化与电竞级配置实战》围绕NVIDIAGeForceRTX3060显卡的性能释放展开，系统梳理从硬件适配到软件调校的全链路优化策略。内容涵盖显卡驱动参数的精细化设置、游戏画质与帧率平衡的实战技巧，以及1080P与2K分辨率下的帧率对比测试数据。此外，针对电竞场景需求，文章详细解析了CPU、内存与散热系统的协同配置方案，确保硬件组合在高负载下的稳定性。核心章节优化方向显卡
  • iOS进程增加内存上限的接口 memory
    1）iOS进程增加内存上限的接口2）.sommap内存占用排查的问题3）在使用RecastNavigation遇到的两个问题这是第420篇UWA技术知识分享的推送，精选了UWA社区的热门话题，涵盖了UWA问答、社区帖子等技术知识点，助力大家更全面地掌握和学习。UWA社区主页：community.uwa4d.comUWAQQ群：793972859MemoryQ：在打iOS包的时候注意到Xcode里有
  • 【操作系统之对换技术详解】 武帝为此 操作系统服务器网络
    文章目录一、前言二、对换技术的原理1.什么是对换（Swapping）？2.为什么需要对换？三、对换的工作过程1️⃣内存不足，触发对换2️⃣将内存中的数据写入磁盘3️⃣释放内存4️⃣数据交换回内存四、对换与分页的区别五、对换的优缺点✅优点：❌缺点：六、现代操作系统中的对换✅1️⃣LinuxSwap分区✅2️⃣Windows虚拟内存七、总结一、前言在操作系统中，对换（Swapping）是一种将内存与磁
  • Android通过uri 获取文件路径 迷路国王 Android知识
    话不多说，通过uri获取文件路径遇到了很多坑，但也最终解决了，直接上代码。importandroid.content.ContentResolver;importandroid.content.ContentUris;importandroid.content.Context;importandroid.database.Cursor;importandroid.net.Uri;importand
  • C++核心编程手册 易方达蓝筹 Cor计算机网络c++开发语言后端
    C++核心编程本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。1内存分区模型C++程序在执行时，将内存大方向划分为4个区域代码区：存放函数体的二进制代码，由操作系统进行管理的全局区：存放全局变量和静态变量以及常量栈区：由编译器自动分配释放,存放函数的参数值,局部变量等堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收内存四区意义：不同区域存放的数据，赋予不
  • java类加载顺序 3213213333332132 java
    package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
  • Hibernate与mybitas的比较 BlueSkator sqlHibernate框架ibatisorm
    第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
  • php多维数组排序以及实际工作中的应用 dcj3sjt126com PHPusortuasort
    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
  • DOM改变字体大小 周华华 前端
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • c3p0的配置 g21121 c3p0
    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 以在spring中配置dataSource为例： <!-- spring加载资源文件 --> <bean name="prope
  • Java获取工程路径的几种方法 510888780 java
    第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
  • 在类Unix系统下实现SSH免密码登录服务器 Harry642 免密ssh
    1.客户机     (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址     (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址     (3)执行cat
  • Java新手入门的30个基本概念一 aijuans javajava 入门新手
    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
  • Memcached for windows 简单介绍 antlove javaWebwindowscachememcached
    1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
  • 数据库对象的视图和索引 百合不是茶 索引oeacle数据库视图
      视图     视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图       为什么oracle需要视图;    &
  • Mockito(一) --入门篇 bijian1013 持续集成mockito单元测试
            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。  &nb
  • 精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle数据库plsql
    /* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
  • 【Log4j一】Log4j总体介绍 bit1129 log4j
    Log4j组件：Logger、Appender、Layout   Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 日志的输出目标 日志的输出格式 日志的输出级别(是否抑制日志的输出)  logger继承特性 A logger is said to be an ancestor of anothe
  • Java IO笔记 白糖_ java
    public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
  • Docker 监控 ronin47 docker监控
             目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 额外的，因为是docker的
  • java-顺时针打印图形 bylijinnan java
    一个画图程序 要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
  • 关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   # ${HOME} will be replaced by user home directory accordin
  • [并行计算]论宇宙的可计算性 comsci 并行计算
          现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......       那么,这种概念让我们推论出一个结论     &nb
  • 用OpenGL实现无限循环的coverflow dai_lm androidcoverflow
    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
  • JAVA数据计算的几个解决方案1 datamachine javaHibernate计算
    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线-------------------------------------     数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J  &nbs
  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
    怎么创建一个简单的(非 RBAC)用户授权系统 通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 在配置文件(一般为 protecte
  • 未选之路 dcj3sjt126com 诗
    作者:罗伯特*费罗斯特   黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处.   但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹.   那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
  • Java处理15位身份证变18位 蕃薯耀 18位身份证变15位15位身份证变18位身份证转换
      15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。   Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml   <!-- 激活自动代理功能 参看：
  • Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScripthtmlandroid脚本
      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序    要在webview中,调用addJavascriptInterface(OBJ,int
  • 8个最佳Web开发资源推荐 lampcy 编程Web程序员
    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 这里列出10个最佳Web开发资源，它们都是受
  • 架构师之面试------jdk的hashMap实现 nannan408 HashMap
    1.前言。   如题。 2.详述。   (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
  • html禁止清除input文本输入缓存 Rainbow702 html缓存input输入框change
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。 如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off";  <input type="text" autocomplete="off" n
  • POJO和JavaBean的区别和联系 tjmljw POJOjava beans
    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
  • java中单例的五种写法 liuxiaoling java单例
    /** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、 双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他