java题目

package com.test;

import java.util.Arrays;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;

public class Sort
{
    /**
     * 根据以下要求，比较两个字符串的大小，并返回比较结果：
     * 1、比较两字符串的大小。 2、忽视大小写
     *  3、 按字典序 如果第一个字符串大于第二个字符串 返回大于0，
     * 如果第一个字符串等于第二个字符串 返回等于0
     * ，如果第一个字符串小于第二个字符串返回小于0。
     * 4、例子 compareToIgnoreCase(“HARD”,”hark”)的比较结果返回小于0 。
     *
     * @param str1
     * @param str2
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static int  sortArray(String str1, String str2)
    {
       String str1Temp = str1.toLowerCase();
       String str2Temp = str2.toLowerCase();

       if(str1.compareToIgnoreCase(str2) > 0)
       {
           return 1;
       }else if(str1.compareToIgnoreCase(str2) < 0)
       {
           return -1;
       }else
       {
           return 0;
       }

    }

    /**
     * 把数组中的1-26的数字映射成a-z的小写字母 如果输入其他数字，则在页面上打印"?"
     * 如：int [] arr={1,2,3,4,30} 输出：a,b,c,d,?
     *
     * @param a
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static String conver(int[] a)
    {
        String goal = "";
        for(int i= 0; i < a.length;i++)
        {
            if(a[i] > 26 || a[i] <1)
            {
                goal = goal +"?,";
            }
            else
            {
                int temp = a[i]+'a'-1;
                char str = (char)(temp);
                goal = goal+str+",";
            }
        }
        return goal.substring(0, goal.length()-1);
    }

    /**
     * 输入A-Z26个字母，输入一个大写字母后，输出该字母之后第5个字母的小写。
     *  如输入A，输出f…… 输入Z，则输出e。 超出Z时，超过1个，
     *  则返回a，超过两个，则返回b，以此类推。
     */
    public static char converTochar(char chars)
    {
        if (chars >= 'A' && chars <= 'Z')
        {
            if ((chars + 5) > 90)
            {
                return (char)(chars - 85 + 'a' - 1);
            }
            else
            {
                return (char)(chars + 37);
            }

        }    
            return chars;
    }

    /**
     * 判断一个字符串是否是首字母大写，其余字母都是小写。
     *  例如 输入：Ｔｒｕｅ 输出： true
     */



    /**
     * 给一个二维数组inArr[ ][ ],写一个方法获取每一列的最小值，输出到一个一维数组outArr[ ]中。
     *  如：inArr[ ][ ]={{1,8,3},{6,5}}，则输出outArr[ ] = {1,5,3}
     */
    public static int[] findMin(int[][] inArr)
    {
        int maxLength = 0;
        for (int i = 0; i < inArr.length; i++)
        {
            if (inArr[i].length > maxLength)
            {
                maxLength = inArr[i].length;
            }
        }
        int[] outArr = new int[maxLength];
        for (int column = 0; column < maxLength; column++)
        {
            outArr[column] = Integer.MAX_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];
                    }
                }
            }
        }
        return outArr;
    }

    /**
     * 实现数组倒置算法： 如一数组：1,2,3 4,5,6 则倒置后：1,4 2,5 3,6
     */
    public static int[][] goal(int[][] arrays)
    {
        int[][] goal = new int[arrays[0].length][arrays.length];
        for (int i = 0; i < arrays.length; i++)
        {
            for (int j = 0; j < arrays[0].length; j++)
            {
                goal[j][i] = arrays[i][j];
            }
        }
        return goal;
    }
    /**
     * 输入一个字符串，字符串是字母和数字的组合，编程实现输出一个新的字符串，
     * 要求字母在前面，
     * 数字在后面，顺序不变，例如：2s7ess83a 变成sessa2783
     */
    public static String splits(String str)
    {
        String strings = "";
        String numbers ="";
        for(int i = 0;i < str.length();i++)
        {
            if((str.charAt(i)>= 'A' && str.charAt(i) <='Z')||
                (str.charAt(i)>= 'a' && str.charAt(i) <='z'))
            {
                strings = strings + str.charAt(i);
            }else
            {
                numbers = numbers +str.charAt(i);
            }
        }
        return strings+numbers;
    }
   /**
    * 一个字符串，获取最长的一个单词，如有多个相同长度的单词返回第一个单词。
    * 入输入：“hello china”则返回 hello
    */
    public static String getString(String str)
    {
        String[] strings = str.split(" ");
        String tempMaxLenth = strings[0];
        for(int i = 1;i < strings.length;i++)
        {
            if(tempMaxLenth.length() < strings[i].length())
            {
                tempMaxLenth = strings[i];
            }
        }
        return tempMaxLenth;

    }
