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 输出: 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);
}
}
JAVA 基础练习
最新推荐文章于 2013-11-21 15:45:00 发布