1 package test;

  2 

  3 import java.util.Arrays;

  4 import java.util.HashMap;

  5 import java.util.Iterator;

  6 import java.util.Map;

  7 import java.util.Map.Entry;

  8 import java.util.Random;

  9 import java.util.Set;

 10 

 11 public class Test {

 12 

 13     private static int[] arr = new int[1000];

 14 

 15     public static void main（String[] args） {

 16         // 筹办数组

 17         createArray（）;

 18         // 办法一：用Map

 19         test01（arr）;

 20         test02（arr）;

 21     }

 22 

 23     /

 24       起首筹办一个长度为1000的数组作为测试对象

 25       经由过程random类来随机插入整数

 26      /

 27     public static void createArray（） {

 28         Random r = new Random（）;

 29         for （int i = 0; i < 1000; i++） {

 30             arr[i] = r.nextInt（100）;

 31         }

 32     }

 33 

 34     /

 35       第一个办法是依次读取数组中每个值，把读取到的值和它呈现的次数分别作为key和value放到一个Map中去，

 36       读取完成之后，再找到此Map中value值大那个key就可以了。

 37       ＠param arr

 38      /

 39     public static void test01（int[] arr） {

 40         Map<Integer， Integer> map = new HashMap<Integer， Integer>（）;

 41         for （int i = 0; i < arr.length; i++） {

 42             if （map.containsKey（arr[i]）） {

 43                 // 若是已存在雷同的key，则其value值加1

 44                 map.put（arr[i]， map.get（arr[i]） + 1）;

 45             } else {

 46                 // 若是还没有雷同的key，则value值为1并添加到map中

 47                 map.put（arr[i]， 1）;

 48             }

 49         }

 50         // 遍歷Map

 51         Set<Entry<Integer， Integer>> set = map.entrySet（）;

 52         Iterator<Entry<Integer， Integer>> it = set.iterator（）;

 53         int nums = 0;// 定义次数

 54         int key = 0;// 定义呈现次数最多的数

 55         while （it.hasNext（）） {

 56             Entry<Integer， Integer> entry = it.next（）;

 57             if （entry.getValue（） > nums） {

 58                 nums = entry.getValue（）;

 59                 key = entry.getKey（）;

 60             }

 61         }

 62         System.out.println（呈现次数最多的数是： + key + ; 呈现了 + nums + 次！）;

 63     }

 64     

 65     /

 66       此办法为先对数组进行排序，然后遍历数组求成果。

 67       不推荐此办法，为了推敲到数组的各类可能状况，写了一个小时，唉，估计还有bug。

 68       ＠param arr

 69      /

 70     public static void test02（int[] arr） {

 71         // 先对数组进行排序

 72         Arrays.sort（arr）;

 73         // 排完序之后，进行依次遍历

 74         int nums = 0;// 定义次数

 75         int key = 0;// 定义呈现次数最多的数

 76         // 遍历开端

 77         int i = 1;

 78         int tmpNums = 1;

 79         int tmpKey = arr[0];

 80         while （i < arr.length） {

 81             if （arr[i] == tmpKey） {

 82                 tmpNums++;

 83             } else {

 84                 if （tmpNums > nums） {

 85                     key = tmpKey;

 86                     nums = tmpNums;

 87                     tmpKey = arr[i];

 88                     tmpNums = 1;

 89                 } else {

 90                     if （i < arr.length - 1） {

 91                         tmpNums = 1;

 92                         tmpKey = arr[i+1];

 93                     }

 94                 }

 95             }

 96             i++;

 97         }

 98         // 若是最后几个数都一样且呈现的次数最多则进入此if语句

 99         if （tmpNums > nums） {

100             key = tmpKey;

101             nums = tmpNums;

102         }

103         // 若是数组中所稀有都一样，则进入此if语句

104         if （nums == 0） {

105             nums = tmpNums;

106             key = tmpKey;

107         }

108         System.out.println（呈现次数最多的数是： + key + ; 呈现了 + nums + 次！）;

109     }

110 }