随机产生99条2-10个长度的字符串存入线程安全的集合中然后按格式输出

package com.random;

import java.util.ArrayList;

public class RandomPwd
{
	private static RandomPwd	pwd			= null;

	/**
	 * 供随机选择的数字
	 */
	private static final String	figures		= new String("1234567890");

	/**
	 * 供随机选择的大小写字母
	 */
	private static final String	chars		= new String(
													"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
	/**
	 * 供随机选择的字母
	 */
	private static final String	s			= new String(
													"1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
	/**
	 * 数字字符串的长度
	 */
	private static final int	figureLen	= 10;

	/**
	 * 大小写字母字符串的长度
	 */
	private static final int	charLen		= 52;

	/**
	 * 随机对象
	 */
	private static final Random	random		= new Random();

	/**
	 * 产生2-10位同时有数字和字母的字符串
	 * 
	 * @return StringBuffer
	 */
	private StringBuffer randmomStr()
	{
		StringBuffer temp = new StringBuffer();
		int charNumOfTemp = 0;
		int figureNumOfTemp = 0;

		// false标记产生数字，true标记产生字母
		boolean flag = false;

		// 产生的字符串长度2-10
		int pwdLen = random.nextInt(9) + 2;

		for (int i = 0; i < pwdLen; i++)
		{
			flag = random.nextBoolean();

			// 产生的字符中不能全是字母或者数字，至少最后一位是数字或字母
			if ((flag || ((figureNumOfTemp + 1) == pwdLen))
					&& ((charNumOfTemp + 1) < pwdLen))
			{
				temp.append(chars.charAt(random.nextInt(charLen)));
				charNumOfTemp++;
			}
			else
			{
				temp.append(figures.charAt(random.nextInt(figureLen)));
				figureNumOfTemp++;
			}
		}

		return temp;
	}

	/**
	 * 随机产生2-8字母或者字母的字符串
	 * 
	 * @return
	 */
	private StringBuffer randomChars()
	{
		StringBuffer sb = new StringBuffer();
		int len = random.nextInt(9) + 2;
		int sLen = 62;
		for (int i = 0; i < len; i++)
		{
			sb.append(s.charAt(random.nextInt(sLen)));
		}

		return sb;
	}

	/**
	 * 交换list2位置的个值
	 * 
	 * @param array
	 * @param i
	 * @param j
	 */
	private void swap(List<StringBuffer> list, int i, int j)
	{
		StringBuffer temp = list.get(i);
		list.set(i, list.get(j));
		list.set(j, temp);
	}

	/**
	 * 判断max是否比min大，按字典 可以用String的compareTo方法代替
	 * 
	 * @param max
	 * @param min
	 * @return
	 */
	private boolean isMaxThan(StringBuffer max, StringBuffer min)
	{
		int maxLen = max.length();
		int minLen = min.length();
		int len = maxLen > minLen ? minLen : maxLen;
		for (int i = 0; i < len; i++)
		{
			if (max.charAt(i) == min.charAt(i))
			{
				continue;
			}
			else if (max.charAt(i) > min.charAt(i))
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		// for循环比较完后没有得出结果，则判断max的字符串是否长些
		if (maxLen > minLen)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	/**
	 * 升序快速排序的分割函数
	 * 
	 * @param array
	 * @param low
	 * @param high
	 * @return
	 */
	private int part(List<StringBuffer> list, int low, int high)
	{
		StringBuffer index = list.get(low);
		while (low < high)
		{
			while (low < high)
			{
				if (isMaxThan(index, list.get(high)))
				{
					swap(list, low, high);
					break;
				}
				else
				{
					high = high - 1;
				}

			}

			while (low < high)
			{
				if (isMaxThan(list.get(low), index))
				{
					swap(list, low, high);
					break;
				}
				else
				{
					low = low + 1;
				}

			}
		}

		return low;
	}

	/**
	 * 对list通过ASCII码按字典进行快速排序
	 * 
	 * @param array
	 * @param low
	 * @param high
	 */
	private void charsQuikSortASC(List<StringBuffer> list, int low, int high)
	{
		if (low < high)
		{
			int m = part(list, low, high);
			charsQuikSortASC(list, low, m);
			charsQuikSortASC(list, m + 1, high);
		}
	}

	/**
	 * 4个字符串一行打印List<StringBuffer>
	 * 
	 * @param array
	 */
	private void print(List<StringBuffer> list)
	{
		for (int i = 0; i < list.size(); i++)
		{
			StringBuffer s = list.get(i);
			System.out.print(s);

			// 字符串不满10个用空格填充
			for (int j = 0; j <= 10 - s.length(); j++)
			{
				System.out.print(" ");
			}

			// 四个字符串一行
			if ((i + 1) % 4 == 0)
			{
				System.out.println("\n");
			}
		}
	}

	/**
	 * 产生99条2-10长度的且同时有数字和字母的字符串。 如果产生的字符串除了最后一位外都是数字或字母则最后一位将添加成字母或数字，
	 * 以满足字符串中必须有数字和字母的要求。
	 * 
	 * @return
	 */
	public List<StringBuffer> general99RandomStr()
	{
		// 线程安全的ArrayList集合
		List<StringBuffer> list = Collections
				.synchronizedList(new ArrayList<StringBuffer>(99));
		for (int i = 0; i < 9; i++)
		{
			list.add(randmomStr());
		}
		return list;
	}

	/**
	 * 产生99条2-10长度的且同时包含数字和字母的随机字符串
	 * 
	 * @return
	 */
	public List<StringBuffer> general99RandomChars()
	{
		StringBuffer sb = null;

		// 线程安全的ArrayList集合
		List<StringBuffer> list = Collections
				.synchronizedList(new ArrayList<StringBuffer>(99));
		for (int i = 0; i < 99;)
		{
			sb = randomChars();

			// 字符串中同时包含数字和字母且不重复才添加进集合
			if (sb.toString()
					.matches("([\\d]+[A-Za-z]+).*|([A-Za-z]+[\\d]+).*"))
			{
				if (!list.contains(sb))
				{
					list.add(sb);
					i++;
				}
			}
		}

		return list;
	}

	/**
	 * 将集合排序
	 * 
	 * @param list
	 */
	public void sortAndPrint(List<StringBuffer> list)
	{
		charsQuikSortASC(list, 0, list.size() - 1);
	}

	/**
	 * 单例
	 * 
	 * @return
	 */
	public static synchronized RandomPwd getInstance()
	{
		if (pwd == null)
		{
			pwd = new RandomPwd();
		}
		return pwd;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		List<StringBuffer> list = getInstance().general99RandomChars();
		getInstance().sortAndPrint(list);
		getInstance().print(list);
	}

}