Java常用算法

/**
 * 类功能描述：常用算法
 */
public class Arithmetic {
	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		{
			System.out.println("请输入2个数");
		    int a = Integer.parseInt(in.readLine());
		    int b = Integer.parseInt(in.readLine());
			if(b > a) {
				int temp = a;
				a = b;
				b = temp;			
			}
			int dv = divisor(a, b);
			System.out.println("最大公约数：" + dv);
			int gb = gbs(a, b);
			System.out.println("最小公倍数：" + gb);
		}
		
		{
			int result = 1;
			System.out.println("阶乘：请输入数字");	
			int n = Integer.parseInt(in.readLine());
			result = recursion(n, result);
			System.out.println("结果为：" + result);
		}
		
		{		
			System.out.println("查找字符串匹配个数");
			System.out.println("请输入字符串：");
			String str = in.readLine();	
			System.out.println("请输入要查找的字符串：");
			String strToFind = in.readLine();
			System.out.println("结果为：" + countStr(str,strToFind));
		}
		
		{		
			System.out.println("请输入人民币金额");
			String rmb = in.readLine();	
			System.out.println("输入人民币金额为：" + rmbToConvert(rmb));
		}

		{		
			String str="6sabcsssfsfs33"; 
			System.out.println("原字符串："+str);
			str = rmString(str);
			System.out.println("结果：" + str);
		}
	}
	
	//最大公约数
	public static int divisor(int a, int b) {
		if(a%b == 0) {
			return b;
		} else {
			return divisor(b, a%b);
		}		
	}
	
	//最小公倍数
	public static int gbs(int a, int b) {
		return a*b/divisor(a, b);
	}	
	
	//阶乘
	public static int recursion(int n, int result) {
		if (n> 0) {
			result = result * n;
			return recursion(n-1, result);
		}
		return result;
	}
	
	//查找字符串匹配个数
	public static int countStr(String str, String strToFind)  throws IOException {
		int count = 0;
		int index = -1;
		if(str.length() < strToFind.length()) {
			String temp = str;
			str = strToFind;
			strToFind = temp;
		}
		while((index = str.indexOf(strToFind)) != -1) {
			str = str.substring(strToFind.length() + index);
			count++;
		}
		if(count == 0) {
			throw new IOException("没有匹配");
		}
		return count;
	}
	
	//数字转换大写
	public static String rmbToConvert(String rmb)
	{
		final String []bitRmb = {"","十","百","千"};
		final String []bigRmb = {"","万","亿"};
		final String []numberRmb = {"0","1","2","3","4","5","6","7","8","9"};
		final String []hanRmb = {"零","一","二","三","四","五","六","七","八","九"};
		int i,j;
		for(i=0;i<hanRmb.length;i++){
			rmb = rmb.replaceAll(numberRmb[i], hanRmb[i]);
		}		
		StringBuilder sb = new StringBuilder();
		sb.append("元");
		for(i=rmb.length()-1,j=0;i>=0;i--,j++){
			char temp = rmb.charAt(i);
			if(temp!='零'){
				sb.append(bitRmb[j%4]); //添加单位
			}
			if(j%4==0){
				sb.append(bigRmb[j%3]); //添加单位
			}
			sb.append(temp);  
		}
		String result = sb.reverse().toString(); //逆序处理方法
		result = result.replaceAll("零*", "");
		return result;
	}
	
	//删除字符串ab3
	public static String rmString(String str)
	{
		boolean[] removeChars = new boolean[256];   
		removeChars['a'] = true;   
		removeChars['b'] = true;   
		removeChars['3'] = true;   
		StringBuffer sb = new StringBuffer();   
		for (char ch:str.toCharArray()) {   
			if (!removeChars[ch]) sb.append(ch);   
		}   
		return sb.toString();   
	}
	
	//读取文件中字符串判断其内容
	public static void readFile() throws IOException
	{
	    String fileName = "C:/Hello.txt"; 
		String line;
		int i,k = 0,cU = 0,cL = 0,cN = 0; 
		BufferedReader in = new BufferedReader(new FileReader(fileName)); 
		line = in.readLine();   //读取一行内容 
		while ( line != null ) {  
		    cU = 0 ; 
		    cL = 0 ; 
		    cN = 0 ; 
		    char c; 
			for(i=0 ;i<line.length();i++){
				c = line.charAt(i);
				if(c > 'a' && c < 'z') { 
					cL ++ ; 
				} 
				else if(c > 'A' && c < 'Z') { 
					cU ++ ; 
				} 
				else { 
					cN ++ ; 
				} 
			}
			line = in.readLine(); 
			k++ ;  
		 } 
		 System.out.println("Number of LowerCase:" + cL); 
		 System.out.println("Number of UpperCase:" + cU); 
		 System.out.println("Number of NotChar:" + cN); 
	}
}

