java 数组取值_数组和集合

珍惜当下

---

数据集处理是每种语言必备的功能，Java更甚之，数据集可以允许重复，也可以不允许重复，可以允许 null 存在，也可以不允许 null 存在，可以自动排序，也可以不自动排序，可以是阻塞式的，也可以是非阻塞式的......前面我们分别详细介绍了Java常用两大数据集：集合和数组，这篇文章我们将对比介绍两者在开发中的使用场景及相关性能问题。还是比较实用的，总结一下分析给小伙伴们~~数组和集合如何选？

数组在实际的系统开发中用得越来越少了，我们通常只有在阅读一些开源项目时才会看到它们的身影，在 Java 中它确实没有List、Set、Map这些集合类用起来方便，但是在基本类型处理方面数组还是占优势的，而且集合类的底层也都是通过数组实现的，比如对一个数据集求和，数组实现如下：

/**   * 数组求和   * @param nums   * @return   */public static long getArraySum(int[] nums){    long sum = 0;    for (int i = 0; i < nums.length; i++) {        sum += i;    }    return sum;}public static void main(String[] args) {    int[] nums = new int[10000000];    for (int i = 0; i < nums.length; i++) {        nums[i] = i;    }    //数组求和    long star = System.currentTimeMillis();    long sum = getArraySum(nums);    System.out.println("数组和为："+sum);    long end = System.currentTimeMillis();    System.out.println("数组求和耗时："+(end-star)+"ms"); }运行结果如下：数组和结果为：49999995000000数组求和耗时：10ms

对一个 int 类型的数组求和，取出所有的数组元素然后相加，此时如果是基本类型则使用数组效率是最高的，使用集合则效率次之。再看使用List求和如下：

 /**   * 集合求和   * @param nums   * @return   */  public static long getListSum(List nums){      long sum = 0;      for (int i = 0; i < nums.size(); i++) {          sum += nums.get(i);      }      return sum;  }public static void main(String[] args) {     //集合求和  Integer[] nums = new Integer[10000000];  for (int i = 0; i < nums.length; i++) {      nums[i] = i;  }  List numList = Arrays.asList(nums);  long starTime = System.currentTimeMillis();  long sum = getListSum(numList);  System.out.println("集合求和结果："+sum);  long endTime = System.currentTimeMillis();  System.out.println("集合求和耗时："+(endTime - starTime)+"ms");}运行结果：集合求和结果：49999995000000集合求和耗时：21ms

我们可以看到对于一个1000W数据求和运算，使用集合求和耗时大约是数组求和耗时的2倍。对于集合求和：

sum += nums.get(i)

这里其实已经做了一个拆箱动作，Integer对象通过intValue()方法自动拆箱转换成了一个int基本类型，对于性能濒于临界的系统来说该方案是比较危险的，特别是大数量的时候，首先，在初始化 List 数组时要进行装箱动作，把一个 int 类型包装成一个 Integer 对象，虽然有整型池(面试踩过的坑：Java Integer 缓存)，但不在整型池范围内的都会产生一个新的 Integer 对象，而且众所周知，基本类型是在栈内存中操作的，而对象则是在堆内存中操作的，栈内存的特点是速度快，容量小，堆内存的特点是速度慢，容量大，从性能上来讲，基本类型的处理占优势。其次，在进行求和计算(或者其他遍历计算)时要做拆箱动作，因此无谓的性能消耗也就产生了。

int 和 long 型数据存储范围如下：

 @Test    public void test(){        System.out.println(String.format("int型数据范围：%d ~ %d",Integer.MIN_VALUE,Integer.MAX_VALUE));        System.out.println(String.format("long型数据范围：%d ~ %d",Long.MIN_VALUE,Long.MAX_VALUE));    }运行结果：int型数据范围：-2147483648 ~ 2147483647long型数据范围：-9223372036854775808 ~ 9223372036854775807

有一个问题：数组一旦经过初始化长度不可变，这样不便使用，在实际开发中若有必要，可以使用变长数组。比如要对班级学生的信息进行统计，因为我们不知道一个班级会有多少学生(随时都可能会有学生入学、退学或转学)，所以需要有一个足够大的数组来容纳所有的学生，但问题是多大才算足够大？这个足够大是相对于当时的场景而言的。随着环境的变化，“足够大”也可能会转变成“足够小”，然后就会出现超出数组最大容量的情况，那该如何解决呢？我们可以通过对数组扩容“婉转”地解决该问题，代码如下：

 /**     * 数组扩容     * @param data     * @param newLengh     * @param      * @return     */    public static T[]  expandCapacity(T[] data,int newLen){        newLen = newLen         return Arrays.copyOf(data,newLen);    }

上述代码中采用的是Arrays数组工具类的copyof方法，产生了一个newLen 长度的新数组，并把原有的值拷贝了进去，之后就可以对超长的元素进行赋值了(依据类型的不同分别斌值为 0、 false 或 null ) 。其实，集合的长度自动维护功能的原理与此类似。在实际开发中，如果确实需要变长的数据集，数组也是在考虑范围之内的，不能因固定长度而将其否定之。多种最值算法，适时选择

对一批数据进行排序，然后找出其中的最大值或最小值，这是基本的数据结构知识。在 Java 中我们可以通过编写算法的方式，也可以通过数组先排序再取值的方式来实现。下面以求最大值为例：

1)自行实现：

快速查找最大值先来看用快速查找法取最大值的算法，其代码如下：

 /**   * 获取数组最大值   * @param data   * @return   */  public static int getMax(int[] data){      int max = data[0];      for (int i = 0; i < data.length; i++) {          max = max > data[i] ? max : data[0];      }      return max;  }

这是我们经常使用的最大值算法，也是速度最快的算法。它不要求排序，只要遍历一遍数组即可找出最大值。

2、先排序，后取值：

对于求最大值，也可以采用先排序后取值的方式，同样比较简单，代码如下：

  /**   * 获取数组最大值   *   * @param data   * @return   */  public static int getMax(int[] data) {      //先排序      Arrays.sort(data.clone());      //在取值      return data[data.length - 1];  }

从效率上来讲，当然是自己写快速查找法更快一些了，只用遍历一遍就可以计算出最大值。但在实际测试中我们发现，如果数组数量少于1万，两者基本上没有差别，在同一个毫秒级别里，此时就可以不用自己写算法了，直接使用数组先排序后取值的方式。如果数组元素超过1万，就需要依据实际情况来考虑：自己实现，可以提升性能：先排序后取值，简单，通俗易懂。排除性能上的差异，两者都可以选择，甚至后者更方便一些，也更容易想到。

现在问题来了，在代码中为什么要先使用clone拷贝再排序呢？那是因为数组也是一个对象，不拷贝就改变了原有数组元素的顺序，除非数组元素的顺序无关紧要。

接着往下思考，如果要查找仅次于最大值的元素(也就是老二)，该如何处理呢？要注意，数组的元素是可以重复的，最大值可能是多个，所以单单一个排序然后取倒数第二个元素是解决不了问题的。此时，就需要一个特殊的排序算法了，先要剔除重复数据，然后再排序。当然，自己写算法也可以实现，但是集合类已经提供了非常好的方法，要是再使用数组自己写算法就显得有点过时了。数组不能剔除重复数据，但 Set 集合却是可以的，而且 Set 的子类 Treeset 还能自动排序。代码如下：

  /**   * 获取比最大值小一个的最大值   * @param data   * @return   */  public static int getSecond(Integer[] data){      List list = Arrays.asList(data);      TreeSet treeList = new TreeSet<>(list);      //取得比最大值小一个的最大值      return treeList.lower(treeList.last());  }

剔除重复元素并升序排列，这都由 Treeset 类实现的，然后可再使用 lower 方法寻找小于最大值的值。大家看，上面的程序非常简单吧？那如果是我们自己编写代码会怎么样？那至少要遍历数组两遍才能计算出老二的值，代码的复杂度将大大提升。也许你会说，这个要求有点变态，怎么会有这样的需求？不，有这样的需求很正常，比如在学校按成绩排名时，如果一个年级有 1200 人，只要找出最高的三个分数 〔 可不一定就是 3 个人，也可能是多人)，是不是就是这种情况呢？因此在实际应用中求最值，包括最大值、最小值、第二大值、倒数第二小值等，使用集合是最简单的方式，当然若从性能方面来考虑，数组是最好的选择。注意最值计算时使用集合最简单，使用数组性能最优。

不同列表选择不同的遍历方式

我们思考这样一个案例：统计一个省的各科高考成绩，比如数学平均分是多少，语文平均分是多少等，这是每年招生办都会公布的数据，我们来想想看该算法应如何实现。当然使用数据库中的一个 SQL 语句就能求出平均值，不过这不再我们的考虑之列，这里还是使用纯 Java 的算法来解决之，看代码：

  public static void main(String[] args) {        int stuNum = 100 * 10000;        //100万学生成绩        List stuList = new ArrayList<>(stuNum);        for (int i = 0; i < stuNum; i++) {            stuList.add(new Random().nextInt(150));        }        //求平均值        long startTime = System.currentTimeMillis();        System.out.println("平均成绩是："+average(stuList)+"分");        long endTime = System.currentTimeMillis();        System.out.println("所花时间是："+(endTime-startTime)+"ms");    }    /**     * 求平均成绩     * @return     */    public static int average(List scores){        int sum = 0;        for (int score:scores) {            sum += score;        }        return sum/scores.size();    }运行结果：平均成绩是：74分所花时间是：38ms

把 100 万名学生的成绩放到一个 ArrayList 数组中，然后通过 foreach 方式遍历求和，再计算平均值，程序非常简单，输出的结果是：平均分是：74，执行,间是：38ms 仅仅求一个算术平均值就花费了38毫秒，不要说考虑其他诸如加权平均值、补充平均值等算法，那花的时间肯定更长．我们仔细分析一下 arverage 方法，加号操作是最基本操作，没有什么可以优化的，剩下的就是一个遍历了，问题是 List 的遍历可以优化吗？我们可以尝试一下，List 的遍历还有另外一种方式，即通过下标方式来访问，代码如下：

 public static void main(String[] args) {        int stuNum = 100 * 10000;        //100万学生成绩        List stuList = new ArrayList<>(stuNum);        for (int i = 0; i < stuNum; i++) {            stuList.add(new Random().nextInt(150));        }        //求平均值        long startTime = System.currentTimeMillis();        System.out.println("平均成绩是："+average(stuList)+"分");        long endTime = System.currentTimeMillis();        System.out.println("所花时间是："+(endTime-startTime)+"ms");    }     /**     * 求平均成绩     * @return     */    public static int average(List scores){        int sum = 0;        for (int i = 0; i < scores.size(); i++) {            sum += scores.get(i);        }        return sum/scores.size();    }运行结果：平均成绩是：74分所花时间是：13ms

执行时间已经大幅度下降，性能提升了65% ，这是一个飞速提升！那为什么我们使用下标方式遍历数组会有这么高的性能提升呢？这是因为 ArrayList 数组实现了 RandolllAccess 接口(随机存取接口)，这也就标志着 ArrayList 是一个可以随机存取的列表。在 Java 中， RandomAccess 和 Cloneable、 Serializable 一样，都是标志性接口，不需要任何实现，只是用来表明其实现类具有某种特质的，实现了Cloneable 表明可以被拷贝，实现Serializable 接口表明被序列化 ，实现了 RandomAccess 则表明这个类可以随机存取，对我们的ArrayList来说也就标志着其数据元素之间没有关联，即两个位置相邻的元素之间没有相互依赖和索引关系，可以随机访问和存储。我们知道,Java 中的 foreach 语法是 iterator (迭代器)的变形用法，也就是说上面的 foreach 与下面的代码等价：

for (Iterator iterator = scores.iterator(); iterator.hasNext();){   sum += iterator.next();

那我们再想想什么是迭代器，迭代器是23个设计模式中的一种，“提供一种方法访问一个容器对象中的各个元素，同时又无须暴露该对象的内部细节”，也就是说对于ArrayList , 需要先创建一个迭代器容器，然后屏蔽内部遍历细节，对外提供 hasNext、next 等方法。问题是 ArrayList 实现了 RandomAccess 接口，已表明元素之间本来没有关系，可是，为了使用迭代器就需要强制建立一种互相“知晓”的关系，比如上一个元素可以判断是否有下一个元素，以及下一个元素是什么关系等，这也是通过foreach遍历耗时的原因。Java为ArrayList类加上RandomAccess 接口，就是在告诉我们，“嘿，ArrayList是随机存取的，采用下标方式遍历列表速度会更快”，接着又有一个问题了：为什么不把 RandomAccess 加到所有的 List 实现类上呢？那是因为有些List实现类不是随机存取的，而是有序存取的，比如 LinkedList 类， LinkedList 也是一个列表，但它实现了双向链表，每个数据结点中都有三个数据项：前节点的引用(PreviousNode)、本节点元素(Node Element )、后继节点的引用(Next Node)，这是数据结构的基本知识，不多讲了，也就是说在LinkedList 中的两个元素本来就是有关联的，我知道你的存在，你也知道我的存在。那大家想想看，元素之间已经有关联关系了，使用foreach 也就是迭代器方式是不是效率更高呢？我们修改一下例子，代码如下：

public static void main(String[] args) {      int stuNum = 100 * 10000;      //100万学生成绩      List stuList = new LinkedList();      for (int i = 0; i < stuNum; i++) {          stuList.add(new Random().nextInt(150));      }      //求平均值      long startTime = System.currentTimeMillis();      System.out.println("平均成绩是："+average(stuList)+"分");      long endTime = System.currentTimeMillis();      System.out.println("所花时间是："+(endTime-startTime)+"ms");  }    /**     * 求平均成绩     * @return     */    public static int average(List scores){        int sum = 0;        for (int score:scores) {            sum += score;        }        return sum/scores.size();    }平均成绩是：74分所花时间是：18ms

确实如此，效率也提高了，18ms,可能大家还想要测试一下下标方式(也就是采用 get 方法访问元素)遍历LinkedList 元素的情况，其实不用测试，效率真的非常低，前面我们也介绍过LinkedList的get方法源码，这里就不再赘述了，感兴趣小伙伴可以翻看。

明白了随机存取列表和有序存取列表的区别，我们优化average方法如下，实现不同的列表采用不同的遍历方法：

/** * 求平均成绩 * @return */public static int average(List scores){    int sum = 0;   if (scores instanceof RandomAccess){       for (int i = 0; i < scores.size(); i++) {           sum += scores.get(i);       }   }else {       for (int score :scores) {           sum += score;       }   }    return sum/scores.size();}

这样列表的遍历可以实现以不变应万变，随机存取列表(eg:ArrayList)采用下标遍历，有序列表(eg:LinkedList)采用foreach遍历。

今天总结了一些数组和列表的一些优化小技巧，感兴趣小伙伴欢迎留言一起交流哦。

另外对于冠状病毒，希望小伙伴们调整好心态，客观对待，不信谣不传谣，少出门，做好自我防护，爱己爱他人，平平安安度过难关。

---

欢迎关注ITSK，每天进步一点点，我们追求在交流中收获成长和快乐