300分！给一个数组求里面出现次数最多的元素和其次数另：需要加上时间复杂度，否则只给5分。最优算法给100分

int[] count = new int[1000];//数组长度为最大数，该方法有这个缺陷，要知道数的范围
int nums []= { 2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
for(int i = 0 ; i < nums.length;i++)
{
count[nums[i]]++;
}
int max = 0;//对应的数
int maxCount = 0;//最大次数
for(int i = 0 ; i < 1000;i++)
{
if(count[i]>maxCount)
{
maxCount = count[i];
max = i;
}
}
System.out.println(max+" "+maxCount);
算法复杂度O(N+M) M为数范围 N为数组大小

改了下，刚才忘了可能有多个数出现最多次 int[] count = new int[1000];//数组长度为最大数，该方法有这个缺陷，要知道数的范围
int nums []= { 2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
for(int i = 0 ; i < nums.length;i++)
{
count[nums[i]]++;
}
List<Integer> max = new ArrayList<Integer>();//对应的数
int maxCount = 0;//最大次数
for(int i = 0 ; i < 1000;i++)
{
if(count[i]>maxCount)
{
maxCount = count[i];
max = new ArrayList<Integer>();
max.add(i);
}
else if(count[i]==maxCount)
{
max.add(i);
}
}
System.out.println(max+" "+maxCount);O(N+M)系数就没考虑了

算法思想是：先将数组排序，然后再遍历一遍就可以得到出现最多的那个数了~~import java.util.Arrays;
public class Test{
  public static void main(String args[]){
int nums []=  { 2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
Arrays.sort(nums);
int flag = nums[0];
int time = 0;
int maxNum = 0;
int maxTime = 0;
for(int i = 0; i < nums.length; i++)
{
if(nums[i] == flag)
{
time++;
}
else if(nums[i]!=flag)
{
if(time > maxTime)
{
maxTime = time;
maxNum = nums[i-1];
}
flag = nums[i];
time = 1;
}
}
System.out.println(maxNum + " " + maxTime);

  }
}
复杂度就转移到了采用什么排序算法了。这里用的是JDK提供的排序：
对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能

import java.util.*;
public class TestGrepLegalWord {
    public static void main(String[] args) {
Integer nums []=  { 2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
HashMap<Integer, Integer> hashMap = getHashMap(nums);
System.out.println(getMaxTimes(hashMap));
    }
    public static HashMap<Integer, Integer> getHashMap( Integer[] a) {
HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
for(int i=0; i<a.length; i++)
   if(hashMap.get(a[i]) == null)hashMap.put(a[i],1);
   else hashMap.put(a[i],hashMap.get(a[i])+1);
return hashMap;
    }
    public static int getMaxTimes(HashMap<Integer ,Integer> hashMap){
int maxTimes = 0;
Iterator<Integer> iterator = hashMap.keySet().iterator();
while (iterator.hasNext()) {
    Integer temp = iterator.next();
    if(maxTimes<hashMap.get(temp))maxTimes = hashMap.get(temp);
     }
return maxTimes;
    }
}
复杂度O(N+M)

感觉hashMap的时间复杂度应该不止O(N+M) 因为hash到数组的一个位置之后会遍历链状的Entry寻找元素

一般会想到用Hashmap 但是应该不是最优算法

如果是LZ举例的数字的话，投机取巧一下
int[] cnt = {0,0,0,0,0,0,0,0,0,0}; //分别记录数字0,1,2,3,4,5,6,7,8,9的次数
int[] max = {0,0}; //记录出现最多的数字以及出现次数，max[0]次数，max[1]数字
for (int n : num) { //遍历数组
    cnt[n]++; //该数字对应的计数器累加
    if (cnt[n] > max[0]) { //比较计数器和当前最大次数
        max[0] = cnt[n];
        max[1] = n;
    }
}
System.out.printf("最大数字：%d，出现次数：%d\n", max[1], max[0]);时间复杂度O(N)，只需要遍历数组一遍即可

int nums[] = {1,2,3,3,6,8,9,2,3,9,9,9,9,9};
Map<Integer, Integer> treeMap = new TreeMap<Integer, Integer>();
for(int i = 0; i < nums.length; i++) {
int tempNum = nums[i];
if(!treeMap.containsKey(tempNum)) {
// 如果第一次出现，则初始为1
treeMap.put(tempNum, 1);
}else {
// 如果在容器中已存在，则在原来的基础上+1
int auto = treeMap.get(tempNum)+1;
treeMap.put(tempNum, auto);
}
}
int maxNum = 0;//最多的数字
int degree = 0;//最多的次数
Iterator<Integer> iter = treeMap.keySet().iterator();
while(iter.hasNext())
{
Integer temp = iter.next();
if(treeMap.get(temp)>maxNum) {
maxNum=temp;
degree = treeMap.get(temp);

}
// 输出每个数字出现的次数
System.out.println("数字"+temp+"' 出现"+treeMap.get(temp)+"次。");
}
System.out.println("出现最多的数字是："+maxNum+"，出现的次数是："+degree+"次");
}
输出的结果是：数字1' 出现1次。
数字2' 出现2次。
数字3' 出现3次。
数字6' 出现1次。
数字8' 出现1次。
数字9' 出现6次。
出现最多的数字是：9，出现的次数是：6次
不知道这是不是LZ想要的结果

嘿嘿，你数据如果0-9的话，我就要你分咯，int[] data=new int[10];
for(int i=0;i<nums.length;i++){
data[nums[i]]++;
}
//在循环求出，data中数值最大的，获取其下标那么就是出现次数最多的数，值就是出现的次数咯；

import java.util.Random;public class MarquisSort
{
  private static int[] resultData;

  public static void main( String[] args )
  {  int MAX = 1000;
  int[] nums = {2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
  long begin = System.currentTimeMillis();
  int[] data = sort( nums );
  int flag = data[0];
  int time = 0;
  int maxNum = 0;
  int maxTime = 0;
  for(int i = 0; i < data.length; i++)
  {
      if(data[i] == flag)
      {
          time++;
      }
      else if(data[i]!=flag)
      {
          if(time > maxTime)
          {
              maxTime = time;
              maxNum = data[i-1];
          }
          flag = data[i];
          time = 1;
      }
  }
  System.out.println(maxNum + " " + maxTime);
  long end = System.currentTimeMillis();
  System.out.println( ( end - begin )/10000000); // 以这个时间为标准，越小越好。
  }  public static int[] sort( int[] nums ){
  int max = getMax(nums)+1;
  int[] temp = new int[max];
  for(int i:nums){
  temp[i]++;
  }

  int pos=0;
  for (int i=0;i<max;i++){
  if (temp[i]>0){
  for(int l=0;l<temp[i];l++)
  nums[pos++]=i;
  }
  }
  return nums;
  }
  private static int getMax( int[] data ) {
  int max = 0;
  for( int i : data ){
  if( i > max ){
  max = i;
  }
  }
  return max;
  }
}

哥们，我这边网速不好，复制LZ的那个数字复制不上，所以我就自己随便写了一个数组，下面是用LZ的数组
int[] nums = {2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7}; Map<Integer, Integer> treeMap = new TreeMap<Integer, Integer>();
for(int i = 0; i < nums.length; i++) {
int tempNum = nums[i];
if(!treeMap.containsKey(tempNum)) {
// 如果第一次出现，则初始为1
treeMap.put(tempNum, 1);
}else {
// 如果在容器中已存在，则在原来的基础上+1
int auto = treeMap.get(tempNum)+1;
treeMap.put(tempNum, auto);
}
}
int maxNum = 0;//最多的数字
int degree = 0;//最多的次数
Iterator<Integer> iter = treeMap.keySet().iterator();
while(iter.hasNext())
{
Integer temp = iter.next();
if(treeMap.get(temp)>maxNum) {
maxNum=temp;
degree = treeMap.get(temp);

}
// 输出每个数字出现的次数
System.out.println("数字"+temp+"' 出现"+treeMap.get(temp)+"次。");
}
System.out.println("出现最多的数字是："+maxNum+"，出现的次数是："+degree+"次");
}
这是结果：
数字0' 出现96次。
数字0' 出现96次。
数字1' 出现118次。
数字2' 出现112次。
数字3' 出现101次。
数字4' 出现100次。
数字5' 出现95次。
数字6' 出现90次。
数字7' 出现94次。
数字8' 出现102次。
数字9' 出现92次。
出现最多的数字是：1，出现的次数是：118次

对不起！刚才太急了，程序中有点小问题改一下，还有那个结果中的数字0' 出现96次。出现了两次是我手误
int maxNum = 0;//最多的数字
int degree = 0;//最多的次数
Iterator<Integer> iter = treeMap.keySet().iterator();
while(iter.hasNext())
{
Integer temp = iter.next();
if(treeMap.get(temp)>degree) {
maxNum=temp;
degree = treeMap.get(temp);

}

我是这样考虑的，既然用Java写，就写出Java的特色吧。
由于已经包装过，HashMap绝对不是最优的算法。但已经是相当快速的集合了。
如果只是追求速度，我想汇编语言无敌了，写起来也不困难

我刚开始接触java，不是太会编程，但总要先顶一下哈~~~

package CSDN;import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class CountArray {
public static void main(String[] args) {
int nums[] = { 2, 4, 3, 6, 9, 2, 1, 9, 3, 7, 4, 1, 0, 1, 2, 2, 1, 5, 8,
8, 4, 1, 1, 7, 6, 1, 9, 6, 5, 5, 6, 9, 1, 8, 7, 9, 9, 1, 6, 3,
4, 4, 6, 5, 3, 1, 1, 5, 7, 7, 8, 0, 1, 9, 3, 5, 2, 4, 4, 4, 0,
8, 5, 3, 2, 1, 9, 6, 7, 9, 8, 2, 6, 4, 1, 7, 2, 0, 9, 1, 4, 6,
6, 5, 5, 6, 3, 5, 3, 3, 8, 3, 6, 3, 1, 0, 6, 2, 7, 1, 8, 4, 7,
3, 3, 1, 3, 1, 3, 7, 4, 0, 9, 7, 9, 4, 6, 0, 2, 1, 9, 2, 8, 8,
0, 1, 6, 4, 4, 4, 0, 4, 4, 3, 3, 4, 9, 3, 0, 3, 5, 6, 3, 2, 4,
7, 5, 1, 3, 7, 4, 4, 4, 8, 5, 7, 9, 8, 7, 1, 3, 1, 0, 7, 8, 4,
6, 9, 5, 2, 8, 5, 2, 7, 3, 8, 4, 4, 6, 3, 5, 9, 2, 8, 9, 8, 7,
1, 6, 5, 1, 4, 4, 1, 5, 8, 7, 5, 9, 0, 7, 4, 6, 5, 3, 6, 1, 2,
9, 6, 2, 1, 1, 8, 4, 1, 2, 6, 6, 0, 0, 4, 9, 0, 8, 9, 5, 7, 7,
2, 3, 8, 4, 2, 7, 8, 7, 5, 3, 4, 4, 6, 9, 5, 0, 4, 8, 7, 1, 6,
3, 1, 9, 7, 4, 9, 0, 4, 0, 3, 5, 8, 0, 8, 6, 7, 8, 1, 0, 2, 0,
8, 3, 0, 1, 1, 7, 6, 6, 2, 2, 8, 1, 7, 8, 2, 5, 2, 5, 8, 4, 0,
0, 2, 4, 2, 8, 3, 4, 2, 5, 6, 4, 4, 8, 8, 7, 2, 3, 8, 0, 0, 6,
4, 2, 1, 6, 7, 1, 5, 3, 7, 1, 2, 3, 4, 5, 1, 8, 1, 5, 1, 3, 1,
8, 5, 1, 0, 1, 1, 8, 4, 6, 2, 6, 8, 0, 2, 7, 4, 3, 0, 8, 5, 0,
1, 2, 8, 1, 2, 9, 0, 4, 8, 5, 5, 8, 1, 5, 8, 9, 5, 2, 9, 8, 2,
2, 0, 2, 6, 1, 9, 0, 5, 8, 4, 6, 9, 1, 6, 8, 0, 7, 0, 3, 5, 5,
9, 5, 9, 9, 6, 1, 9, 2, 8, 2, 7, 6, 8, 0, 8, 7, 1, 4, 2, 2, 7,
6, 1, 7, 0, 9, 7, 6, 4, 4, 3, 3, 5, 7, 7, 8, 9, 6, 9, 6, 3, 7,
6, 3, 2, 5, 2, 5, 8, 2, 7, 1, 0, 7, 7, 5, 6, 8, 9, 2, 3, 4, 9,
6, 1, 3, 9, 1, 9, 0, 5, 6, 7, 0, 7, 6, 0, 5, 3, 7, 4, 5, 0, 2,
1, 1, 8, 2, 4, 8, 4, 5, 4, 8, 2, 2, 6, 1, 7, 0, 9, 3, 1, 5, 4,
0, 4, 2, 9, 4, 5, 4, 7, 7, 0, 2, 1, 7, 5, 3, 5, 6, 0, 7, 3, 6,
5, 9, 5, 4, 4, 1, 6, 5, 6, 1, 1, 4, 2, 1, 9, 7, 4, 6, 3, 6, 9,
1, 3, 4, 0, 1, 8, 1, 5, 0, 3, 4, 9, 3, 1, 7, 8, 2, 2, 2, 2, 5,
1, 4, 0, 2, 2, 2, 1, 2, 9, 9, 8, 2, 9, 6, 0, 4, 9, 5, 2, 1, 3,
7, 0, 2, 5, 8, 5, 0, 2, 7, 0, 2, 6, 2, 4, 7, 6, 1, 2, 3, 5, 7,
5, 6, 2, 1, 5, 0, 2, 1, 2, 3, 4, 7, 8, 3, 8, 0, 8, 2, 5, 5, 8,
0, 1, 3, 3, 7, 5, 9, 8, 8, 1, 5, 0, 5, 4, 1, 9, 2, 1, 0, 9, 1,
0, 6, 7, 8, 4, 9, 7, 9, 0, 0, 8, 2, 5, 1, 7, 0, 7, 5, 8, 5, 9,
6, 6, 6, 3, 1, 5, 0, 8, 3, 0, 3, 4, 8, 4, 3, 3, 9, 3, 0, 7, 8,
9, 3, 4, 5, 6, 0, 9, 7, 2, 1, 1, 8, 4, 6, 0, 3, 4, 7, 4, 6, 7,
9, 3, 0, 3, 9, 6, 9, 2, 2, 2, 5, 5, 9, 0, 0, 6, 2, 4, 1, 1, 7,
6, 3, 9, 5, 6, 6, 6, 8, 8, 1, 2, 0, 4, 3, 0, 9, 4, 5, 4, 9, 1,
7, 7, 2, 1, 1, 0, 0, 0, 9, 3, 3, 1, 9, 3, 3, 7, 3, 7, 1, 2, 2,
6, 0, 4, 8, 9, 0, 7, 8, 3, 8, 3, 4, 1, 2, 8, 1, 6, 0, 1, 2, 1,
9, 2, 8, 3, 2, 5, 8, 5, 9, 3, 2, 1, 6, 9, 7, 6, 5, 3, 0, 1, 4,
4, 2, 8, 4, 4, 2, 0, 9, 0, 7, 7, 7, 6, 4, 0, 6, 9, 2, 4, 7, 2,
3, 9, 9, 8, 3, 8, 3, 8, 1, 3, 6, 9, 8, 5, 8, 1, 4, 2, 0, 2, 9,
4, 2, 7, 6, 1, 9, 6, 3, 0, 4, 1, 8, 1, 3, 4, 5, 2, 0, 5, 5, 3,
8, 0, 9, 0, 1, 3, 4, 8, 1, 5, 0, 9, 6, 5, 0, 7, 2, 8, 2, 3, 2,
9, 9, 2, 4, 7, 0, 8, 6, 4, 0, 8, 6, 8, 3, 6, 6, 7, 5, 3, 0, 1,
3, 7, 1, 6, 3, 8, 4, 5, 4, 1, 2, 9, 0, 5, 7, 1, 7, 1, 2, 9, 3,
8, 1, 2, 7, 5, 3, 8, 7, 1, 7, 3, 0, 8, 2, 9, 6, 8, 6, 0, 9, 9,
5, 4, 3, 8, 1, 2, 2, 2, 2, 3, 9, 8, 5, 5, 5, 5, 2, 9, 8, 8, 1,
3, 0, 1, 1, 9, 3, 7, 7, 7, 2, 2, 3, 6, 3, 7 };
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
List<Integer> list = new ArrayList<Integer>();
for (int n : nums)
// key - value (数据 - 数据出现的次数)
map.put(n, map.get(n) == null ? 1 : map.get(n) + 1);
for (int n : map.keySet()) { // 将数据出现的次数存放到ArrayList数列中
list.add(map.get(n));
System.out.println(n + "出现的次数：" + map.get(n));
}
for (int n : map.keySet()) { // 获取出现频率最高的数据
if (map.get(n) == Collections.max(list))
System.out.println("出现频率最高的是：" + n);
}
}
}结果：

0出现的次数：96
1出现的次数：118
2出现的次数：112
3出现的次数：101
4出现的次数：100
5出现的次数：95
6出现的次数：90
7出现的次数：94
8出现的次数：102
9出现的次数：92
出现频率最高的是：1

时间复杂度N(n+m)

楼主的问题貌似是网上的老题了，3楼的回答应该是比较合适的方法，不过可以参考下面几楼童鞋的方法改进下
        int[] count = new int[1000];
       memset(count, 0, sizeof(int) * 1000);
        int nums []= { 2,4,3,6,9,2,1,9,3,7,4,1,0...};
       int MaxKey = -1;
       int MaxCount = 0;
       int TopIndex = nums.length;
        for(int i = 0 ; i < TopIndex;i++)
        {
            if(MaxCount < (count[nums[i]]++))
            {
                MaxCount = count[nums[i]];
                MaxKey = nums[i];
            }
        }
      只遍历一遍就可以了，不用遍历2次，时间复杂度忘了，貌似是O(N)

放入hashMap 足以然后顺搜足以啊o（n）+顺搜一次 o（n）事件复杂度上界 O(N) 啊

如果数组中的数字仅仅是0-9的话，可以如下实现
/*
     * 返回一个数组，第一个元素放数字最多的一个那个数
     * 第二个元素是出现的次数
     */
    public int[] getMaxTimes(int[] myArr){
        int[] retArr = new int[2];
        int[] myNum = new int[10];
        int maxTimes = 0;
        int maxNum = 0;

        for(int i = 0; i < myArr.length; ++i){
            ++myNum[myArr[i]];
        }

        //找到最大的数字和出现的次数
        for(int j = 0; j < 9; ++j){
            if(maxTimes < myNum[j]){
                maxTimes = myNum[j];
                maxNum = j;
            }
        }

        retArr[0] = maxNum;
        retArr[1] = maxTimes;

        return retArr;
    }

对整个数组遍历一遍，过程中统计出其中的每个数出现的次数，并记录出现最多的数以及次数，虽然时间复杂度较低，但开辟的空间比较大;   时间赋值度：O(num.length);代码如下：
    public static void main(String[] args)
    {
        int[] nums = {2, 4, 3, 6, 9, 2, 1, 9, 3, 7, 4, 1, 0, 1, 2, 2, 1, 5, 8, 8, 4, 1, 1, 7, 6, 1, 9, 6, 5, 5, 6, 9, 1, 8, 7, 9, 9, 1, 6, 3, 4, 4, 6, 5, 3, 1, 1, 5, 7, 7, 8, 0, 1, 9, 3, 5, 2, 4, 4, 4, 0, 8, 5, 3, 2, 1, 9, 6, 7, 9, 8, 2, 6, 4, 1, 7, 2, 0, 9, 1, 4, 6, 6, 5, 5, 6, 3, 5, 3, 3, 8, 3, 6, 3, 1, 0, 6, 2, 7, 1, 8, 4, 7, 3, 3, 1, 3, 1, 3, 7, 4, 0, 9, 7, 9, 4, 6, 0, 2, 1, 9, 2, 8, 8, 0, 1, 6, 4, 4, 4, 0, 4, 4, 3, 3, 4, 9, 3, 0, 3, 5, 6, 3, 2, 4, 7, 5, 1, 3, 7, 4, 4, 4, 8, 5, 7, 9, 8, 7, 1, 3, 1, 0, 7, 8, 4, 6, 9, 5, 2, 8, 5, 2, 7, 3, 8, 4, 4, 6, 3, 5, 9, 2, 8, 9, 8, 7, 1, 6, 5, 1, 4, 4, 1, 5, 8, 7, 5, 9, 0, 7, 4, 6, 5, 3, 6, 1, 2, 9, 6, 2, 1, 1, 8, 4, 1, 2, 6, 6, 0, 0, 4, 9, 0, 8, 9, 5, 7, 7, 2, 3, 8, 4, 2, 7, 8, 7, 5, 3, 4, 4, 6, 9, 5, 0, 4, 8, 7, 1, 6, 3, 1, 9, 7, 4, 9, 0, 4, 0, 3, 5, 8, 0, 8, 6, 7, 8, 1, 0, 2, 0, 8, 3, 0, 1, 1, 7, 6, 6, 2, 2, 8, 1, 7, 8, 2, 5, 2, 5, 8, 4, 0, 0, 2, 4, 2, 8, 3, 4, 2, 5, 6, 4, 4, 8, 8, 7, 2, 3, 8, 0, 0, 6, 4, 2, 1, 6, 7, 1, 5, 3, 7, 1, 2, 3, 4, 5, 1, 8, 1, 5, 1, 3, 1, 8, 5, 1, 0, 1, 1, 8, 4, 6, 2, 6, 8, 0, 2, 7, 4, 3, 0, 8, 5, 0, 1, 2, 8, 1, 2, 9, 0, 4, 8, 5, 5, 8, 1, 5, 8, 9, 5, 2, 9, 8, 2, 2, 0, 2, 6, 1, 9, 0, 5, 8, 4, 6, 9, 1, 6, 8, 0, 7, 0, 3, 5, 5, 9, 5, 9, 9, 6, 1, 9, 2, 8, 2, 7, 6, 8, 0, 8, 7, 1, 4, 2, 2, 7, 6, 1, 7, 0, 9, 7, 6, 4, 4, 3, 3, 5, 7, 7, 8, 9, 6, 9, 6, 3, 7, 6, 3, 2, 5, 2, 5, 8, 2, 7, 1, 0, 7, 7, 5, 6, 8, 9, 2, 3, 4, 9, 6, 1, 3, 9, 1, 9, 0, 5, 6, 7, 0, 7, 6, 0, 5, 3, 7, 4, 5, 0, 2, 1, 1, 8, 2, 4, 8, 4, 5, 4, 8, 2, 2, 6, 1, 7, 0, 9, 3, 1, 5, 4, 0, 4, 2, 9, 4, 5, 4, 7, 7, 0, 2, 1, 7, 5, 3, 5, 6, 0, 7, 3, 6, 5, 9, 5, 4, 4, 1, 6, 5, 6, 1, 1, 4, 2, 1, 9, 7, 4, 6, 3, 6, 9, 1, 3, 4, 0, 1, 8, 1, 5, 0, 3, 4, 9, 3, 1, 7, 8, 2, 2, 2, 2, 5, 1, 4, 0, 2, 2, 2, 1, 2, 9, 9, 8, 2, 9, 6, 0, 4, 9, 5, 2, 1, 3, 7, 0, 2, 5, 8, 5, 0, 2, 7, 0, 2, 6, 2, 4, 7, 6, 1, 2, 3, 5, 7, 5, 6, 2, 1, 5, 0, 2, 1, 2, 3, 4, 7, 8, 3, 8, 0, 8, 2, 5, 5, 8, 0, 1, 3, 3, 7, 5, 9, 8, 8, 1, 5, 0, 5, 4, 1, 9, 2, 1, 0, 9, 1, 0, 6, 7, 8, 4, 9, 7, 9, 0, 0, 8, 2, 5, 1, 7, 0, 7, 5, 8, 5, 9, 6, 6, 6, 3, 1, 5, 0, 8, 3, 0, 3, 4, 8, 4, 3, 3, 9, 3, 0, 7, 8, 9, 3, 4, 5, 6, 0, 9, 7, 2, 1, 1, 8, 4, 6, 0, 3, 4, 7, 4, 6, 7, 9, 3, 0, 3, 9, 6, 9, 2, 2, 2, 5, 5, 9, 0, 0, 6, 2, 4, 1, 1, 7, 6, 3, 9, 5, 6, 6, 6, 8, 8, 1, 2, 0, 4, 3, 0, 9, 4, 5, 4, 9, 1, 7, 7, 2, 1, 1, 0, 0, 0, 9, 3, 3, 1, 9, 3, 3, 7, 3, 7, 1, 2, 2, 6, 0, 4, 8, 9, 0, 7, 8, 3, 8, 3, 4, 1, 2, 8, 1, 6, 0, 1, 2, 1, 9, 2, 8, 3, 2, 5, 8, 5, 9, 3, 2, 1, 6, 9, 7, 6, 5, 3, 0, 1, 4, 4, 2, 8, 4, 4, 2, 0, 9, 0, 7, 7, 7, 6, 4, 0, 6, 9, 2, 4, 7, 2, 3, 9, 9, 8, 3, 8, 3, 8, 1, 3, 6, 9, 8, 5, 8, 1, 4, 2, 0, 2, 9, 4, 2, 7, 6, 1, 9, 6, 3, 0, 4, 1, 8, 1, 3, 4, 5, 2, 0, 5, 5, 3, 8, 0, 9, 0, 1, 3, 4, 8, 1, 5, 0, 9, 6, 5, 0, 7, 2, 8, 2, 3, 2, 9, 9, 2, 4, 7, 0, 8, 6, 4, 0, 8, 6, 8, 3, 6, 6, 7, 5, 3, 0, 1, 3, 7, 1, 6, 3, 8, 4, 5, 4, 1, 2, 9, 0, 5, 7, 1, 7, 1, 2, 9, 3, 8, 1, 2, 7, 5, 3, 8, 7, 1, 7, 3, 0, 8, 2, 9, 6, 8, 6, 0, 9, 9, 5, 4, 3, 8, 1, 2, 2, 2, 2, 3, 9, 8, 5, 5, 5, 5, 2, 9, 8, 8, 1, 3, 0, 1, 1, 9, 3, 7, 7, 7, 2, 2, 3, 6, 3, 7};
        int[] tellNum = new int[nums.length]; //统计num中的每个数字的个数
        int num = 0; //出现最多的数字
        int maxCount = 0; //记录最大的统计数。
        for (int i = 0; i < nums.length; i++)
        {
            int tod = nums[i];
            tellNum[tod] = tellNum[tod] + 1;
            if(maxCount<tellNum[tod])
            {
                maxCount = tellNum[tod];
                num = tod;
            }
        }
        System.out.println("出现最多的数字是："+num+"出现次数："+maxCount);
    }

改正一个错误。/*
     * 返回一个数组，第一个元素放数字最多的一个那个数
     * 第二个元素是出现的次数
     */
    public int[] getMaxTimes(int[] myArr){
        int[] retArr = new int[2];
        int[] myNum = new int[10];
        int maxTimes = 0;
        int maxNum = 0;

        for(int i = 0; i < myArr.length; ++i){
            ++myNum[myArr[i]];
        }

        //找到最大的数字和出现的次数
        for(int j = 0; j < 10; ++j){
            if(maxTimes < myNum[j]){
                maxTimes = myNum[j];
                maxNum = j;
            }
        }

        retArr[0] = maxNum;
        retArr[1] = maxTimes;

        return retArr;
    }

支持阿宝的方法。由于是无序数列，循环一次应该是必须的，所以O(n)应该是最小的时间复杂度了。其实阿宝的方法不用拘泥于10个数的上限，因为频率最高的数在首次循环中就已经找到了：
[code=Java]
public static void main(String[] args) {
int nums[] = { 2, 4, 3, 6, 9, 2, 1, 9, 3, 7, 4, 1, 0, 1, 2, 2, 1, 5, 8,
8, 4, 1, 1, 7, 6, 1, 9, 6, 5, 5, 6, 9, 1, 8, 7, 9, 9, 1, 6, 3,
4, 4, 6, 5, 3, 1, 1, 5, 7, 7, 8, 0, 1, 9, 3, 5, 2, 4, 4, 4, 0,
8, 5, 3, 2, 1, 9, 6, 7, 9, 8, 2, 6, 4, 1, 7, 2, 0, 9, 1, 4, 6,
6, 5, 5, 6, 3, 5, 3, 3, 8, 3, 6, 3, 1, 0, 6, 2, 7, 1, 8, 4, 7,
3, 3, 1, 3, 1, 3, 7, 4, 0, 9, 7, 9, 4, 6, 0, 2, 1, 9, 2, 8, 8,
0, 1, 6, 4, 4, 4, 0, 4, 4, 3, 3, 4, 9, 3, 0, 3, 5, 6, 3, 2, 4,
7, 5, 1, 3, 7, 4, 4, 4, 8, 5, 7, 9, 8, 7, 1, 3, 1, 0, 7, 8, 4,
6, 9, 5, 2, 8, 5, 2, 7, 3, 8, 4, 4, 6, 3, 5, 9, 2, 8, 9, 8, 7,
1, 6, 5, 1, 4, 4, 1, 5, 8, 7, 5, 9, 0, 7, 4, 6, 5, 3, 6, 1, 2,
9, 6, 2, 1, 1, 8, 4, 1, 2, 6, 6, 0, 0, 4, 9, 0, 8, 9, 5, 7, 7,
2, 3, 8, 4, 2, 7, 8, 7, 5, 3, 4, 4, 6, 9, 5, 0, 4, 8, 7, 1, 6,
3, 1, 9, 7, 4, 9, 0, 4, 0, 3, 5, 8, 0, 8, 6, 7, 8, 1, 0, 2, 0,
8, 3, 0, 1, 1, 7, 6, 6, 2, 2, 8, 1, 7, 8, 2, 5, 2, 5, 8, 4, 0,
0, 2, 4, 2, 8, 3, 4, 2, 5, 6, 4, 4, 8, 8, 7, 2, 3, 8, 0, 0, 6,
4, 2, 1, 6, 7, 1, 5, 3, 7, 1, 2, 3, 4, 5, 1, 8, 1, 5, 1, 3, 1,
8, 5, 1, 0, 1, 1, 8, 4, 6, 2, 6, 8, 0, 2, 7, 4, 3, 0, 8, 5, 0,
1, 2, 8, 1, 2, 9, 0, 4, 8, 5, 5, 8, 1, 5, 8, 9, 5, 2, 9, 8, 2,
2, 0, 2, 6, 1, 9, 0, 5, 8, 4, 6, 9, 1, 6, 8, 0, 7, 0, 3, 5, 5,
9, 5, 9, 9, 6, 1, 9, 2, 8, 2, 7, 6, 8, 0, 8, 7, 1, 4, 2, 2, 7,
6, 1, 7, 0, 9, 7, 6, 4, 4, 3, 3, 5, 7, 7, 8, 9, 6, 9, 6, 3, 7,
6, 3, 2, 5, 2, 5, 8, 2, 7, 1, 0, 7, 7, 5, 6, 8, 9, 2, 3, 4, 9,
6, 1, 3, 9, 1, 9, 0, 5, 6, 7, 0, 7, 6, 0, 5, 3, 7, 4, 5, 0, 2,
1, 1, 8, 2, 4, 8, 4, 5, 4, 8, 2, 2, 6, 1, 7, 0, 9, 3, 1, 5, 4,
0, 4, 2, 9, 4, 5, 4, 7, 7, 0, 2, 1, 7, 5, 3, 5, 6, 0, 7, 3, 6,
5, 9, 5, 4, 4, 1, 6, 5, 6, 1, 1, 4, 2, 1, 9, 7, 4, 6, 3, 6, 9,
1, 3, 4, 0, 1, 8, 1, 5, 0, 3, 4, 9, 3, 1, 7, 8, 2, 2, 2, 2, 5,
1, 4, 0, 2, 2, 2, 1, 2, 9, 9, 8, 2, 9, 6, 0, 4, 9, 5, 2, 1, 3,
7, 0, 2, 5, 8, 5, 0, 2, 7, 0, 2, 6, 2, 4, 7, 6, 1, 2, 3, 5, 7,
5, 6, 2, 1, 5, 0, 2, 1, 2, 3, 4, 7, 8, 3, 8, 0, 8, 2, 5, 5, 8,
0, 1, 3, 3, 7, 5, 9, 8, 8, 1, 5, 0, 5, 4, 1, 9, 2, 1, 0, 9, 1,
0, 6, 7, 8, 4, 9, 7, 9, 0, 0, 8, 2, 5, 1, 7, 0, 7, 5, 8, 5, 9,
6, 6, 6, 3, 1, 5, 0, 8, 3, 0, 3, 4, 8, 4, 3, 3, 9, 3, 0, 7, 8,
9, 3, 4, 5, 6, 0, 9, 7, 2, 1, 1, 8, 4, 6, 0, 3, 4, 7, 4, 6, 7,
9, 3, 0, 3, 9, 6, 9, 2, 2, 2, 5, 5, 9, 0, 0, 6, 2, 4, 1, 1, 7,
6, 3, 9, 5, 6, 6, 6, 8, 8, 1, 2, 0, 4, 3, 0, 9, 4, 5, 4, 9, 1,
7, 7, 2, 1, 1, 0, 0, 0, 9, 3, 3, 1, 9, 3, 3, 7, 3, 7, 1, 2, 2,
6, 0, 4, 8, 9, 0, 7, 8, 3, 8, 3, 4, 1, 2, 8, 1, 6, 0, 1, 2, 1,
9, 2, 8, 3, 2, 5, 8, 5, 9, 3, 2, 1, 6, 9, 7, 6, 5, 3, 0, 1, 4,
4, 2, 8, 4, 4, 2, 0, 9, 0, 7, 7, 7, 6, 4, 0, 6, 9, 2, 4, 7, 2,
3, 9, 9, 8, 3, 8, 3, 8, 1, 3, 6, 9, 8, 5, 8, 1, 4, 2, 0, 2, 9,
4, 2, 7, 6, 1, 9, 6, 3, 0, 4, 1, 8, 1, 3, 4, 5, 2, 0, 5, 5, 3,
8, 0, 9, 0, 1, 3, 4, 8, 1, 5, 0, 9, 6, 5, 0, 7, 2, 8, 2, 3, 2,
9, 9, 2, 4, 7, 0, 8, 6, 4, 0, 8, 6, 8, 3, 6, 6, 7, 5, 3, 0, 1,
3, 7, 1, 6, 3, 8, 4, 5, 4, 1, 2, 9, 0, 5, 7, 1, 7, 1, 2, 9, 3,
8, 1, 2, 7, 5, 3, 8, 7, 1, 7, 3, 0, 8, 2, 9, 6, 8, 6, 0, 9, 9,
5, 4, 3, 8, 1, 2, 2, 2, 2, 3, 9, 8, 5, 5, 5, 5, 2, 9, 8, 8, 1,
3, 0, 1, 1, 9, 3, 7, 7, 7, 2, 2, 3, 6, 3, 7 };
int count[] = new int[10000];
int max = 0;
Stack<Integer> maxIndexes = new Stack<Integer>(); for (int n : nums) {
if (++count[n] >= max) {
if (count[n] > max) {
maxIndexes.clear();
max = count[n];
}
maxIndexes.push(n);
}
}// for (int i = 0; i < 10; i++)
// System.out.printf("%d出现的次数：%d\n", i, count[i]); System.out.println("出现次数最多的数：");
while (!(maxIndexes.empty())) {
int n = maxIndexes.pop();
System.out.printf("%d 出现的次数： %d\n", n, count[n]);
}
}
[code]

算法懒的写了。
思路是先排序，再遍历一遍。
排序的时间复杂度最快为nlogn
则这个算法的时间复杂度为O(nlogn+n)

原来上面有很多兄弟都是这样想的。
另：用map的时间复杂度绝对不只O(N+M)
当然如果用空间换时间的办法，定义出最小数至最大数长度的数组，分别表示最每个数的次数是可以的这样的复杂度差不多有O(2N+M)

阿宝的就是最经典的计数器算法，如果不知道数据范围的话：    int[] nums = {}; // 鄙视一下lz的int nums[]写法
    int max = nums[0];
    int min = nums[0];
    for (int i : nums) { // O(N)
      if (i > max) {
        max = i;
      } else if (i < min) {
        min = i;
      }
    }
    System.out.printf("max: %d, min: %d%n", max, min);
    int[] count = new int[max - min + 1];
    int maxCnt = count[0];
    int maxNum = nums[0];
    for (int i : nums) { // O(N)
      count[i - min]++;
      if (count[i - min] > maxCnt) {
        maxCnt = count[i];
        maxNum = i;
      }
    }    System.out.printf("Number %d has most occurrences: %d%n", maxNum, maxCnt);时间复杂度O(N)（两个O(N)），但是空间复杂度上会和夸张，比如存放了Integer.MAX_VALUE和MIN_VALUE的话，可能就运行不起来了。其实还是HashMap<Integer, Integer>比较通用，时间复杂度也是O(N)（如果初始大小设置合理的话）

int nums []=  { 2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,1,6,4,4,4,0,4,4,8,3,6,3,1,0,6,2,7,1,8,4,7, 3,3,1,3,1,3,7,4,0,9, 2,1,9, 2,8,8,0,3,3,4,9,         3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8, ,7,7,2,3,,1,1,7,6,                9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,             8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0       6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,              4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,              2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,               1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,               0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,              1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,               2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,               5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,               9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,               1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,                9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,               1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,               3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,              5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,               7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8, 8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
        //存放每个数字出现的次数
        int[] count = new int[nums.length];
        //遍历数组，将次数存入count
        for(int i=0;i<nums.length;i++){
            if(nums[i]==0){
                count[0]++;
            }else if(nums[i]==1){
                count[1]++;
            }else if(nums[i]==2){
                count[2]++;
            }else if(nums[i]==3){
                count[3]++;
            }else if(nums[i]==4){
                count[4]++;
            }else if(nums[i]==5){
                count[5]++;
            }else if(nums[i]==6){
                count[6]++;
            }else if(nums[i]==7){
                count[7]++;
            }else if(nums[i]==8){
                count[8]++;
            }else if(nums[i]==9){
                count[9]++;
            }
        }
        //出现最大次数
        int maxNum = 0;
        //存放最大数及其出现次数
        String result ="";
        //数组下标即对应数字，内容是对应数字出现次数
        for(int i =0;i<count.length;i++){
            if(count[i]>maxNum){
                maxNum = count[i];
                result = maxNum+"-"+i;
            }
        }
        System.out.println("最大的数为"+result.split("-")[1]+",出现次数是"+result.split("-")[0]);

如果只有0－9之间的数的话，14楼的答案是很好的，14楼的答案如下。int[] cnt = {0,0,0,0,0,0,0,0,0,0}; //分别记录数字0,1,2,3,4,5,6,7,8,9的次数
int[] max = {0,0}; //记录出现最多的数字以及出现次数，max[0]次数，max[1]数字
for (int n : num) { //遍历数组
    cnt[n]++; //该数字对应的计数器累加
    if (cnt[n] > max[0]) { //比较计数器和当前最大次数
        max[0] = cnt[n];
        max[1] = n;
    }
}
System.out.printf("最大数字：%d，出现次数：%d\n", max[1], max[0]);
时间复杂度O(N)，只需要遍历数组一遍即可
如果不确定数的大小，可以参考这个算法或haspmap的算法。或另做考虑。接个分吧。

public class MaxArray { private int a []={1,2,1,1,2};
public static void main(String[] args)
{
MaxArray ob = new MaxArray();
ob.maxArray();
}
public void maxArray()
{
int b = 0 ;
int tem = 0;
int result = 0;
for(int i = 0;i<a.length;i++)
{
int count = 1;
for(int j = i+1;j<a.length;j++)
{
if((a[i]-a[j])==0)
{
count++;
}
}
if(tem<count)
{
tem = count;
b = a[i];
}
}
System.out.print("出现频率最多的数是："+b+"，一共出现了"+tem+"次");
}
}
这算法有点浪费资源，呵呵。复杂度还没学。呵呵。

HashMap 查找一个 key 的复杂度是 O(1)

找到数组索引后Entry链上的遍历查找为何只有O(1)

因为 HashMap 查找 key 所消耗的时间与总数量的比率基本上恒定在一个值上，或者有少许的变化。HashMap 查找效率最好的情况下是 O(1)，最坏的情况下是 O(N)

public static void main(String[] args) {
int i,j,h,max=0,num=0;
int nums []= {2,4,3,6,9,2,1,9,3,7,4,1,0,1,2,2,1,5,8,8,4,1,1,7,6,1,9,6,5,5,6,9,1,8,7,9,9,1,6,3,4,4,6,5,3,1,1,5,7,7,8,0,1,9,3,5,2,4,4,4,0,8,5,3,2,1,9,6,7,9,8,2,6,4,1,7,2,0,9,1,4,6,6,5,5,6,3,5,3,3,8,3,6,3,1,0,6,2,7,1,8,4,7,3,3,1,3,1,3,7,4,0,9,7,9,4,6,0,2,1,9,2,8,8,0,1,6,4,4,4,0,4,4,3,3,4,9,3,0,3,5,6,3,2,4,7,5,1,3,7,4,4,4,8,5,7,9,8,7,1,3,1,0,7,8,4,6,9,5,2,8,5,2,7,3,8,4,4,6,3,5,9,2,8,9,8,7,1,6,5,1,4,4,1,5,8,7,5,9,0,7,4,6,5,3,6,1,2,9,6,2,1,1,8,4,1,2,6,6,0,0,4,9,0,8,9,5,7,7,2,3,8,4,2,7,8,7,5,3,4,4,6,9,5,0,4,8,7,1,6,3,1,9,7,4,9,0,4,0,3,5,8,0,8,6,7,8,1,0,2,0,8,3,0,1,1,7,6,6,2,2,8,1,7,8,2,5,2,5,8,4,0,0,2,4,2,8,3,4,2,5,6,4,4,8,8,7,2,3,8,0,0,6,4,2,1,6,7,1,5,3,7,1,2,3,4,5,1,8,1,5,1,3,1,8,5,1,0,1,1,8,4,6,2,6,8,0,2,7,4,3,0,8,5,0,1,2,8,1,2,9,0,4,8,5,5,8,1,5,8,9,5,2,9,8,2,2,0,2,6,1,9,0,5,8,4,6,9,1,6,8,0,7,0,3,5,5,9,5,9,9,6,1,9,2,8,2,7,6,8,0,8,7,1,4,2,2,7,6,1,7,0,9,7,6,4,4,3,3,5,7,7,8,9,6,9,6,3,7,6,3,2,5,2,5,8,2,7,1,0,7,7,5,6,8,9,2,3,4,9,6,1,3,9,1,9,0,5,6,7,0,7,6,0,5,3,7,4,5,0,2,1,1,8,2,4,8,4,5,4,8,2,2,6,1,7,0,9,3,1,5,4,0,4,2,9,4,5,4,7,7,0,2,1,7,5,3,5,6,0,7,3,6,5,9,5,4,4,1,6,5,6,1,1,4,2,1,9,7,4,6,3,6,9,1,3,4,0,1,8,1,5,0,3,4,9,3,1,7,8,2,2,2,2,5,1,4,0,2,2,2,1,2,9,9,8,2,9,6,0,4,9,5,2,1,3,7,0,2,5,8,5,0,2,7,0,2,6,2,4,7,6,1,2,3,5,7,5,6,2,1,5,0,2,1,2,3,4,7,8,3,8,0,8,2,5,5,8,0,1,3,3,7,5,9,8,8,1,5,0,5,4,1,9,2,1,0,9,1,0,6,7,8,4,9,7,9,0,0,8,2,5,1,7,0,7,5,8,5,9,6,6,6,3,1,5,0,8,3,0,3,4,8,4,3,3,9,3,0,7,8,9,3,4,5,6,0,9,7,2,1,1,8,4,6,0,3,4,7,4,6,7,9,3,0,3,9,6,9,2,2,2,5,5,9,0,0,6,2,4,1,1,7,6,3,9,5,6,6,6,8,8,1,2,0,4,3,0,9,4,5,4,9,1,7,7,2,1,1,0,0,0,9,3,3,1,9,3,3,7,3,7,1,2,2,6,0,4,8,9,0,7,8,3,8,3,4,1,2,8,1,6,0,1,2,1,9,2,8,3,2,5,8,5,9,3,2,1,6,9,7,6,5,3,0,1,4,4,2,8,4,4,2,0,9,0,7,7,7,6,4,0,6,9,2,4,7,2,3,9,9,8,3,8,3,8,1,3,6,9,8,5,8,1,4,2,0,2,9,4,2,7,6,1,9,6,3,0,4,1,8,1,3,4,5,2,0,5,5,3,8,0,9,0,1,3,4,8,1,5,0,9,6,5,0,7,2,8,2,3,2,9,9,2,4,7,0,8,6,4,0,8,6,8,3,6,6,7,5,3,0,1,3,7,1,6,3,8,4,5,4,1,2,9,0,5,7,1,7,1,2,9,3,8,1,2,7,5,3,8,7,1,7,3,0,8,2,9,6,8,6,0,9,9,5,4,3,8,1,2,2,2,2,3,9,8,5,5,5,5,2,9,8,8,1,3,0,1,1,9,3,7,7,7,2,2,3,6,3,7};
int []count={0,0,0,0,0,0,0,0,0,0};//初始化数组记录每个数出现的次数,比如count[0]的值就是0出现的次数
//遍历nums[],记录每个数出现的次数
for(i=0;i<nums.length;i++)
{
h=nums[i];
count[h]=count[h]+1;

}
//获取count[]中最大的值，就是出现的次数，下标就是原来的数值
for(j=0;j<count.length;j++)
{
if(num<count[j])
{
num=count[j];
max=j;
}
}
System.out.println("最大数"+max);
System.out.println("出现次数"+num);
}

就是写一个程序判断一个数组中出现次数最多的那个元素。
方法一：import java.util.*;
public class Test1{
public static void main(String args[]){
     String[] s = {"a","b","a","a","b","c"};
     HashMap< String, Integer> hm = new HashMap< String, Integer>();

     for (int i = 0; i < s.length; i++) {
        if (!hm.containsKey(s[i])) {
                hm.put(s[i], 1);
        } else  {
                hm.put(s[i], hm.get(s[i]).intValue()+1);
            }
        }

        System.out.println(hm);
  }
}
运行结果：{a=3, c=1, b=2}方法二：import java.util.*;
public class FindMostEle {
    private static LinkedHashMap<String, Integer> map;

    public static LinkedHashMap<String, Integer> mostEle(String[] strArray){
        map = new LinkedHashMap<String, Integer>();

        String str = "";
        int count = 0;
        int result = 0;

        for(int i=0; i<strArray.length; i++)
            str += strArray[i];

        for(int i=0; i<strArray.length; i++){
            String temp = str.replaceAll(strArray[i], "");
            count = (str.length() - temp.length())/strArray[i].length();

            if (count > result){
                map.clear();
                map.put(strArray[i], count);
                result = count;
            }
            else if(null == map.get(strArray[i]) && count == result)
                map.put(strArray[i], count);
        }
        return map;
    }

    public static void main(String args[]){
        String[] strArray = {"11", "11", "2", "2", "4", "5", "4"};

        LinkedHashMap<String, Integer> result = mostEle(strArray);

        ArrayList<Integer> c = new ArrayList<Integer>(result.values());
        Set<String> s = result.keySet();

        System.out.print("一共有"+ result.size() +"元素最多。它们分别是");
        System.out.print(s);
        System.out.println("，分别出现了"+ c.get(0) +"次。");

    }
}
结果是：一共有3元素最多。它们分别是[11, 2, 4]，分别出现了2次。
方法三：
import java.util.*;
public class test {
    public static void main(String[] args) {
        int[] array = {1,2,2,3,4,4,5,6,7,7,8,9};
        int iMaxCount=0;
        //因为可能有多个元素的出现次数同时位居第一，
        //所以结果应该是一个集合。用一个List来装载。
        List< Integer> list=new ArrayList< Integer>();
        for (int i=0;i< array.length;i++){
            int iCount=0;
            for (int j=0;j< array.length;j++){
                   if (array[i]==array[j])
                       iCount++;
            }
            if (iCount>iMaxCount){
                list.clear();
                list.add(array[i]);
                iMaxCount=iCount;
            }else if (iCount==iMaxCount){
                if (list.indexOf(array[i])==-1)
                    list.add(array[i]);
            }
        }
        System.out.println("出现次数最多的元素为"+list.toString());
    }
}
运行结果：
出现次数最多的元素为[2, 4, 7]

map 最简洁，但时间复杂度并非最低，而且实用map相对的占用的空间复杂度也偏高，但简单易懂，使用有上限的数组时间复杂度最低，但是空间复杂度就相对高些，而排序再计算的方式，时间复杂度和空间复杂度都蛮高的

调试易

300分！给一个数组求里面出现次数最多的元素和其次数另：需要加上时间复杂度，否则只给5分。最优算法给100分

解决方案 »

300分！给一个数组 求里面出现次数最多的元素和其次数 另：需要加上时间复杂度，否则只给5分。最优算法给100分

解决方案 »

300分！给一个数组求里面出现次数最多的元素和其次数另：需要加上时间复杂度，否则只给5分。最优算法给100分