package com.bz.sort.algorithm;

public class QuickSort {
    /** *//**
     * 对外调用的方法入口。
     * @param array 待排序数组
     */
    public void sort(int[] array) {
        if (array == null || array.length < 0) {
            throw new RuntimeException("待排序数组中无数据。");
        }

        // 排序
        sort(array, 0, array.length - 1);
    }

    /** *//**
     * 快速排序。
     * @param arr 待排序数组
     * @param left 关注的区间
     * @param right 关注的区间
     */
    private void sort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // 取得pivot位置，这里的策略是取得最小的index，即返回left
        int pivot = findPivot(arr, left, right);
        // 排序并重新计算出pivot
        pivot = partion(arr, left, right, pivot);

        // 以pivot为中心将原数组分解成两块，递归排序
        sort(arr, left, pivot - 1);
        sort(arr, pivot + 1, right);
    }

    /** *//**
     * 排序并返回新的pivot
     * @param arr 待排序数组
     * @param left 区间
     * @param right 区间
     * @param pivot 轴
     * @return 
     */
    private int partion(int[] arr, int left, int right, int pivot) {
        int tmp = arr[pivot];
        int low = left;
        int high = right;
        while (low < high) {
            // 从后向前遍历数组，找到第一个小于arr[pivot]的数
            while (low < high && tmp < arr[high]) {
                high--;
            }
            arr[low] = arr[high];

            // 从前向后遍历数组，找到第一个大于arr[pivot]的数
            while (low < high && tmp >= arr[low]) {
                low++;
            }
            arr[high] = arr[low];
        }

        // 此时low与high重合，将tmp的值移动到low的位置
        arr[low] = tmp;
        // 将low当作新的pivot返回
        return low;
    }

    /** *//**
     * 取得排序的轴
     * @param array
     * @return
     */
    protected int findPivot(int[] array, int left, int right) {
        if (array == null || array.length < 0) {
            throw new RuntimeException("待排序数组中无数据。");
        }
        // 选择第一个元素为轴
        return left;
    }
}

测试代码如下：

package com.bz.sort.algorithm;

import org.junit.Test;

import junit.framework.Assert;

public class QuickSortTest {
    @Test
    public void testSort() {
        int[] array = { 4, 2, 1, 7, 5, 3, 8, 6 };
        QuickSort qs = new QuickSort();
        qs.sort(array);
        for (int i = 0; i < array.length - 1; i++) {
            Assert.assertTrue(array[i] <= array[i + 1]);
        }
    }
}

在网上查了一些关于此异常的解决方案，基本上都是说要扩大linux系统的文件句柄数限制。
但如果程序对于Socket、Stream等使用后没能及时关闭的话，扩大这个文件句柄数限制是治标不治本的。

我先是在测试环境扩大了linux的文件句柄数限制，随后提高测试压力，过一段时间后发现还是会报这个异常。
（中间也用lsof命令查看占用的文件句柄数，不断的增加啊，心寒啊。）
现象是 用 lsof -p *** 来查看，形如
java    22055 webapp   21w  FIFO                0,6          29300342 pipe
java    22055 webapp   22r  FIFO                0,6          29256305 pipe
在不断增加。

所以我果断对代码进行了排查。文件的IO操作、对数据库的操作，看了都没有什么问题，
最后排查到由Java程序去调用Shell脚本的代码，

代码写的还是很简单的，看上去很清晰，但是有明显的问题：

Process proc = Runtime.getRuntime().exec(cmd);
//略对proc.getErrorStream()、proc.getInputStream()流的操作。
proc.waitFor();
return proc.exitValue();

这里的问题是 对流没有在finally处做关闭处理。这个问题比较明显。
还有一个问题就是Process的使用问题，

如果对Process的不熟悉的话，可能会以为return proc.exitValue();之后就万事大吉了。
（exitValue()确实很像是已经退出了并得到返回值的意思，估计是这个方法的名字迷惑了我们的开发人员。）
实际不然，看Jdk的帮助文档可以发现，要通过destroy()来实现对子进程的销毁并释放占用的File Descriptor。

这个问题，短时间的测试是不会有问题的，但在投入生产后，随着程序的长期运行，开发中的疏忽就会暴露了。
所以在对使用的方法拿不准的情况下，还是要多做调查，谨慎使用啊。

希望能让在排查类似问题的朋友注意，如果你排查的代码中也存在Runtime.getRuntime().exec(cmd)这样的调用，那么请确保那段代码没有问题。

本文为原创，欢迎转载，转载请注明出处BlogJava。

