import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class test01 {
/**
* 根据以下要求，比较两个字符串的大小，并返回比较结果：
* 1、比较两字符串的大小。
* 2、忽视大小写
* 3、 按字典序 如果第一个字符串大于第二个字符串 返回大于0，如果第一个字符串等于第二个字符串 返回等于0 ，如果第一个字符串小于第二个字符串返回小于0。
* 4、例子 compareToIgnoreCase("HARD","hark")的比较结果返回小于0 。
* @param str1
* @param str2
* @return
*/
public static String test1(String str1, String str2)
{
String strValue = "";
//compareToIgnoreCase是字符串比较大小、忽略大小写和返回值的方法
if(str1.compareToIgnoreCase(str2) > 0)
{
strValue = "> 0";
}else if(str1.compareToIgnoreCase(str2) == 0)
{
strValue = "= 0";
}else
{
strValue = "< 0";
}
return strValue;
}
/**
* 给一个二维数组inArr[ ][ ],写一个方法获取每一列的最小值，输出到一个一维数组outArr[ ]中。
* 如：inArr[ ][ ]={{1,8,3},{6,5}}，则输出outArr[ ] = {1,5,3}
* @return
*/
public static String test2(int[][] inArr)
{
//获取二维数组中一维数组的最大长度
int maxLength = getMaxLength(inArr);
List<Integer []> list1=new ArrayList<Integer []>();
List<Integer> list = new ArrayList<Integer>();
//循环一维数组的最大长度
for (int j = 0; j < maxLength; j++)
{
//循环二维数组的长度
for (int i = 0; i < inArr.length; i++)
{
//获取对应一维数组的长度
int tempLength=inArr[i].length;
//防止非法索引访问数组时抛出的异常，因为第二个一维数组少了一个长度，因此读取的时候索引大于数组的大小
if((j+1)>tempLength)
{
continue;
}
list.add(inArr[i][j]);
}
Integer temp[]=(Integer[]) list.toArray(new Integer[list.size()]);
list= new ArrayList<Integer>();
list1.add(temp);
}
int temp[]=new int[maxLength];
int c=0;
for(int i=0;i<list1.size();i++){
Integer [] obj=(Integer [])list1.get(i);
//升序
Arrays.sort(obj);
/*for(int j=0;j<obj.length;j++){
System.out.print(obj[j]);
}*/
//在升序中取第一个
temp[c++]=obj[0];
/*System.out.println();*/
}
return "{"+temp[0]+","+temp[1]+","+temp[2]+"}";
}
/**
* 获取数组的长度
* @param array
* @return
*/
public static int getMaxLength(int array[][]) {
int length = 0;
for (int i = 0; i < array.length; i++) {
length = length < array[i].length ? length = array[i].length : length;
}
return length;
}
/**
* 判断一个字符串是否是首字母大写，其余字母都是小写。
* @param str
* @return
*/
public static String test3(String str)
{
boolean bResult = true;
String strValue = "";
int iLength = str.length();
for(int i=0; i<iLength; i++)
{
char c = str.charAt(i);
if(i == 0)
{
//判断字母是否是大写
if(!Character.isUpperCase(c))
{
bResult = false;
break;
}
}else
{
//判断字母是否是小写
if(!Character.isLowerCase(c))
{
bResult = false;
break;
}
}
}
strValue = ("".equals(str)) ? "" : bResult + "";
return strValue;
}
/**
* 输入一个字符串，字符串是字母和数字的组合，编程实现输出一个新的字符串，要求字母在前面，数字在后面，顺序不变，例如：2s7ess83a 变成sessa2783
* @param str
* @return
*/
public static String test4(String str)
{
StringBuffer strValue = new StringBuffer();
StringBuffer strNumber = new StringBuffer();
for(int i=0; i<str.length(); i++)
{
char c = str.charAt(i);
//判断是否是数字
if(Character.isDigit(c))
{
strNumber.append(c);
}else
{
strValue.append(c);
}
}
return strValue.toString() + strNumber.toString();
}
/**
* 一个字符串，获取最长的一个单词，如有多个相同长度的单词返回第一个单词。入输入："hello china"则返回 hello
* @param str
* @return
*/
public static String test5(String str)
{
String strOld = "";
String [] sStr = str.split(" ");
for(String strNew:sStr)
{
//判断前一个单词比后一个单词短
if(strOld.length() < strNew.length())
{
strOld = strNew;
}
}
return strOld;
}
/**
* 将一个字符里出现最多的字母截取，如，addcbbs变为acs。
* @param str
* @return
*/
public static String test6(String str)
{
char[] cStr = str.toCharArray();
int iMax = 0;
//把字符串去重复，这样可以方便定义数组长度等
String strTemp = str.replaceAll("(?s)(.)(?=.*\\1)", "");
int iLength = strTemp.length();
int[] iCount = new int[iLength];
char[] cTemp = strTemp.toCharArray();
//获取每个字母出现的次数，并存储到数组
for(int i=0; i<iLength; i++)
{
int iTemp = cTemp[i];
for(int j=0; j<str.length(); j++)
{
int jTemp = cStr[j];
if(iTemp == jTemp)
{
iCount[i] += 1;
}
}
}
//获取字母出现最多的次数
for (int i = 0; i < iCount.length; i++)
{
int iValue = iCount[i];
if (iValue > iMax)
{
iMax = iValue;
}
}
//替换字母出现最多的字母
for (int i = 0; i < iCount.length; i++)
{
int iValue = iCount[i];
if (iValue == iMax)
{
int iID = strTemp.charAt(i);
String strValue = (char)iID + "";
str = str.replace(strValue, "");
}
}
return str;
}
/**
* 输入一个整型数组，arr=(1,2,5)
* 输出数组中数字对应英文字母表中对应的字母，如果不在字母表中用"?"表示
* 例如，输入arr=（1,2,30，3），输出：a b ? c
* @param str
*/
public static String test7(int[] inArr)
{
String strValue = "";
for(int iArr:inArr)
{
//因为小写字母a的char值是97，因此需要增加96就可以达到char值
iArr = iArr + 96;
//判断是否超出和小于小写字母的char值
if(iArr > 96 && iArr < 123)
{
strValue += (char)iArr;
}else
{
strValue += "?";
}
}
return strValue;
}
/**
* 输入一数组，按照英文26个字母顺序，输出每个数字对应的字母，如果查不到，则输出？。如[1,3,30]，输出ac?。
* @param str1
* @param str2
*/
public static String test8(int[] inArr)
{
//a-z ==> 97-122
String strValue = "";
for(int iArr:inArr)
{
//因为小写字母a的char值是97，因此需要增加96就可以达到char值
iArr = iArr + 96;
//判断是否超出和小于小写字母的char值
if(iArr > 96 && iArr < 123)
{
strValue += (char)iArr;
}else
{
strValue += "?";
}
}
return strValue;
}
/**
* 把数组中的1-26的数字映射成a-z的小写字母
* 如果输入其他数字，则在页面上打印"?"
* 如：int [] arr={1,2,3,4,30}
* 输出：a,b,c,d,?
* @param inArr
* @return
*/
public static String test9(int[] inArr)
{
//a-z ==> 97-122
String strValue = "";
for(int iArr:inArr)
{
//因为小写字母a的char值是97，因此需要增加96就可以达到char值
iArr = iArr + 96;
//判断是否超出和小于小写字母的char值
if(iArr > 96 && iArr < 123)
{
strValue += (char)iArr + ",";
}else
{
strValue += "?,";
}
}
strValue = ("".equals(strValue)) ? "" : strValue.substring(0, strValue.length() - 1);
return strValue;
}
/**
* 输入A-Z26个字母，输入一个大写字母后，输出该字母之后第5个字母的小写。
* 如输入A，输出f，输入Z，则输出e，超出Z是，超过1个，则返回a，超过两个，则返回b，以此类推。
* @param str
* @return
*/
public static String test10(String str)
{
String strValue = "";
int iValue = str.charAt(0);
//A-Z ===> 65-90，判断是否是大写
if(Character.isUpperCase((char)iValue))
{
//86到90刚好5个，所以到了85后就会继续到a
if(iValue < 86)
{
iValue = iValue + 5;
}else
{
//公式是:64+(5-(90-iValue));为什么是从64开始而不是65，因为A是65，从Z到A也要加1
iValue = iValue - 21;
}
char cValue = (char) (iValue);
strValue = cValue + "";
strValue = strValue.toLowerCase();
}
return strValue;
}
/**
* 一个维数组，求大于等于数组内的所有值的平均值的个数
* 例，{1、2、3、4、5、6、7、8、9、10} 输出 5
* @param inArr
* @return
*/
public static String test11(int[] inArr)
{
int iNum = 0;
int iLength = inArr.length;
int iSum = 0;
for(int iArr:inArr)
{
//加总
iSum += iArr;
}
//平均值
int iAvg = iSum/iLength;
for(int iArr:inArr)
{
//比平均值高的，+1
if(iArr > iAvg)
{
iNum = iNum + 1;
}
}
return iNum + "";
}
/**
* 给一个二维数组inArr[ ][ ],写一个方法获取每一列的最大值，输出到一个一维数组outArr[ ]中。
* 如：inArr[ ][ ]={{1,8,3},{6,5}}，则输出outArr[ ] = {8,6}
* 选取一组一维数组，求出它的最大值和次大值，放入另一个一维数组中并返回。
* @param inArr
* @return
*/
public static String test12(int[][] inArr)
{
StringBuffer strValue = new StringBuffer();
int maxLength = 0;
int minLength = 0;
//获取二维数组中的一维数组的最大长度
for (int i = 0; i < inArr.length; i++)
{
if (inArr[i].length > maxLength)
{
maxLength = inArr[i].length;
}
}
//获取二维数组中的一维数组的最小长度
for (int i = 0; i < inArr.length; i++)
{
if(i == 0)
{
minLength = inArr[i].length;
}else
{
if (inArr[i].length < minLength)
{
minLength = inArr[i].length;
}
}
}
//比较前，对输出赋予最大长度
int[] outArr = new int[maxLength];
for (int column = 0; column < maxLength; column++)
{
//获取Integer最小值并赋予输出数组
outArr[column] = Integer.MIN_VALUE;
for (int row = 0; row < inArr.length; row++)
{
if (column < inArr[row].length)
{
//如果输入数组的值比输出的值大，输出数组的值由输入的值替代
if (inArr[row][column] > outArr[column])
{
outArr[column] = inArr[row][column];
}
}
}
}
//Arrays升序
Arrays.sort(outArr);
for(int i=0; i<minLength; i++)
{
strValue.append(outArr[maxLength - 1 - i]);
strValue.append(",");
}
String str = strValue.toString();
str = ("".equals(str)) ? "" : str.substring(0, str.length()-1);
return "{"+ str +"}";
}
/**
* 求两个数的最大公约数
* @param str1
* @param str2
* @return
*/
public static String test13(int str1, int str2)
{
int iMin = Math.min(str1, str2);
for(int i=iMin; i>0; i--)
{
if(str1%i == 0 && str2%i == 0)
{
return i + "";
}
}
return 0 + "";
}
/**
* @param args
*/
public static void main(String[] args) {
String strStart1 = "HARD";
String strEnd1 = "hark";
int [][] inArr212 = {{1, 8, 3}, {6, 5}};
String strValue3 = "HadadsDs";
String strValue4 = "2s7ess83a";
String strValue5 = "hello china";
String strValue6 = "addcbbs";
int[] inArr7 = {1,2,30,3};
int[] inArr8 = {1,3,30};
int[] inArr9 = {1,2,3,4,30};
int[] inArr11 = {1,2,3,4,5,6,7,8,9,10};
System.out.println("输出：");
System.out.println("Test1：比较两个字符串的大小，结果： " + test1(strStart1, strEnd1));
System.out.println("Test2：二维数组获取每一列的最小值，结果： " + test2(inArr212));
System.out.println("Test3：判断 首字母大写，其余字母都是小写，结果：" + test3(strValue3));
System.out.println("Test4：输出要求字母在前面，数字在后面，结果：" + test4(strValue4));
System.out.println("Test5：获取最长的一个单词，如有多个相同长度的单词返回第一个单词，结果：" + test5(strValue5));
System.out.println("Test6：字母截取，结果：" + test6(strValue6));
System.out.println("Test7：输入一个整型数组，输出对应的字母，如：" + test7(inArr7));
System.out.println("Test8：输入一数组，按照英文26个字母顺序，输出每个数字对应的字母，如果查不到，则输出？，结果： " + test8(inArr8));
System.out.println("Test9：把数组中的1-26的数字映射成a-z的小写字母，结果： " + test9(inArr9));
System.out.println("Test10：输入一个大写字母后，输出该字母之后第5个字母的小写，结果：" + test10("A"));
System.out.println("Test11：求大于等于数组内的所有值的平均值的个数，结果： " + test11(inArr11));
System.out.println("Test12：二维数组获取每一列的最大值，结果： " + test12(inArr212));
System.out.println("Test13：求两个数的最大公约数，结果：" + test13(24, 36));
}
}
3589
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