/**
 * 回文
 *
 */

    public static int huiwen(int str[])
    {
    int i,len,k=1;
    len=str.length;
   // len=str.len(str);
    for(i=0;i<len/2;i++)
    {
    if(str[i]!=str[len-i-1])
    {
    k=0;
    break;
    }
    }
    if(k==0)
   System.out.println(Arrays.toString(str) +"不是一个回文数");
    else
        System.out.println(Arrays.toString(str)+"是一个回文数");
    return 0;
    }


/**
 * 输入一个字符串，字符串是字母和数字的组合，编程实现输出一个新的字符串，
 * 要求字母在前面，数字在后面，顺序不变，例如：2s7ess83a 变成sessa2783
 */

    public static String getString(String a)
    {
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();

        char arr[] = a.toCharArray();

        for (int i = 0; i < arr.length; i++)
        {
            int temp = Integer.valueOf(arr[i]);

            if ('0' <= temp && temp <= '9')
            {
                sb2.append(arr[i]);
            }
            else
            {
                sb1.append(arr[i]);
            }
        }

        return sb1.append(sb2).toString();
    }


    /**
     *将一个字符里出现最多的字母截取，如，addcbbs变为acs。
     */

方法1：
   public static void main(String args[])
    {
    String str="213sdf452346dfhb";

    String temp=“”;

char[] c=str.toCharArray();

    for(int i=0; i<c.length;i++)
    {
        if(temp.indexOf(c[i])==-1)
        {
        temp+=c[i];
        
        }
    }
    System.out.println("去重后的字符窜为:"+temp);
    }
    

方法2：
    public static String splits(String str)
        {
            String strings = "";
            String numbers = "";
            for (int i = 0; i < str.length(); i++)
            {
                if ((str.charAt(i) >= 'A' && str.charAt(i) <= 'Z') ||
                    (str.charAt(i) >= 'a' && str.charAt(i) <= 'z'))
                {
                    strings = strings + str.charAt(i);
                }
                else
                {
                    numbers = numbers + str.charAt(i);
                }
            }
            return strings + numbers;
        }

        public static String subStrings(String str)
        {
            String goals = "";
            Set set = new HashSet<String>();
            List<String> goalList = new ArrayList<String>();
            for (int i = 0; i < str.length(); i++)
            {
                set.add(str.charAt(i) + "");
                goalList.add(str.charAt(i)+"");
            }
            // String[] goal = (String[])set.toArray();
            String[] goal = (String[])set.toArray(new String[0]);
            // char[] goalt = (char[])set.toArray();//(new char[0]);
            int[] count = new int[goal.length];


            for (int i = 0; i < goal.length; i++)
            {
                int tempCount = 0;
                for (int j = 0; j < str.length(); j++)
                {
                    if (goal[i].equals(str.charAt(j)+""))
                    {
                        tempCount++;
                    }
                }
                count[i] = tempCount;
            }
            int countMax = count[0];
            List<Integer> MaxCount = new ArrayList<Integer>();
            for (int i = 1; i < count.length; i++)
            {
                if (count[i] > countMax)
                {
                    countMax = count[i];
                }
            }

            List<String> goalListRemove = new ArrayList<String>();
            for (int i = 0; i < count.length; i++)
            {
                if (count[i] == countMax)
                {
                    goalListRemove.add(goal[i]);
                    MaxCount.add(i);
                }
            }

            for (Iterator it = goalList.iterator(); it.hasNext();)
            {
                String a = (String)it.next();

                if(goalListRemove.contains(a))
                {
                    it.remove();
                }
            }


            return goalList.toString();
        }




   //c[i]= a[i]+b[b.lenght()-i-1];
    public static void main(String args[])
    {

//        int [] arr={1,2,3,4,30,8};
//        Arrays.sort(arr);
//        System.out.print(Arrays.toString(arr));
//
//
//        char temp = 'A';
//       System.out.println(Sort.isHope("TruE"));
//
//       System.out.println(Arrays.deepToString(Sort.goal(arrays)));

        charstr[] a="12345654321";
        a.
    }
}