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,内存,图片,布局)

  • 集装箱箱号自动识别算法，启智畅想AI应用 启智畅想 集装箱号码识别集装箱识别集装箱号OCR识别集装箱号码识别深度学习ocr计算机视觉人工智能
    集装箱箱号识别技术能够自动快速的记录集装箱号码，在记录集装箱号码的同时，也保存了当时采集到的集装箱照片，通过私有化部署API的方式和后台系统进行对接，当车辆进出通道时，相机自动检测箱号，实时、自动检测号码后，通过后台服务器进行识别获取各个号码，按照每组信息直接同步进入后台系统，大大提高效率的同时，在后续出现错误的时候，也可以通过调用现场采集的图片进行比对核实，这样不仅大大提高了效率，解放了人力，还
  • 全面分析 DeepSeek 的新开源 FlashMLA X.Cristiano FlashMLA深度学习人工智能
    导言著名的人工智能公司DeepSeek最近开源了FlashMLA，这是一款针对HopperGPU上的多头潜意识（MLA）进行了优化的高性能解码内核。这一进展对于大型语言模型（LLM）来说意义重大，因为大型语言模型在推理过程中面临内存和计算方面的挑战，尤其是长序列。本报告深入探讨了FlashMLA的技术细节、性能指标、应用和未来影响，为研究人员、开发人员和人工智能爱好者提供了全面的了解。背景介绍多头
  • 【Python爬虫教程】进阶篇-16 app自动化测试appium 「已注销」 python爬虫逆向教程python爬虫appium网络爬虫网络安全
    Appium是一个跨平台移动端自动化测试工具，可以非常便捷地为iOS和Android平台创建自动化测试用例。它可以模拟App内部的各种操作，如点击、滑动、文本输入等，只要我们手工操作的动作Appium都可以完成。在前面我们了解过Selenium，它是一个网页端的自动化测试工具。Appium实际上继承了Selenium，Appium也是利用WebDriver来实现App的自动化测试。对iOS设备来说
  • 云原生周刊：云原生和 AI 云计算
    开源项目推荐FlashMLADeepSeek于北京时间2025年2月24日上午9点正式开源了FlashMLA项目。FlashMLA是专为NVIDIAHopper架构GPU（如H100、H800）优化的高效多头潜在注意力（MLA）解码内核，旨在提升大模型推理性能，特别是针对可变长度序列进行了优化。性能表现：在NVIDIAH800SXM5GPU上，FlashMLA展现了卓越的性能：内存带宽：高达300
  • Android开发兼容性问题3万字保姆级教程(Android版本、屏幕、多语言、硬件、第三方库、权限） 大模型大数据攻城狮 androidandroid面试安卓面试android兼容性android多版本分辨率兼容androidUI
    目录第一章Android版本兼容性1.1版本众多的挑战1.2设置版本参数1.3API版本检测1.4兼容性实例使用minSdkVersion和targetSdkVersion1.5版本更新的应对策略第二章屏幕尺寸与分辨率兼容性2.1屏幕尺寸的多样性2.2响应式布局2.3drawable资源管理使用尺寸单位2.4屏幕尺寸实例2.4.1实例背景2.4.2UI布局适配2.4.3图片资源适配2.4.4实例效
  • 配置nginx反向代理时，要注意的权限设置 Codes_AndyLiu 杂谈nginx服务器bufferheadertomcatfile
    MYPM演示环境(www.mypm.cc/mypm)中当下载大的附件，或是页面中有大图片时，就会下载中断或是图版无法显示也许你要说我用的nginx缺省的设置没碰到这问题，那是因为你的网站没大文件查看nginx日志failed(13:Permissiondenied)whilereadingupstream怪了为什么说没权限呢，当时这问题搞了2个多小时，在这期间不得不用tomcat当代理服务器引出了
  • 十年磨一剑：站在面试官角度聊聊现下大环境面试，“野生”程序员现阶段面试问题 & 学习误区 2401_84149896 程序员面试学习职场和发展
    3.Hook**Hook的选择点：**静态变量和单例，因为一旦创建对象，它们不容易变化，非常容易定位。Hook过程：寻找Hook点，原则是静态变量或者单例对象，尽量Hookpublic的对象和方法。选择合适的代理方式，如果是接口可以用动态代理。偷梁换柱——用代理对象替换原始对象。多数插件化也使用的Hook技术4.内存泄漏构造单例的时候尽量别用Activity的引用；静态引用时注意应用对象的置空或者
  • css 实现图片3D旋转效果（那些年写过的转圈圈） Venus865 css前端
    css实现图片旋转效果还是很容易的，不说废话直接上，先看下效果实现起来也不复杂，主要用到的css样式有：transform-style,transform,animation,-webkit-box-reflect，会在代码里一一介绍，如下.container{width:800px;height:600px;border:1pxsolidrgba(0,0,0,0.1);display:flex;
  • HoRain云--如何在Java中使用HTTP代理 HoRain 云小助手 javahttp开发语言
    HoRain云小助手：个人主页⛺️生活的理想，就是为了理想的生活!⛳️推荐前些天发现了一个超棒的服务器购买网站，性价比超高，大内存超划算！忍不住分享一下给大家。点击跳转到网站。目录⛳️推荐一、全局代理设置（所有网络请求生效）1.1启动参数配置（推荐）1.2代码动态配置二、原生HttpURLConnection代理配置2.1基础代理设置2.2认证自动处理三、ApacheHttpClient5.x代理
  • 数据结构及算法介绍 lw1994wl #数据结构及算法数据结构算法
    数据结构及算法介绍一、数组与字符串定义数组：一种线性数据结构，用于存储一组相同类型的元素。字符串：字符的有序集合，本质上是一个字符数组。特点数组：元素在内存中连续存储。支持随机访问（通过索引）。插入和删除操作效率较低（需要移动元素）。字符串：不可变性（如Java中的String是不可变对象）。支持拼接、分割、匹配等操作。应用场景数组：存储固定大小的数据集合（如成绩列表）。字符串：文本处理（如搜索、
  • 【Python爬虫(82)】开启物联网数据爬取之旅 奔跑吧邓邓子 Python爬虫python爬虫物联网开发语言
    【Python爬虫】专栏简介：本专栏是Python爬虫领域的集大成之作，共100章节。从Python基础语法、爬虫入门知识讲起，深入探讨反爬虫、多线程、分布式等进阶技术。以大量实例为支撑，覆盖网页、图片、音频等各类数据爬取，还涉及数据处理与分析。无论是新手小白还是进阶开发者，都能从中汲取知识，助力掌握爬虫核心技能，开拓技术视野。目录一、物联网设备通信协议1.1MQTT协议详解1.2CoAP协议探秘
  • RDMA原理 完颜振江 网络服务器运维RDMA
    RDMA（远程直接内存访问）技术通过绕过操作系统内核和CPU干预，实现高效的低延迟数据传输。以下是对其原理的系统性解析：1.核心原理零拷贝（Zero-copy）：数据直接在应用内存与网卡间传输，无需内核缓冲区的复制。内核旁路（KernelBypass）：应用程序通过用户态驱动直接操作网卡，减少上下文切换开销。CPU卸载（CPUOffload）：数据传输由支持RDMA的智能网卡（RNIC）处理，释放
  • Golang面试必问的10大难点，90%开发者栽在第三个！ go
    本文精心梳理了一系列面试中具有一定难度的高频Golang问题，其中部分知识点可能你之前未曾深入探究，然而它们却在面试和实际工作中至关重要。包括：Golang的基础语法、并发模型、内存管理等核心知识点。本篇也将深入更多中高级主题，结合企业级应用场景，助你在激烈竞争中脱颖而出。衷心祝愿每一位求职者都能找到心仪的工作。1.Golang有哪些基本数据类型，它们的特点分别是什么？Golang的基本数据类型主
  • AI 在未来相机领域的应用前景如何？ 程序员Android 人工智能数码相机智能电视
    和你一起终身学习，这里是程序员Android人工智能（AI）在手机相机领域的应用已成为近年来技术创新的核心驱动力之一。随着计算摄影、深度学习算法和硬件加速技术的进步，AI正在重新定义手机摄影的可能性，并为未来带来更多颠覆性潜力。以下是AI在手机相机中的关键潜力方向及具体应用场景：经典好文推荐，通过阅读本文，您将收获以下知识点:1.计算摄影的深度进化多帧合成与超分辨率：AI通过分析多张连续拍摄的帧（
  • 【Python爬虫(37)】解锁分布式爬虫：原理与架构全解析 奔跑吧邓邓子 Python爬虫python爬虫分布式开发语言
    【Python爬虫】专栏简介：本专栏是Python爬虫领域的集大成之作，共100章节。从Python基础语法、爬虫入门知识讲起，深入探讨反爬虫、多线程、分布式等进阶技术。以大量实例为支撑，覆盖网页、图片、音频等各类数据爬取，还涉及数据处理与分析。无论是新手小白还是进阶开发者，都能从中汲取知识，助力掌握爬虫核心技能，开拓技术视野。目录一、走进分布式系统1.1分布式系统的定义与特点1.2分布式系统的核
  • 最详细的谷歌GMS EDLA认证介绍，你想知道的这里都有！ 深光标准技术 安卓
    一、GMS认证介绍，谷歌EDLA认证介绍，目前最详细的关于EDLA认证的介绍GMS全称是GoogleMobileService(即谷歌移动服务)，GMS认证简单来说就是使用安卓系统的移动设备在经过谷歌的一系列测试后取得谷歌的认可，可以合法使用谷歌提供的各种软件服务，包括Chrome、Gmail、YouTube、地图、PlayStore等等。Android设备需要GMS认证才能运行所有Google的
  • 探讨组合加密算法在IM中的应用 即时通讯im网络编程
    1、前言本文深入分析了即时通信(IM)系统中所面临的各种安全问题，综合利用对称加密算法（DES算法）、公开密钥算法（RSA算法）和Hash算法(MD5)的优点，探讨组合加密算法在即时通信中的应用。2、IM安全系列文章本文是IM通讯安全知识系列文章中的第2篇，总目录如下：《即时通讯安全篇（一）：正确地理解和使用Android端加密算法》《即时通讯安全篇（二）：探讨组合加密算法在IM中的应用》（本文
  • mysql案例 ~ 监控以及如何避免从库延迟问题 weixin_33910434 数据库
    一简介:今天咱们来汇总下如何避免主从延迟二方案:1集群硬件配置统一,磁盘组更好(SSD最佳),更大的内存2linux系统+mysql的配置参数已经优化3mysql从库没有任何慢语句进行IO的消耗4mysql主库业务唯一,不把多个频繁的业务集中在同一DB上,同时业务本身也进行了优化,减少了和数据库的交互.就是一句话:减少主库事务三架构1mysql5.7半同步复制2pxc/mgr强一致性架构上面两种架
  • Gallery2 视频静音功能 闪退 exposed beyond app through Intent.getData() wxx2150 BUGandroidgallerymutecrash
    具体的错误log如下---------beginningofcrash03-2219:19:17.950E/AndroidRuntime(5809):FATALEXCEPTION:main03-2219:19:17.950E/AndroidRuntime(5809):Process:com.android.gallery3d,PID:580903-2219:19:17.950E/AndroidRu
  • Android开发奇葩bug:布局宽高不自动自适应了 893151960 androidbugAndroid开发布局自适应宽高失效Android布局有问题Android自适应宽高失效
    Android开发奇葩bug:布局宽高不自动自适应了写着写着约束布局ConstraintLayout的子控件一初始化过宽高后，后面就算你内容再多，高已经变了，但是它没生效。不管怎么检查代码够感觉没错。奇怪了差点我界面就打算重写了。解决方案：把有问题的布局部分抠出来，放在FrameLayout层内，不要在ConstraintLayout里面了。不知道你看没看懂，反正就尝试抠有问题的布局出来。
  • Android14 Camera框架中Jpeg流buffer大小的计算 叶羽西 安卓android
    背景描述Android13中，相机框架包含对AIDLCameraHAL的支持，在Android13或更高版本中添加的相机功能只能通过AIDLCameraHAL接口使用。对于Android应用层来说，使用API34即以后版本的Camera应用程序通过CameraAIDLInterface访问到HAL层。在将HAL层从HIDL相机接口迁移到AIDL相机接口时，发现AIDLHALJpegbuffer带下
  • exposed beyond app through Intent.getData() 秋天的春 Androidandroid
    调用相册打开图片startActivity时报了个错startActivityForResulterror:file:///storage/emulated/0/Android/data/xxx.jpgexposedbeyondappthroughIntent.getData()调查发现是AndroidStudio7.0之后官方对这权限做了调整：官方解答：出于用户隐私安全考虑，对于面向Androi
  • Android 12系统源码_多屏幕（四）自由窗口模式 AFinalStone Framework12源码android
    一、小窗模式1.1小窗功能的开启方式开发者模式下开启小窗功能adb手动开启adbshellsettingsputglobalenable_freeform_support1adbshellsettingsputglobalforce_resizable_activities11.2源码配置copyfile#addforfreedomPRODUCT_COPY_FILES+=\frameworks/n
  • RK3568 Android12跳过认证 预置谷歌服务GMS 飞猿_SIR android
    在Rom开发中需要发布海外版本时基本都需要内置google服务，而规范方式集成的话都需要设备进行认证，获取google应用签名等非常复杂的一套流程，一般大厂才有这些资质和资源，这里介绍一种非常规方式集成GMS，跳过设置认证流程，在RK3568android12环境亲测有效。谷歌全家桶中有三个是必现安装的：GoogleServicesFramework【gsf】、GooglePlayServices
  • 《C语言》--指针-＞从初阶道进阶 (初阶) 彩妙不是菜喵 c语言c语言
    C语言中的指针是一种强大的特性，它允许程序直接访问和操作内存中的数据。指针的概念对于理解和高效使用C语言至关重要，它为数据结构的构建、内存管理、函数参数传递等提供了灵活性和效率。那么接下来，我疆带着大家来详细了解指正及其用法。一、什么是指针指针是作为c语言中的重难点，也是一位程序员必须学会的知识点之一。其本质上是一种变量，它存储了另一个变量的""内存地址""。总的来说：指针就是地址，口语中说的指针
  • JVM之垃圾回收和调优思路 星星都没我亮 Java虚拟机jvm
    文章目录GC的基础知识1.什么是垃圾2.如何定位（找到）垃圾3.常见的垃圾回收算法4.JVM内存分代模型（用于分代垃圾回收算法）5.常见的垃圾回收器常见垃圾回收器组合参数设定：(1.8)JVM调优第一步，了解JVM常用命令行参数PSGC日志详解调优前的基础概念：什么是调优？调优，从规划开始优化环境解决JVM运行中的问题一个案例理解常用工具jconsole远程连接jvisualvm远程连接jprof
  • Latex学习_MARKDOWN（持续更新） 崧小果 科研小白成长路学习
    overleafIEEE期刊模板：https://template-selector.ieee.org/secure/templateSelector/publicationTypeIEEE会议模板：https://www.ieee.org/conferences/publishing/templates.html图片、表格公式$formular$\begin{equation}formular\
  • 单片机C语言基础知识-指针篇 墨小羽ovo 单片机c语言嵌入式硬件
    引言：指针是变量在计算机或单片机内所占有的存储区域的地址。C51语言中广泛使用的指针概念是从C语言中继承下来的，利用指针变量不但可以操作各种基本的数据类型、，而且能使C51语言像汇编语言一样，具有处理单片机内存地址的能力。地址，指针，指针变量概念区分地址：地址是单片机内存单元的编号。其中内存单元是单片机存储器中的最小存储单位，通常一个字节称为-一个内存单元。指针：指针是一个特殊变量，其实也是一个地
  • C/C++内存管理 bbppooi c++c语言c++学习算法开发语言
    1.C/C++内存分布我们先来看下面的一段代码和相关问题intglobalVar=1;staticintstaticGlobalVar=1;voidTest(){staticintstaticVar=1;intlocalVar=1;intnum1[10]={1,2,3,4};charchar2[]="abcd";constchar*pChar3="abcd";int*ptr1=(int*)mall
  • 短剧源码搭建部署短剧小程序测试报告 南阳迈特网络科技 短剧源码短剧小程序短剧系统系统架构小程序php
    短剧小程序测试报告1.概述今天对一款短剧小程序进行了全面测试，整体体验非常优秀。该小程序在功能设计、用户体验、后台管理以及商业模式等方面都表现出色。以下是详细的测试反馈：感兴趣的可以点我参考一起讨论一下2.前端体验2.1格式布局优点：界面设计简洁美观，色彩搭配舒适，符合短剧类应用的用户群体审美。布局合理，导航清晰，用户可以轻松找到所需功能。响应式设计良好，在不同尺寸的设备上都能保持良好的显示效果。
  • 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其他