java集合之trove4j高性能集合库

简介

Trove是一个java Collection集合工具类，编写程序时使用便捷、占内存少的特点，下面我们逐一介绍。

使用便捷

maven工程pom.xml文件引入所需要依赖额jar包，非maven请自行下载吧。

        
            net.sf.trove4j
            trove4j
            3.0.3
        

我们打开jar包看下源码包含的所有对象，下面我们会以list为例进行代码介绍

如果我们使用原始jdk方式创建int或byte等类型的集合，那么我们通常编码如下

 List intList = new ArrayList<>();
 List byteList = new ArrayList<>();
 其他类型不列举了

接下来使用Trove的方式看起来就比较简单了

TIntList intList  = new TIntArrayList();
TByteList byteList = new TByteArrayList();
其他类型看包里吧，不列举了

重点
trove把java原生集合的范型去掉了如List，而用具体的类型集合来取代如TIntList，导致类型比较多，但trove的具体类型优化后的效果要比java原生集合类要好些。

代码示例

package com.cjnserver.server1.trovecollection;

import gnu.trove.iterator.TIntIterator;
import gnu.trove.list.TByteList;
import gnu.trove.list.TIntList;
import gnu.trove.list.array.TByteArrayList;
import gnu.trove.list.array.TIntArrayList;

import java.util.*;

/**
 * @Description : torve集合框架
 * @Author : chenjiatai
 * @Date: 2020-01-15 11:29
 */
public class TroveCollection {
    public static void main(String[] args) {
        // trove方式的int类型list
        TIntList tList = new TIntArrayList();
        System.out.println("=====添加一些元素=====");
        tList.add(4);
        tList.add(3);
        tList.add(2);
        tList.add(1);
        print(tList);

        System.out.println("=====集合中最大值=====");
        System.out.println(tList.max());
        System.out.println("=====集合中最小值=====");
        System.out.println(tList.min());
        System.out.println("=====集合中元素求和=====");
        System.out.println(tList.sum());

        System.out.println("=====trove方式可以很方便的添加一个int数组，矮油不错哦~=====");
        int[] intArray = {8,7,6,5,4};
        tList.add(intArray);
        print(tList);

        // 判断集合是否为空
        boolean isEmpty = tList.isEmpty();
        // 是否包含指定元素
        boolean isContains = tList.contains(4);
        // 集合中元素的数量
        int size = tList.size();

        // for循环遍历集合（方式1）
        for (int i = 0; i < tList.size(); i++) {
            tList.get(i);
        }

        // 迭代器遍历集合（方式2）
        TIntIterator tIterator = tList.iterator();
        while (tIterator.hasNext()) {
            tIterator.next();
        }

        System.out.println("=====刪除指定索引位置的元素(索引为2)=====");
        tList.removeAt(2);
        print(tList);

        System.out.println("=====删除集合中出现的第一个相同元素(值为4)=====");
        tList.remove(4);
        print(tList);

        System.out.println("=====升序排序=====");
        tList.sort();
        print(tList);

        System.out.println("=====反转元素的顺序=====");
        tList.reverse();
        print(tList);

        System.out.println("=====指定2个索引位置，截取出一个新集合=====");
        TIntList tSubList = tList.subList(1,5);
        print(tSubList);

        System.out.println("=====插入元素到指定索引位置=====");
        tSubList.insert(1, 99);
        print(tSubList);

        System.out.println("=====替换指定索引位置的元素=====");
        tSubList.replace(0, 100);
        print(tSubList);

        System.out.println("=====随机打乱=====");
        tSubList.shuffle(new Random());
        print(tSubList);

        System.out.println("=====清空集合=====");
        tSubList.clear();
        System.out.println(tSubList.size());
    }

    /**
     * 打印方法
     * @param tList
     */
    private static void print(TIntList tList) {
        TIntIterator tIterator = tList.iterator();
        while (tIterator.hasNext()) {
            System.out.print(tIterator.next() + "\t");
        }
        System.out.println();
    }
}

控制台输出结果如下

=====添加一些元素=====
4	3	2	1	
=====集合中最大值=====
4
=====集合中最小值=====
1
=====集合中元素求和=====
10
=====trove方式可以很方便的添加一个int数组，矮油不错哦~=====
4	3	2	1	8	7	6	5	4	
=====刪除指定索引位置的元素(索引为2)=====
4	3	1	8	7	6	5	4	
=====删除集合中出现的第一个相同元素(值为4)=====
3	1	8	7	6	5	4	
=====升序排序=====
1	3	4	5	6	7	8	
=====反转元素的顺序=====
8	7	6	5	4	3	1	
=====指定2个索引位置，截取出一个新集合=====
7	6	5	4	
=====插入元素到指定索引位置=====
7	99	6	5	4	
=====替换指定索引位置的元素=====
100	99	6	5	4	
=====随机打乱=====
99	6	5	4	100	
=====清空集合=====
0
Process finished with exit code 0

占内存少

public static void main(String[] args) {
        System.gc();

        long currInitUseMemory1 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("当前初始化使用的内存" + currInitUseMemory1);

        System.out.println("=====list占用内存对比=====");
        TIntList tIntList = new TIntArrayList();
        for (int i = 0; i < 100000; i++) {
            tIntList.add(i);
        }
        long currUseMemory2 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("TIntList 中增加10000个元素使用内存" + (currUseMemory2 - currInitUseMemory1));

        List arrayList = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            arrayList.add(i);
        }
        long currUseMemory3 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("ArrayList中增加10000个元素使用内存" + (currUseMemory3 - currUseMemory2));

        System.out.println("=====map占用内存对比=====");

        TIntIntMap tIntIntMap = new TIntIntHashMap();
        for (int i = 0; i < 100000; i++) {
            tIntIntMap.put(i,i);
        }
        long currUseMemory4 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("tIntIntMap中增加10000个元素使用内存" + (currUseMemory4 - currUseMemory3));

        Map hashMap = new HashMap<>();
        for (int i = 0; i < 100000; i++) {
            hashMap.put(i,i);
        }
        long currUseMemory5 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("hashMap   中增加10000个元素使用内存" + (currUseMemory5 - currUseMemory4));
    }

控制台输出结果如下

当前初始化使用的内存3697592
=====list占用内存对比=====
TIntList 中增加10000个元素使用内存1997576
ArrayList中增加10000个元素使用内存2684352
=====map占用内存对比=====
tIntIntMap中增加10000个元素使用内存4017120
hashMap   中增加10000个元素使用内存9101744

Process finished with exit code 0

从结果看出内存确实节省了不少，应该trove对存储的数据结构进行了优化或修改了算法，小伙伴们感兴趣自己研究一下，发到评论区，感谢！