/**
 * 类功能描述：多种排序算法，默认升序
 */
public class BaseSort {
	// 交换i1、i2下标指向的值
	public void swap(Object[] array, int i1, int i2) {
		Object tempObj;
		tempObj = array[i1];
		array[i1] = array[i2];
		array[i2] = tempObj;
		tempObj = null;
	}
	// 打印输出数组元素
	public void print(Object[] array) {
		for (Object obj : array) {
			System.out.print(obj + "    ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		System.out.println("----------------------------------------------------->插入排序");
		Object[] insertArray = { 9, 5, 7, 1, 6, 3, 8, 10, 4, 2 };
		(new InsertSort()).insertSort(insertArray);
		System.out.println("----------------------------------------------------->冒泡排序");
		Object[] bubbleArray = { 9, 5, 7, 1, 6, 3, 8, 10, 4, 2 };
		(new BubbleSort()).bubbleSort(bubbleArray);
	}
}

/**
	插入排序 将数组所有元素划分成了有序区和无序区，假设当前数组有 N 个元素，
	开始默认第一个元素（下标为0）所处的位置是有序区，这是局部有序，从第二个元素（i=1）至数组最后一个元素（i=N-1）属于无序区；
	假设数组元素是按从左至右存放的，如果用 i 来标记无序区中的第一个元素下标，也就是无序区中最左边或者说是无序区中下标值最小的下标，
	则每趟排序是将下标 i 所指向的有效值插入有序区的适当位置，使得每趟排序完成之后，有序区的所有元素总是保持局部有序状态。
	按这样来回 N -1 趟插入之后，则 N 个元素已成有序状态，复杂度O(n^2)
 */
class InsertSort extends BaseSort {
	/**
	 * @方法名: insertSort
	 * @参数名： array 排序对象
	 * @参数名： order 排序顺序
	 * @描述语: 插入排序:默认第一个是有序,使其余的像纸牌游戏那样依次插入，复杂度 O(n^2)
	 */
	public void insertSort(Object[] array) {
		int length = array.length;
		for (int i = 1, j; i < length; i++) { // 默认第1个(下标0)有序，i是无序区第一个元素下标，第i趟结束后，i下移，如此来回N -1趟
			for (j = 0; j < i; j++) { // 将无序区下标为i所指向的值插入有序区适当位置
				if (Double.parseDouble(array[j].toString()) > Double.parseDouble(array[i].toString())) {
					swap(array, i, j);
				}
			}
			System.out.println("----------------------------------------------------->第" + i + "趟");
			print(array);
		}
	}
}

/**
	N 个元素数据需要进行 N - 1 趟排序，第 i 趟排序，需要对元素数据做两两比较 N - i 次
	，每趟排序完成之后，剩余较大的元素（升序）或较小的元素（降序）将冒到
	数组最末端，此后，该项元素就此排定，不需要再移动。
 */
class BubbleSort extends BaseSort {
	/**
	 * @方法名: bubbleSort
	 * @参数名： array 排序对象
	 * @参数名： order 排序顺序
	 * @描述语: 单向冒泡排序，复杂度：O(n^2)
	 */
	public void bubbleSort(Object[] array) {
		int length = array.length;
		for (int i = 0, j; i < length - 1; i++) { // N个数需N-1趟,每趟完成之后,较大元素将冒到数组最末端
			for (j = 0; j < length - 1 - i; j++) { // 每趟需要比较N-i次比较
				if (Double.parseDouble(array[j].toString()) > Double.parseDouble(array[j + 1].toString())) {
					swap(array, j, j + 1);
				}
			}
			System.out.println("----------------------------------------------------->第" + i + "趟");
			print(array);
		}
	}
}

/**
 * 
 * 类功能描述：路人甲攻击路人乙，假设结果只可能是：击中、击中要害、躲闪、招架这四种之一，并且只能是一种(为描述方便四种结果分别用符号A、B、C、D代表)：
 * 假设这四种结果发生的概率分别是a%,b%,c%,d%，其中a+b+c+d=100，要求从这四种结果中随机选出一种结果，发生概率越高的事件被选中的几率越大。
 *			 
 * @author <a href="mailto:[e-mail]">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午01:56:27
 */
public class Chances {
	
	/**
	 *	@function:根据概率随机选择一种结果，发生概率越高的事件被选中的几率越大
	 *	@param percents 参数数组的元素值分别顺序代表A,B,C,D发生的概率
	 *	@return 返回0代表A事件，返回1代表B事件，返回3代表D事件
	 *	 根据要求实现randomResult方法
	 */
	public int randomResult(int[] percents){
		int randomNumber = (int) (Math.random()*100);
		if (randomNumber >= 0 && randomNumber < percents[0]) {
			return 0;
		} else if (randomNumber >= percents[0] && randomNumber < percents[0] + percents[1]) {
			return 1;
		} else if (randomNumber >= percents[0] + percents[1] && randomNumber < percents[0] + percents[1] + percents[2]) {
			return 2;
		} else if (randomNumber >= percents[0] + percents[1] + percents[2] && randomNumber < percents[0] + percents[1] + percents[2] + percents[3]) {
			return 3;
		}
		return -1;
	}
	
	public static void main(String[] args) {
		Chances chances = new Chances();
		int[] percents = {5,10,30,55};
		int result = chances.randomResult(percents);
		System.out.println(result);
	}
}

import java.util.Random;

/**
 * 
 * 类功能描述：两个整数A和B，A的值范围为[0,255]，B的值范围为[0,0xFFFFFF]，为了节省存储空间，需要将它们压缩在一个int中，如何实现？又如何还原？请用JAVA代码编写。
 *
 * @author <a href="mailto:[e-mail]">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午02:18:11
 */
public class Depress {

	/**
	 * 
	 * @function:
	 * @param random10   0-255 占用8位二进制
	 * @param random16   0-0xFFFFFF 占用24位二进制 
	 * @author: mengqingyu    2014-4-2 下午01:54:27
	 */
	public void bitShift(int random10, int random16) {
		int result = random10 << 24 | random16; // int类型是4个字节占用32位二进制，所以可以容纳以上2个数，低8位左移24位空出24位用来通过|存放16进制的24位
		System.out.println("原10进制数" + random10 + "：" + Integer.toBinaryString(random10));// 转换成二进制输出原数据
		System.out.println("原16进制数" + random16 + "：" + Integer.toBinaryString(random16));// 转换成二进制输出原数据
		System.out.println("存到一个int中：" + Integer.toBinaryString(result)); // 转换成二进制输出最终结果
		System.out.println("取出10进制数" + random10 + "：" + Integer.toBinaryString(result >>> 24)); // 右移24位还原10进制数，用>>>为了高位补0,
		System.out.println("取出16进制数" + random16 + "：" + Integer.toBinaryString(result << 8 >>> 8)); // 先左移8位为了把10进制数清零，剩下24位的16进制在右移8位还原
	}

	public static void main(String[] args) {
		Random random = new Random(); // 随机数
		Depress depress = new Depress();
		depress.bitShift(random.nextInt(255), random.nextInt(Integer.valueOf("FFFFFF", 16)));
	}
}

/**
 * 
 * 类功能描述：以下String类用于存储字符串，假设其实现如下：
 * 			  请完整实现其equals方法和hashCode方法(为了提高性能可以增加私有成员变量)。
 * 			  根据要求实现equals和hashCode方法
 * @author <a href="mailto:[e-mail]">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午02:07:28
 */
public final class Sstring {

	/** 用于存储字符串的数组，字符串存储总是从第一个开始 */
	private final char value[];

	/** 指示存储的字符总数  */
	private final int count;

	private final int offset = 0;

	private int hash;

	public Sstring(char value[], int count) {
		this.value = value;
		this.count = count;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if ((obj == null) || (obj.getClass() != this.getClass()))
			return false;
		if (obj instanceof Sstring) {
			Sstring anotherString = (Sstring) obj;
			int n = count;
			if (n == anotherString.count) {
				char v1[] = value;
				char v2[] = anotherString.value;
				int i = offset;
				int j = anotherString.offset;
				while (n-- != 0) {
					if (v1[i++] != v2[j++])
						return false;
				}
				return true;
			}
		}
		return false;
	}

	//HashCode遵循原则，一般使用较小素数作为系数如31，来进行乘法计算这样能够最大限度降低地址重复率和超出int范围
	@Override
	public int hashCode() {
		int h = hash;
		if (h == 0 && value != null) {
			int off = offset;
			char val[] = value;
			int len = count;
			for (int i = 0; i < len; i++) {
				h = 31 * h + val[off++];
			}
			hash = h;
		}
		return h;
	}

	public static void main(String[] args) {
		char value[] = { '1', '2', '3' };
		int count = 3;
		Sstring s1 = new Sstring(value, count);
		Sstring s2 = new Sstring(value, count);
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
		System.out.println(s1.equals(s2));
	}
}

/**
 * 
 * 类功能描述：游戏世界中使用技能攻击目标时，攻击结果可能是：击中、暴击、躲闪、招架四种之一，这些攻击结果被定义为常量，如下：
 * 			   在战斗系统的处理过程中，这些攻击结果会出发相应的事件。	
 * 			   要求：根据给定的攻击结果和给定的事件，判断指定的事件是否被触发，用效率最高的实现以下eventFired方法。
 * @author <a href="mailto:[e-mail]">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午02:03:04
 */
public class WorldGame {

	enum ResultFlag {
		HIT, /**击中*/
		CRITICAL, /**暴击*/
		DODGE, /**躲闪*/
		PARRY /**招架*/
	}

	enum EventFlag {
		ON_HIT, /**击中时，HIT被触发*/
		ON_BE_HIT, /**被击中时，HIT被触发*/
		ON_HIT_CRITICALLY, /**暴击时，CRITICAL被触发*/
		ON_BE_HIT_CRITICALLY, /**被暴击时，CRITICAL被触发*/
		ON_DODGE, /**躲闪时，DODGE被触发*/
		ON_BE_DODGED, /**被躲闪时，DODGE被触发*/
		ON_PARRY, /**招架时，PARRY被触发*/
		ON_BE_PARRIED /**被招架时，PARRY被触发*/
	}

	public boolean eventFired(ResultFlag result, EventFlag event) {
		//Enum.valueOf(enumType, name)
		switch(result.ordinal()){
			case 0:return (event==EventFlag.ON_HIT||event==EventFlag.ON_BE_HIT);
			case 1:return (event==EventFlag.ON_HIT_CRITICALLY||event==EventFlag.ON_BE_HIT_CRITICALLY);
			case 2:return (event==EventFlag.ON_DODGE||event==EventFlag.ON_BE_DODGED);
			case 3:return (event==EventFlag.ON_PARRY||event==EventFlag.ON_BE_PARRIED);
			default: return false;
		}
	}

	/**
	 * @function:
	 * @param args
	 * @author: mengqingyu 2014-3-26 下午03:46:24
	 */
	public static void main(String[] args) {
		WorldGame wg = new WorldGame();
		boolean flag1 = wg.eventFired(ResultFlag.HIT, EventFlag.ON_BE_HIT);
		boolean flag2 = wg.eventFired(ResultFlag.HIT, EventFlag.ON_BE_PARRIED);
		System.out.println("ResultFlag.HIT, EventFlag.ON_BE_HIT result："+flag1);
		System.out.println("ResultFlag.HIT, EventFlag.ON_BE_PARRIED result："+flag2);
	}
}