想重现这个场景很容易，请看代码。

 1import java.util.ArrayList;
 2import java.util.List;
 3
 4public class LeakTest {
 5    public static void main(Stringargs) {
 6        List<String> handler = new ArrayList<String>();
 7        for(int i = 0; i < 100000; i++) {
 8            Huge h = new Huge();
 9            handler.add(h.getSubString(1, 5));
10        }
11    }
12}
13
14class Huge {
15    private String str = new String(new char[100000]);
16    public String getSubString(int begin, int end) {
17        return str.substring(begin, end);
18    }
19}

执行此代码结果：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

问题就出在Huge类的 getSubString 方法，它调用了String类的substring方法。

来让我们看看 substring 类的实现吧，JDK源码如下：

 1    public String substring(int beginIndex, int endIndex) {
 2    if (beginIndex < 0) {
 3        throw new StringIndexOutOfBoundsException(beginIndex);
 4    }
 5    if (endIndex > count) {
 6        throw new StringIndexOutOfBoundsException(endIndex);
 7    }
 8    if (beginIndex > endIndex) {
 9        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
10    }
11    return ((beginIndex == 0) && (endIndex == count)) ? this :
12        new String(offset + beginIndex, endIndex - beginIndex, value);
13    }

再让我们接下来看看 new String(offset + beginIndex, endIndex - beginIndex, value); 的实现：

1    // Package private constructor which shares value array for speed.
2    String(int offset, int count, char value[]) {
3    this.value = value;
4    this.offset = offset;
5    this.count = count;
6    }

char[] value 数组被共享了。

在我们的main函数里的循环中，每循环一次后，我们希望Huge对象被回收，且释放它占有的内存。

但实际上 private String str = new String(new char[100000]); 占有的内存并不会被释放。

因为 我们通过 Huge 类的 getSubString 方法得到的 String 对象还存在(存在于handler的列表中)，

它虽然是 length 只有 4 的对象，却享有着 char[100000] 的空间。

解决方案：

可以修改Huge 类的 getSubString 方法如下：

1    public String getSubString(int begin, int end) {
2        return new String(str.substring(begin, end));
3    }

只要再套一个String的构造方法即可。

至于为什么，看看JDK源码，一看便知了。这里就不贴出来了。

唉，以后写代码得多多小心啊。

http://topic.csdn.net/u/20090113/17/5abc9a50-64dd-4277-af73-e8d2b762a469.html

我贴过来，自己做一下。

题目1： One team tries to buy several bottle of drinks for 27 athletes. In ABC store three empty bottles can be exchanged

with one new bottle of drinks. Which of the following numbers is the minimal one that the team should buy for the 27

athletes?

 1/** *//** 
 2 * @author bzwm 
 3 *  
 4 */ 
 5public class BottleTest { 
 6    public static void main(String[] args) { 
 7        // 放空瓶子的栈 
 8        java.util.Stack<Object> emptyBottles = new java.util.Stack<Object>(); 
 9        // 买的饮料数 
10        int bottle = 0; 
11        // 喝过饮料的人数 
12        int drink = 0; 
13        // 空饮料瓶子 
14        Object emptyBottle = new Object(); 
15        while (drink < 27) { 
16            // 一个人喝过了 
17            drink++; 
18            // 把空瓶子放在栈中 
19            emptyBottles.push(emptyBottle); 
20            // 买的饮料数加1 
21            bottle++; 
22            // 如果空瓶子栈中的空瓶数为3个 
23            if (emptyBottles.size() == 3) { 
24                // 将三个瓶子拿去商店换饮料 
25                emptyBottles.pop(); 
26                emptyBottles.pop(); 
27                emptyBottles.pop(); 
28                // 一个人喝过饮料 
29                drink++; 
30                // 将空瓶子再放在栈中 
31                emptyBottles.push(emptyBottle); 
32            } 
33        } 
34        System.out.println(bottle); 
35    } 
36}

题目2： How can you create a listener class that receives events when the mouse is moved(single Answer)

A By extending MouseListener

B By implementing MouseListener
C By extending Mouse Motion Listener
D By implementing Mouse Motion Listener
E Either by extending Mouse Motion Listener  or extending MouseListener
F Either by implementing Mouse Motion Listener  or  implementing MouseListener

题目3： You are assign the task of building a panel containing a TextArea at the top, a label directly below it, and a button

directly below the label. If the three components are added directly to the panel, which layout manager can be panel use to

ensure that the TextArea absorbs all of the free vertical space when the parel is resized?

题目4： Which are not containers in Java?(Multiple answer)
A ScollPane
B Canvas
C Scrollbar
D Applet
E Dialog

题目5：You need to store elements in a collection that 
guarantees that no duplicates are stored and all elements 
can be access in nature order, which interface provides 
that capability?

