JAVA 基础练习

package com.gfxu.test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Test {

	public static void main(String[] args) {

		System.out.println((int) 'a' + ";" + (int) 'z' + ";" + (int) 'A' + ";"
				+ (int) 'Z');
		// 测试compareToIgnoreCase
		String leftStr = "HARD";
		String rightStr = "hark";
		int r = compareToIgnoreCase(leftStr, rightStr);
		System.out
				.println("=========================================================");
		System.out.println("测试compareToIgnoreCase");
		System.out.println("leftStr:" + leftStr + "; rightStr:" + rightStr
				+ ";-->result:" + r);

		// 测试字符大小写判断
		System.out
				.println("=========================================================");
		System.out.println("测试isCamelWorld");
		String world = "True";
		System.out.println(world + ":" + isCamelWorld(world));

		// 测试1-26与对应英文字符转换
		System.out
				.println("=========================================================");
		System.out.println("测试intToEng");
		int[] codes = { 1, 3, 5, 24, 25, 26, 40 };
		char[] engs = intToEng(codes);
		showMatrix(engs);

		// 转换A为f
		System.out
				.println("=========================================================");
		System.out.println("测试parseAToe");
		char a = 'A';
		char z = 'Z';
		char o = (char) 91;
		System.out.println(a + ":" + parseAToe(a));
		System.out.println(z + ":" + parseAToe(z));
		System.out.println(o + ":" + parseAToe(o));

		// 大于平均数的个数
		System.out
				.println("=========================================================");
		System.out.println("测试countOfUpAvg");
		int[] numbs = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(countOfUpAvg(numbs));

		// 二维数组列最大值
		System.out
				.println("=========================================================");
		System.out.println("测试maxOfColumn");
		int[][] maxColM = { { 1, 8, 3 }, { 6, 5 }, {} };
		System.out.println(">二维数组：");
		showMatrix(maxColM);
		System.out.println(">列最大值: ");
		showMatrix(maxOfColumn(maxColM));
		// 二维数组列最小值
		System.out
				.println("=========================================================");
		System.out.println("测试minOfColumn");
		System.out.println(">二维数组：");
		showMatrix(maxColM);
		System.out.println(">列最小值: ");
		showMatrix(minOfColumn(maxColM));

		// 数组倒置
		System.out
				.println("=========================================================");
		System.out.println("测试transMatrix");
		int[][] m = { { 1, 2 }, { 5, 6, 7 } };
		System.out.println(">转换前：");
		showMatrix(m);
		System.out.println(">转换后: ");
		showMatrix(transMatrix(m));

		// 回文数判断
		System.out
				.println("=========================================================");
		System.out.println("测试isPalindrome");
		int pa = 1233421;
		System.out.println(pa + " is palindrome ? >" + isPalindrome(pa));

		// 将数字移到字符后
		System.out
				.println("=========================================================");
		System.out.println("测试backNumToAlph");
		String s = "2s7ess83a";
		System.out.println(s + " > " + backNumToAlph(s));

		// 字符串中最长单词
		System.out
				.println("=========================================================");
		System.out.println("测试longestWorld");
		String ls = "hello china";
		System.out.println(ls + " > " + longestWorld(ls));

		// 删除字符串中个数最多的字符
		System.out
				.println("=========================================================");
		System.out.println("测试delMoreAlph");
		String sdelMoreAlphs = "addcbbs";
		System.out.println(sdelMoreAlphs + " > " + delMoreAlph(sdelMoreAlphs));

		// 数组中TOP N 个数字
		System.out
				.println("=========================================================");
		System.out.println("测试topOfArray");
		int[] ta = { 6, 5, 4, 3, 2, 1 };
		showMatrix(ta);
		System.out.print(" > ");
		showMatrix(topOfArray(ta, 2));

		// 数组相加
		System.out
				.println("=========================================================");
		System.out.println("测试caculateArrays");
		int[] aa = { 6, 5, 4, 3, 2, 1 };
		int[] ab = { 1, 2, 3, 4, 5, 6 };
		showMatrix(aa);
		showMatrix(ab);
		System.out.print(" > ");
		showMatrix(caculateArrays(aa, ab));

	}

	/**
	 * 给定两个数组，a（） b（），如a（）=（1,2,3,5,8） b=（3,4,5,6,9）长度相同 将b()倒序排列和a()相加输出到一个数组中。
	 * 
	 * @param aa
	 * @param ab
	 * @return
	 */
	public static int[] caculateArrays(int[] aa, int[] ab) {
		if (null == ab || 0 == ab.length) {
			return aa;
		}
		ab = popAbsc(ab);
		if (null == aa || 0 == aa.length) {
			return ab;
		}
		int l = aa.length;
		int[] out = new int[l];
		for (int i = 0; i < l; i++) {
			out[i] = aa[i] + ab[i];
		}
		return out;
	}

	/**
	 * 冒泡倒序排列
	 * 
	 * @param ab
	 * @return
	 */
	private static int[] popAbsc(int[] ab) {
		int l = ab.length;
		int t;
		for (int i = 0; i < l; i++) {
			for (int j = 0; j < l - i - 1; j++) {
				if (ab[j] < ab[j + 1]) {
					t = ab[j];
					ab[j] = ab[j + 1];
					ab[j + 1] = t;
				}
			}
		}
		return ab;
	}

	/**
	 * 输出数组前topNum个最大数
	 * 
	 * @param a
	 * @param topNum
	 * @return
	 */
	public static int[] topOfArray(int[] a, int topNum) {
		if (null == a || 0 == a.length) {
			return a;
		}
		if (0 == topNum) {
			return null;
		}
		int l = a.length;
		if (topNum > l) {
			topNum = l;
		}
		int t;
		int[] out = new int[topNum];
		for (int i = 0; i < topNum; i++) {
			for (int j = 0; j < l - i - 1; j++) {
				if (a[j] > a[j + 1]) {
					t = a[j];
					a[j] = a[j + 1];
					a[j + 1] = t;
				}
			}
			out[i] = a[l - i - 1];
		}

		return out;
	}

	/**
	 * 将一个字符里出现最多的字母截取，如，addcbbs变为acs。
	 * 
	 * @param a
	 * @return
	 */
	public static String delMoreAlph(String a) {
		if (null != a && 0 != a.length()) {
			List<Character> keys = new ArrayList<Character>(); // 最大字符列表，保存个数最多的字符
			Set<Character> s = new HashSet<Character>(); // 保存已统计过的字符
			int longestCount = 0;
			int l = a.length();
			char o;
			int oc;
			for (int i = 0; i < l; i++) {
				o = a.charAt(i);
				// 如果已统计过，则不再统计；如果还没有统计过，则扫描该字符之后的字符串
				if (!s.contains(o)) {
					oc = 0;
					for (int j = i + 1; j < l; j++) {
						if (o == a.charAt(j)) {
							oc++;
						}
					}
					s.add(o);
					if (oc == longestCount) // 当前字符个数等于已统计字符中最大个数
					{
						keys.add(o); // 将该字符保存到最大字符列表中
					} else if (oc > longestCount) // 当前字符个数大于已统计字符中最大个数
					{
						// 更新最大个数
						longestCount = oc;
						keys.clear();// 清空最大字符列表
						keys.add(o);// 保存字符到最大字符列表
					}
				}
			}
			// 删除个数最大字符
			if (null != keys && 0 != keys.size()) {
				for (Character key : keys) {
					a = a.replaceAll(key + "", "");
				}
			}
		}
		return a;
	}

	/**
	 * 一个字符串，获取最长的一个单词，如有多个相同长度的单词返回第一个单词。如输入：“hello china”则返回 hello
	 * 
	 * @param oStr
	 * @return
	 */
	public static String longestWorld(String oStr) {
		String w = "";
		if (null == oStr || oStr.length() == 0) {
			return w;
		}
		String[] ws = oStr.split(" ");
		if (null == ws || ws.length <= 1) {
			w = oStr;
		} else {
			w = ws[0];
			int ml = w.length();
			int wl = ws.length;
			for (int i = 1; i < wl; i++) {
				String s = ws[i];
				if (s.length() > ml) {
					w = s;
					ml = s.length();
				}
			}
		}
		return w;
	}

	/**
	 * 输入一个字符串，字符串是字母和数字的组合，编程实现输出一个新的字符串，要求字母在前面，数字在后面，顺序不变，例如：2s7ess83a
	 * 变成sessa2783
	 * 
	 * @param oStr
	 * @return
	 */
	public static String backNumToAlph(String oStr) {
		if (null == oStr || oStr.length() == 0) {
			return oStr;
		}
		int l = oStr.length();
		for (int i = 0; i < l;) {
			char t = oStr.charAt(i);
			if (t >= 49 && t <= 57) {
				oStr = oStr.replaceFirst(String.valueOf(t), "");
				oStr = oStr.concat(String.valueOf(t));
				l -= 1;
			} else {
				i++;
			}
		}
		return oStr;
	}

	/**
	 * 判断输入数字是否为回文数
	 * 
	 * @param a
	 * @return
	 */
	public static boolean isPalindrome(int a) {
		int y = 0;
		int b = a;
		// 将a倒置
		while (b > 0) {
			y = 10 * y + b % 10;
			b /= 10;
		}
		if (y == a) {
			return true;
		}
		return false;
	}

	/**
	 * 给一个二维数组inArr[ ][ ],写一个方法获取每一列的最大值，输出到一个一维数组outArr[ ]中。 如：inArr[ ][
	 * ]={{1,8,3},{6,5}}，则输出outArr[ ] = {6,8,3}
	 * 
	 * @param am
	 * @return
	 */
	public static int[] maxOfColumn(int[][] am) {
		int[] out = null;
		if (null != am && 0 != am.length) {
			int rl = am.length;
			// 最大列数
			int maxColumnCount = 0;
			for (int i = 0; i < rl; i++) {
				if (maxColumnCount < am[i].length) {
					maxColumnCount = am[i].length;
				}
			}
			out = new int[maxColumnCount];
			int t;
			for (int i = 0; i < maxColumnCount; i++) {
				t = Integer.MIN_VALUE;
				for (int j = 0; j < rl; j++) {
					if (i < am[j].length && am[j][i] > t) {
						t = am[j][i];
					}
				}
				out[i] = t;
			}
		}
		return out;
	}

	/**
	 * 给一个二维数组inArr[ ][ ],写一个方法获取每一列的最小值，输出到一个一维数组outArr[ ]中。 如：inArr[ ][
	 * ]={{1,8,3},{6,5}}，则输出outArr[ ] = {1,5,3}
	 * 
	 * @param am
	 * @return
	 */
	public static int[] minOfColumn(int[][] am) {
		int[] out = null;
		if (null != am && 0 != am.length) {
			int rl = am.length;
			// 最大列数
			int maxColumnCount = 0;
			for (int i = 0; i < rl; i++) {
				if (maxColumnCount < am[i].length) {
					maxColumnCount = am[i].length;
				}
			}
			out = new int[maxColumnCount];
			int t;
			for (int i = 0; i < maxColumnCount; i++) {
				t = Integer.MAX_VALUE;
				for (int j = 0; j < rl; j++) {
					if (i < am[j].length && am[j][i] < t) {
						t = am[j][i];
					}
				}
				out[i] = t;
			}
		}
		return out;
	}

	/**
	 * 实现数组倒置算法： 如一数组：1,2,3 4,5,6 则倒置后：1,4 2,5 3,6
	 * 
	 * @param old
	 * @return
	 */
	public static int[][] transMatrix(int[][] old) {
		if (null != old && old.length != 0) {
			// 创建临时变量count，记录数组中长度最大的数组length
			int count = 0;
			int oldLength = old.length;
			for (int i = 0; i < oldLength; i++) {
				if (count < old[i].length) {
					count = old[i].length;
				}
			}
			// 创建数组用来装载倒置的数组数据
			int rea[][] = new int[count][oldLength];

			// 倒置
			int rl;
			for (int i = 0; i < oldLength; i++) {
				rl = old[i].length;
				for (int j = 0; j < rl; j++) {
					rea[j][i] = old[i][j];
				}
			}

			return rea;
		}
		return null;
	}

	// 输出数组
	public static void showMatrix(int[][] a) {
		for (int x[] : a) {
			for (int e : x) {
				System.out.print(e + " ");
			}
			System.out.println();
		}
		System.out.println();
	}

	public static void showMatrix(int[] a) {
		for (int e : a) {
			System.out.print(e + " ");
		}
		System.out.println();
	}

	public static void showMatrix(char[] a) {
		for (char e : a) {
			System.out.print(e + " ");
		}
		System.out.println();
	}

	/**
	 * 一个维数组，求大于等于数组内的所有值的平均值的个数 例，{1、2、3、4、5、6、7、8、9、10} 输出 5
	 * 
	 * @param numbs
	 * @return
	 */
	public static int countOfUpAvg(int[] numbs) {
		if (null != numbs && numbs.length != 0) {
			int sum = 0;
			for (int i : numbs) {
				sum += i;
			}
			int l = numbs.length;
			double avg = sum * 1.0 / l;
			int count = 0;
			for (int i : numbs) {
				if (i >= avg) {
					count++;
				}
			}
			return count;
		}
		return 0;
	}

	/**
	 * 根据以下要求，比较两个字符串的大小，并返回比较结果： 1、比较两字符串的大小。 2、忽视大小写 3、 按字典序 如果第一个字符串大于第二个字符串
	 * 返回大于0，如果第一个字符串等于第二个字符串 返回等于0 ，如果第一个字符串小于第二个字符串返回小于0。 4、例子
	 * compareToIgnoreCase(“HARD”,”hark”)的比较结果返回小于0 。
	 * 
	 * @param leftStr
	 * @param rightStr
	 * @return
	 */
	public static int compareToIgnoreCase(String leftStr, String rightStr) {
		if (null == leftStr || null == rightStr) {
			return 0;
		}
		int ll = leftStr.length();
		int rl = rightStr.length();
		char cl;
		char cr;
		for (int l = 0, r = 0; l < ll && r < rl; l++, r++) {
			cl = leftStr.charAt(l);
			cr = rightStr.charAt(r);
			if (cl != cr) {
				if (Character.toUpperCase(cl) != Character.toUpperCase(cr)) {
					return cl - cr;
				}
			}
		}
		return ll - rl;
	}

	/**
	 * 判断一个字符串是否是首字母大写，其余字母都是小写。 例如 输入：Ｔｒｕｅ 输出： true
	 * 
	 * @param world
	 * @return
	 */
	public static boolean isCamelWorld(String world) {
		if (null == world || world.isEmpty()) {
			return false;
		}
		int length = world.length();
		char c = world.charAt(0);
		if (c >= 65 && c <= 90) {
			for (int i = 1; i < length; i++) {
				c = world.charAt(i);
				if (c < 97 || c > 122) {
					return false;
				}
			}
			return true;
		}
		return false;
	}

	/**
	 * 输入A-Z26个字母，输入一个大写字母后，输出该字母之后第5个字母的小写。
	 * 如输入A，输出f，输入Z，则输出e，超出Z是，超过1个，则返回a，超过两个，则返回b，以此类推
	 * 
	 * @param a
	 * @return
	 */
	public static char parseAToe(char a) {
		if (a >= 65 && a <= 90) {
			return toChar((a + 32 + 5) % 96 % 26);
		} else if (a > 90) {
			return toChar((a - 90) % 26);
		} else {
			return toChar(a);
		}
	}
	
	/**
	 * 将1-26转换为对应英文字符
	 * 
	 * @param codes
	 * @return
	 */
	public static char[] intToEng(int[] codes) {
		if (null == codes || codes.length == 0) {
			return new char[0];
		} else {
			int l = codes.length;
			char[] cs = new char[l];
			for (int i = 0; i < l; i++) {
				cs[i] = toChar(codes[i]);
			}
			return cs;
		}
	}
	/**
	 * 将1-26转换为对应英文字符
	 * 
	 * @param code
	 * @return
	 */
	private static char toChar(int code) {
		if (code < 1 || code > 26) {
			return '?';
		}
		return (char) (code + 96);
	}
}