/**
* 类功能描述:常用算法
*/
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:qingyu.meng21@gmail.com">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:qingyu.meng21@gmail.com">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:qingyu.meng21@gmail.com">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:qingyu.meng21@gmail.com">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);
}
}
分享到:
相关推荐
《Java常用算法手册》是一本面向Java初学者的算法指南,旨在通过深入浅出的方式,帮助读者理解并掌握各种常见的编程算法,从而提高他们的编程能力和解决问题的效率。这本书的覆盖范围广泛,涉及到算法基础、数据结构...
资源名称:Java常用算法手册内容简介:现代的设计任务大多通过计算机编程来完成,而算法起到了至关重要的作用。可以毫不夸张地说,算法是一切程序设计的灵魂和基础。选择合理的算法,可以起到事半功倍的效果。 赵...
《Java常用算法手册》是一本深入探讨Java编程中常见算法的实用指南,旨在帮助开发者提升在实际工作中解决复杂问题的能力。...通过阅读这本书,你可以系统地学习和实践Java中的算法,为你的职业生涯增添更多的可能。
通过阅读这些源代码,不仅可以学习到如何在Java中实现各种算法,还能了解到如何优化代码性能,提升解决问题的能力。此外,这些源代码也可以作为实际项目中的参考,帮助开发者快速解决遇到的计算问题。 总的来说,这...
根据提供的文件信息,“Java常用算法手册.pdf”似乎是一份针对Java程序员的学习资源,旨在帮助他们掌握和提升在算法方面的知识与技能。然而,基于提供的简短描述和部分内容来看,并没有直接涉及具体的算法知识点,...
本资源是“Java常用算法手册”的源代码,可以帮助开发者深入理解并实践各种常见的算法。 算法是解决问题或执行任务的精确步骤序列,是计算机科学的基础。对于Java开发者来说,掌握基本的算法知识不仅可以提高编程...
《Java常用算法手册》源代码是一份非常宝贵的资源,它为Java开发者提供了丰富的算法实现,是学习和实践算法的理想材料。这份源代码集合涵盖了多种经典和实用的算法,旨在帮助开发者提升编程技能,理解算法原理,并能...
这本"Java常用算法手册源码"集合了Java编程中常见的算法实现,对于学习和提升Java算法能力非常有帮助。以下将对其中涉及的主要算法进行详细介绍: 1. 排序算法: - 冒泡排序:基础排序算法,通过不断交换相邻元素...
《Java常用算法手册》是一本深入浅出的编程资源,主要涵盖了Java编程语言中的各种常见算法,对于学习和提升Java编程技巧以及理解算法思想具有重要价值。这份手册以实际可运行的代码为载体,使读者能够直观地看到算法...
在Java中,数组提供了快速访问和定位元素的能力。 - **链表**:非连续存储的数据结构,每个元素(节点)包含数据和指向下一个节点的引用。分为单链表、双链表和循环链表等。 - **栈**:后进先出(LIFO)的数据结构...
java常用算法手册第三版高清版
3.1 常用算法思想概述 3.2 穷举算法思想 3.2.1 穷举算法基本思想 3.2.2 穷举算法实例 3.3 递推算法思想 3.3.1 递推算法基本思想 3.3.2 递推算法实例 3.4 递归算法思想 …… 第2篇 算法应用篇 第4章 排序算法 第5章 ...
Java算法手册源代码包含了丰富的编程实践,是学习和理解算法的宝贵资源。这些源文件分别命名为P1到P13,可能代表着不同的章节或者主题。下面将针对Java算法这一主题,详细阐述一些重要的知识点。 首先,Java作为一...