A java.uil.Map
B java.util.Collection
C java.util.List
D java.util.SortedSet
E java.util.SortedMap
F java.util.Set

题目6：What will happen when you attempt to compile and run this 
code?

abstract class Base{
  abstract public void myfunc();
public class Abs extends Base{
public static void main(String argv[])
{
  Abs a = new Abs();
  a.amethod();
}
public void amethod(){
  System.out.println("A method");;
}
}

A The code will compile and run, printing out the words "A 
method"
B The compiler will complain errors in Base class.
C The code will compile but complain at run time that the 
Base class has none abstract methods.
D The compiler will complain errors in Abs class

题目7： Description
import java.util.*;

public class Test
{
  private String value = null;
  public Test(String v)
  {
  value = v;
  }
  public boolean equals(Test o)
  {
  if(o==this) return true;
  if(o instanceof Test)
  {
  Test test =(Test) o;
  return value.equals(test.value);
  }
  return false;
  }
  public static void main(String[] args)
  {
  List list = new ArrayList();
  Test test1 = new Test("object");
  Test test2 = new Test("object");
  Test test3 = new Test("object");
  Object test4 = new Test("object");
  list.add(test1);

  System.out.println(list.contains(test2));
  System.out.println(test2.equals(test3));
  System.out.println(test3.equals(test4));

  }
}

题目8：
Which of the following is NOT true regarding to RuntimeException?
A RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtul
Machine.
B A method is not required to declare in its throws clause any subclasses of RuntimeException that might be thrown during the

execution of the method but not caught.
C An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try
to catch.
D NullPointerException is one kind of RuntimeException.

题目9： Which of the following items demonstrates the key characteristics of Web 2.0

A Centralized
B User centered design
C Open
D Light Weight

题目10： When using the writeObject method to store the state of n  object, how can you protect sensitive data from being 
accessed in the stored object?
A Implement the Object as Exteralizable
B Declare the sensitive fields as private transient
C Declare the sensitive fields as static transient

D Declare the sensitive fields as protected transient

用Java设计一个程序,实现一个字符串的对称个数,如字符串"effeghg",有"ff","effe","ghg"这三个对称字符,所以返回3.

我实现的思路就是遍历这个字符串，

先选定头位置为第一个字符，然后从最后向前遍历这个字符串，

头尾两个字符相同，则取中间字符串，进行递归。

递归结束后得到结果，

继续将头向后推1位，然后再从字符串最后向前遍历，

如此循环，当尾等于头时，退出最外层循环，输出结果。

具体实现：

/** *//** 
 * @author bzwm 
 *  
 */ 
public class FindSymmetryStr { 
    /** *//** 
     * 找出字符串中对称的子字符串的个数 
     * @param orgStr 
     * @return 
     */ 
    public static int findSymmetryStr(String orgStr) { 
        //结果初始化 
        int count = 0; 

        //当输入字符串不为null且长度大于1时进行查找,否则直接返回0 
        if (orgStr != null && orgStr.length() > 1) { 
            //得到输入字符串的长度 
            int size = orgStr.length(); 
            //字符串的头字符索引 
            int head; 
            //字符串从后向前遍历时的"尾"字符索引,即当前字符索引 
            int current; 
            //字符串的头字符 
            char hStr; 
            //字符串从后向前遍历时的"尾"字符 
            char cStr; 

            //从前开始遍历字符串 
            for (head = 0; head < size; head++) { 
                //取得头字符 
                hStr = orgStr.charAt(head); 
                //指向输入字符串的最后 
                current = size - 1; 
                //当尾字符索引等于头字符索引时退出循环 
                while (current > head) { 
                    //取得尾字符 
                    cStr = orgStr.charAt(current); 
                    //如果头尾字符相等,则继续判断 
                    if (hStr == cStr) { 
                        //取出头尾中间的子字符串,对其进行分析 
                        String newStr = orgStr.substring(head + 1, current); 
                        //如果此子字符串的长度大于1,则进行递归 
                        if (newStr.length() > 1) 
                            //递归得到此子字符串中对称的字符串个数 
                            count += findSymmetryStr(newStr); 
                        //如果此子字符串只有1个或0个字符,则表明原头尾字符和此单个字符组成对称字符串 
                        else 
                            count++; 
                        //将尾字符索引向前推1位 
                        current--; 

                    } 
                    //如果头尾字符不相等,则将尾字符索引向前推1位 
                    else { 
                        current--; 
                    } 
                } 
            } 
        } 

        return count; 
    } 

    //测试程序 
    public static void main(String args[]) { 
        int count = findSymmetryStr("cddcbcbeffeghg");// 
        System.out.println("symmetry string count is : " + count); 
    } 
}