Java 排序性能测试项目

最新推荐文章于 2024-07-27 16:49:20 发布
最新推荐文章于 2024-07-27 16:49:20 发布
阅读量182 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44947828/article/details/101392824
版权

基于比较实现的七大排序算法：

思维导图记录：

测评排序算法的重要指标：稳定性

稳定性：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序 算法。

 

源码测试实现：

Lab.java

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

interface SortMethod {
    String getName();
    void sort(int[] a);
}

class InsertSortMethod implements SortMethod {
    @Override
    public String getName() {
        return "插入排序";
    }

    @Override
    public void sort(int[] a) {
        Sort.insertSort0(a);
    }


}
class shellSortMethod implements SortMethod{

    @Override
    public String getName() {
        return "希尔排序";
    }

    @Override
    public void sort(int[] a) {
        Sort.shellSort(a);
    }
}



class selectSort0Method implements SortMethod{

    @Override
    public String getName() {
        return "选择排序";
    }

    @Override
    public void sort(int[] a) {
        Sort.selectSort0(a);
    }
}

class heapSortMethod implements SortMethod{

    @Override
    public String getName() {
        return "堆排";
    }

    @Override
    public void sort(int[] a) {
        Sort.heapSort(a);
    }
}


class bubbleSortMethod implements SortMethod{

    @Override
    public String getName() {
        return "冒泡排序";
    }

    @Override
    public void sort(int[] a) {
        Sort.bubbleSort(a);
    }
}




public class Lab {
    private static SortMethod[] methods = {
            new InsertSortMethod(),
    };

    private static SortMethod[] methods1 = {
            new shellSortMethod(),
    };

    private static SortMethod[] methods2 = {
            new selectSort0Method(),
    };

    private static SortMethod[] methods3 = {
            new heapSortMethod(),
    };

    private static SortMethod[] methods4 = {
            new bubbleSortMethod(),
    };



    //随机
    public static int[] buildRandom(int n) {
        Random random = new Random(20190924);
        int[] r = new int[n];
        for (int i = 0; i < n; i++) {
            r[i] = random.nextInt(n);
        }
        return r;
    }

    //有序
    public static int[] buildSorted(int n) {
        Random random = new Random(20190924);
        int[] r = new int[n];
        for (int i = 0; i < n; i++) {
            r[i] = random.nextInt(n);
        }
        Arrays.sort(r);
        return r;
    }

    //逆序
    private static void shellSortR(int[] array) {
        int gap = array.length;
        while (true) {
            gap = (gap / 3) + 1;
            //gap = gap / 2;
            insertSortWithGapR(array, gap);
            if (gap == 1) {
                break;
            }
        }
    }
    private static void insertSortWithGapR(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int key = array[i];
            int j;
            for (j = i - gap; j >= 0 && array[j] < key; j -= gap) {
                array[j + gap] = array[j];
            }
            array[j + gap] = key;
        }
    }

    public static int[] buildReversed(int n) {
        Random random = new Random(20190924);
        int[] r = new int[n];
        for (int i = 0; i < n; i++) {
            r[i] = random.nextInt(n);
        }
        shellSortR(r);
        return r;
    }

    //相等
    public static int[] buildEquals(int n) {
        return new int[n];
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 4; i++) {
            int n = i * 50000;
            int[] random = buildRandom(n);
            int[] sorted = buildSorted(n);
            int[] reversed = buildReversed(n);
            int[] equals = buildEquals(n);

//            //插入排序随机数据测试
//            for (SortMethod method : methods) {
//                int[] a = random.clone();
//                long begin = System.nanoTime();
//                method.sort(a);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("随机情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //插入排序顺序数据测试
//            for (SortMethod method : methods) {
//                int[] b = sorted.clone();
//                long begin = System.nanoTime();
//                method.sort(b);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("有序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //插入排序逆序数据测试
//            for (SortMethod method : methods) {
//                int[] c = reversed.clone();
//                long begin = System.nanoTime();
//                method.sort(c);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("逆序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //插入排序相等数据测试
//            for (SortMethod method : methods) {
//                int[] d = equals.clone();
//                long begin = System.nanoTime();
//                method.sort(d);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("相等情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//

//            //希尔排序随机数据测试
//            for (SortMethod method : methods1) {
//                int[] a = random.clone();
//                long begin = System.nanoTime();
//                method.sort(a);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("随机情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //希尔排序顺序数据测试
//            for (SortMethod method : methods1) {
//                int[] b = sorted.clone();
//                long begin = System.nanoTime();
//                method.sort(b);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("有序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //希尔排序逆序数据测试
//            for (SortMethod method : methods1) {
//                int[] c = reversed.clone();
//                long begin = System.nanoTime();
//                method.sort(c);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("逆序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //希尔排序相等数据测试
//            for (SortMethod method : methods1) {
//                int[] d = equals.clone();
//                long begin = System.nanoTime();
//                method.sort(d);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("相等情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }

//            //选择排序测试
//            //选择排序随机数据测试
//            for (SortMethod method : methods2) {
//                int[] a = random.clone();
//                long begin = System.nanoTime();
//                method.sort(a);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("随机情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //选择排序顺序数据测试
//            for (SortMethod method : methods2) {
//                int[] b = sorted.clone();
//                long begin = System.nanoTime();
//                method.sort(b);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("有序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //选择排序逆序数据测试
//            for (SortMethod method : methods2) {
//                int[] c = reversed.clone();
//                long begin = System.nanoTime();
//                method.sort(c);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("逆序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //选择排序相等数据测试
//            for (SortMethod method : methods2) {
//                int[] d = equals.clone();
//                long begin = System.nanoTime();
//                method.sort(d);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("相等情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//

//            //堆排序测试
//            //堆排序随机数据测试
//            for (SortMethod method : methods3) {
//                int[] a = random.clone();
//                long begin = System.nanoTime();
//                method.sort(a);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("随机情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //堆排序顺序数据测试
//            for (SortMethod method : methods3) {
//                int[] b = sorted.clone();
//                long begin = System.nanoTime();
//                method.sort(b);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("有序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //堆排序逆序数据测试
//            for (SortMethod method : methods3) {
//                int[] c = reversed.clone();
//                long begin = System.nanoTime();
//                method.sort(c);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("逆序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }
//
//            //堆排序相等数据测试
//            for (SortMethod method : methods3) {
//                int[] d = equals.clone();
//                long begin = System.nanoTime();
//                method.sort(d);
//                long end = System.nanoTime();
//                double ms = (end - begin) * 1.0 / 1000000;
//
//                System.out.printf("相等情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
//            }




            //冒泡排序测试
            //冒泡排序随机数据测试
            for (SortMethod method : methods4) {
                int[] a = random.clone();
                long begin = System.nanoTime();
                method.sort(a);
                long end = System.nanoTime();
                double ms = (end - begin) * 1.0 / 1000000;

                System.out.printf("随机情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
            }

            //冒泡排序顺序数据测试
            for (SortMethod method : methods4) {
                int[] b = sorted.clone();
                long begin = System.nanoTime();
                method.sort(b);
                long end = System.nanoTime();
                double ms = (end - begin) * 1.0 / 1000000;

                System.out.printf("有序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
            }

            //冒泡排序逆序数据测试
            for (SortMethod method : methods4) {
                int[] c = reversed.clone();
                long begin = System.nanoTime();
                method.sort(c);
                long end = System.nanoTime();
                double ms = (end - begin) * 1.0 / 1000000;

                System.out.printf("逆序情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
            }

            //冒泡排序相等数据测试
            for (SortMethod method : methods4) {
                int[] d = equals.clone();
                long begin = System.nanoTime();
                method.sort(d);
                long end = System.nanoTime();
                double ms = (end - begin) * 1.0 / 1000000;

                System.out.printf("相等情况下%s个数据: %s: 耗时 %.5f 毫秒%n", n,method.getName(), ms);
            }




        }
    }

    public static SortMethod[] getMethods() {
        return methods;
    }

    public static void setMethods(SortMethod[] methods) {
        Lab.methods = methods;
    }
}

Sort.java

import java.util.Arrays;
import java.util.Random;

public class Sort {
    // 直接插入排序
//    public static void insertSort(int[] array) {
//        for (int i = 1; i < array.length; i++) {
//            // 有序   [0, i)
//            // 无序   [i, array.length)
//            int key = array[i];
//            int j;
//            for (j = i - 1; j >= 0; j--) {
//                if (array[j] <= key) {
//                    break;
//                } else {
//                    array[j + 1] = array[j];
//                }
//            }
//            array[j + 1] = key;
//        }
//    }

    /**
     * 时间复杂度
     * 最好       平均          最坏
     * O(n)       O(n^2)        O(n^2
     * 数据有序                 数据逆序
     * 空间复杂度
     * O(1)
     * @param array
     */
    //直接插入排序
    public static void insertSort0(int[] array) {
        for (int i = 1; i < array.length; i++) {
            // 有序   [0, i)
            // 无序   [i, array.length)
            int key = array[i];
            int j;
            for (j = i - 1; j >= 0 && array[j] > key; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = key;
        }
    }

    //希尔排序
    public static void shellSort(int[] array) {
        int gap = array.length;
        while (true) {
            gap = (gap / 3) + 1;
            //gap = gap / 2;
            insertSortWithGap(array, gap);
            if (gap == 1) {
                break;
            }
        }
    }

    private static void insertSortWithGap(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int key = array[i];
            int j;
            for (j = i - gap; j >= 0 && array[j] > key; j -= gap) {
                array[j + gap] = array[j];
            }
            array[j + gap] = key;
        }
    }

    //选择排序
    public static void selectSort0(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            // 无序区间 [i, array.length)
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }

            swap(array, minIndex, i);
        }
    }

    public static void selectSort2(int[] array) {
        // 无序: [begin, end]
        int begin = 0;
        int end = array.length - 1;

        while (begin < end) {
            int minIndex = begin;
            int maxIndex = begin;
            for (int j = begin + 1; j <= end; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
                if (array[j] > array[maxIndex]) {
                    maxIndex = j;
                }
            }
            swap(array, minIndex, begin);
            if (maxIndex == begin) {
                maxIndex = minIndex;
            }
            swap(array, maxIndex, end);
            begin++; end--;
        }
    }

    public static void selectSort(int[] array) {
        // 每次选最大的放到无序区间的最后
        for (int i = 0; i < array.length - 1; i++) {
            // 无序 [0, array.length - i)
            // 有序 [array.length - i, array.length)
            int maxIndex = 0;
            for (int j = 1; j < array.length - i; j++) {
                if (array[j] > array[maxIndex]) {
                    maxIndex = j;
                }
            }

            swap(array, maxIndex, array.length - i - 1);
        }
    }

    private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    public static void main(String[] args) {
        testRight();
        testSpeed();
    }

    public static void heapSort(int[] array) {
        createHeapBig(array);
        for (int i = 0; i < array.length - 1; i++) {
            // 无序 [0, array.length - i)
            // 交换 array[0], array[length - i - 1]
            // 无序 [0, array.length - i - 1)
            // 无序长度 array.length - i - 1
            // 下标 0 进行向下调整
            swap(array, 0, array.length - i - 1);
            shiftDownBig(array, 0, array.length - i - 1);
        }
    }

    private static void createHeapBig(int[] array) {
        for (int i = (array.length - 2) / 2; i >= 0; i--) {
            shiftDownBig(array, i, array.length);
        }
    }

    private static void shiftDownBig(int[] array, int i, int size) {
        while (2 * i + 1 < size) {
            int max = 2 * i + 1;
            if (max + 1 < size && array[max+1] > array[max]) {
                max = max + 1;
            }
            if (array[i] >= array[max]) {
                return;
            }
            swap(array, i, max);
            i = max;
        }
    }

    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            boolean isSort = true;
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    isSort = false;
                }
            }
            if (isSort) {
                return;
            }
        }
    }

    public static void testRight() {
        int[] a = { 2, 3, 7, 9, 4, 5, 6, 9, 1, 4, 7, 8 };

        int[] b = a.clone();
        bubbleSort(b);
        System.out.println(Arrays.toString(b));

        int[] c = a.clone();
        Arrays.sort(c);
        System.out.println(Arrays.toString(c));

        System.out.println(Arrays.equals(b, c));
    }

    public static void testSpeed() {
        Random random = new Random(20190924);
        int[] a = new int[10 * 10000];
        for (int i = 0; i < 10 * 10000; i++) {
            a[i] = random.nextInt(10 * 10000);
        }

        long begin = System.nanoTime();
        bubbleSort(a);
        long end = System.nanoTime();

        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("一共耗时: %.5f 毫秒%n", ms);
    }
}

测评结果：

随机数据，有序数据，逆序数据，相等数据（50000,100000,150000,200000个数据测评完成时间）

A,插入排序

B，希尔排序

C，选择排序

D，堆排序

E，冒泡排序

F，归并排序测试有误，明天更新

王白白就很白
关注
专栏目录
排序性能测试（JAVA）
cedarjo的博客
03-22 298
生成测试用数据 @Test public void generatePhoneNum() throws Exception { generatePhoneNum(50000); generatePhoneNum(100000); generatePhoneNum(150000); generatePhoneNum(200000); generatePhone...
java排序源码-sorting:使用Java语言进行排序的源代码
05-19
在实际开发中，Java集合框架中的`Arrays.sort()`方法已经提供了对数组的排序功能，底层采用了TimSort算法，一种结合了插入排序和归并排序特点的稳定排序算法，具有很好的性能表现。此外，`Collections.sort()`方法则...
一个项目的项目性能测试总结
09-26
一个项目的项目总结 一个项目的项目总结 一个项目的项目总结
java压力性能测试工具——JMeter
好幸运
04-28 311
一、下载工具http://jmeter.apache.org/download_jmeter.cgi?Preferred=http%3A%2F%2Fmirror.bit.edu.cn%2Fapache%2F 二、工具配置 教程：https://blog.csdn.net/u012111923/article/details/80705141#commentBox ...
Java性能测试和调优
明戈戈的博客
05-23 466
压力测试（Stress Testing）：在超出系统正常工作负载的条件下，测试系统的性能极限和稳定性。负载测试（Load Testing）：在模拟实际生产环境中的负载条件下，测试系统的性能表现。容量测试（Capacity Testing）：测试系统在达到峰值负载情况下的性能表现，并确定系统的容量上限。通过以上几种不同类型的性能测试，可以全面评估系统在不同负载条件下的性能表现，找出性能瓶颈和优化的方向。性能调优是在性能测试的基础上，针对性地优化系统性能的过程。性能测试旨在评估系统在不同负载条件下的性能表现。
Java中的性能测试与负载测试
最新发布
微赚淘客系统开发者博客
07-27 707
本文将详细介绍 Java 中性能测试与负载测试的实用方法，包括常用工具、测试策略和代码示例，帮助开发者提高系统的稳定性和响应能力。通过使用 JMeter、Gatling 和 VisualVM 等工具，可以有效地进行性能测试和负载测试，发现系统瓶颈并进行优化。性能测试的主要目的是评估应用程序在各种条件下的性能表现，包括响应时间、吞吐量和资源消耗。负载测试是性能测试的一个重要部分，主要用于验证系统在预期负载下的表现。使用参数化测试和数据驱动测试提高测试覆盖率，并避免测试脚本的重复和冗余。
Java排序算法详解与性能测试：从冒泡到堆排序
本文档详细介绍了Java中常用的排序算法及其性能测试结果。作者在一个悠闲的周末，回顾了在学校学习过的排序算法，如冒泡排序、选择排序、插入排序、二分树排序、希尔排序、快速排序、堆排序等，并针对每个算法进行了...
Java排序算法练习：1.快速排序 2.归并排序 3.插入排序 4.冒泡排序 5.选择排序 6.堆排序
08-08
项目中的每个排序算法作为一个独立的类，这种设计遵循了面向对象的原则，便于代码组织和单元测试。 总的来说，理解并掌握这些排序算法有助于提升编程能力，更好地解决实际问题。在处理大量数据时，选择高效且适应...
java汉字笔画排序2例子及jar包
07-04
在给出的标题"java汉字笔画排序2例子及jar包"中，我们可以推断这是一个关于Java实现汉字笔画排序的项目，其中可能包含了两种不同的实现方式或者优化后的版本。 描述中提到，"对排序方法重新定义，减少占用，效率...
SpaniardSort:Shell排序和混合排序的Java实现
05-23
**SpaniardSort-master**这个压缩包文件名暗示这是一个项目仓库的主分支，通常包含源代码、测试用例、README文件等资源。用户可以通过解压文件来查看和学习SpaniardSort的具体实现，包括算法的逻辑、优化策略以及...
细说Java性能测试第二课 性能测试详解1
fegus的博客
04-30 1059
Jmeter二次开发 上一讲我们通过学习 JMeter 的脚本编写方式和执行方式，掌握了如何让 JMeter 更加有效地运行，其技术思路是使用 JMeter 本身或者社区提供的现成方案去实现，这基本已经满足了绝大多数性能测试的需求。 随着互联网行业发展，各种技术方案层出不穷，但是任何方案都不是万能的，有些需求是要我们自己写代码去实现的，JMeter 也留了相应的入口便于我们编写代码，所以本讲将介绍三种插件编写方式： 自定义 BeanShell 功能 自定义请求编写（Java Sampler
常见排序的JAVA实现和性能测试
ColdCoding的博客
03-21 1675
写了五种常见的排序算法实现 算法描述 1.插入排序 从第一个元素开始，该元素可以认为已经被排序 取出下一个元素，在已经排序的元素序列中从后向前扫描 如果该元素（已排序）大于新元素，将该元素移到下一位置 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 将新元素插入到该位置后 重复步骤2~5 在这个基础上有衍生出提高效率的二分插入排序2.冒泡排序 比较
排序算法性能评估
weixin_44987639的博客
12-23 454
性能评价标准 (1 稳定性比较 稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串行中R出现在S之前，在排序过的串行中R也将会是在S之前。 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的. 选择排序、希尔排序、快速排序、堆排序是不稳定的. (2计算的复杂度（最差、...
记一次完整的java项目压力测试
VcStrong的专栏
07-27 2万+
总结：通过这次压力测试，增加了对程序的理解；假定正常情况下方法执行时间为2秒，吞吐量为100/s,则并发为200/s；假设用户可接受范围为10s，那么并发量可以继续增加到1000/s，到这个时候一切还都正常，若想继续提高并发量，我们可以优化吞吐量，增加tomcat的线程数和mysql的连接数；当吞吐量和并发量都达到一定程度，我们的JVM已经爆仓，则到了java开发最喜欢的JVM调优环节。 本着压...
Java Web项目性能测试 - JMeter测试网站吞吐量、反应时间百分比、流量
热门推荐
大大的微笑的专栏
10-08 2万+
Java Web性能测试 - JMeter测试网站吞吐量、反应时间百分比、流量 一、JMeter下载安装 二、测试脚本编写 Java Web性能测试 - 动态网站测试脚本录制 三、测试计划 四、测试报告
细说Java性能测试第三课 性能测试详解2
fegus的博客
04-30 1275
如何制定一份有效的性能测试方案？ 上一讲我们学习了性能测试的场景，并且明确了每个场景的核心意义，这一讲我将带你学习如何做好一份性能测试方案，相信你对测试方案这个概念并不陌生，那如何做好一份性能测试方案呢？这个方案能解决什么问题呢？这一讲我们来一起探索。 什么是性能测试方案？ 性能测试方案，通俗一点说就是指导你进行性能测试的文档，包含测试目的、测试方法、测试场景、环境配置、测试排期、测试资源、风险分析等内容。一份详细的性能测试方案可以帮助项目成员明确测试计划和手段，更好地控制测试流程。 性能测试方案的要点以及
Java-集合性能测试及结果分析
因特马
06-01 1759
本文欢迎转载，转载前请联系作者，经允许后方可转载。转载后请注明出处，谢谢！ http://blog.csdn.net/colton_null 作者：喝酒不骑马 Colton_Null from CSDN 一.引言 上篇介绍了java中集合的部分内容，本篇则针对常用集合进行性能的测试。测试方法借鉴于《Java编程思想》。具体实现代码在文末给出。 测试结果通过格式化输出方式展示。时间单位...
java项目性能测试过程记录
weixin_33670786的博客
10-18 1737
一准备环境和指标 1.主机三台（linux，这里显示的都是伪主机地址）：最好用干净的机子，做性能测试的时候别装其他东西在上面跑。 100.22.0.98部署自己的项目服务100.22.0.96部署rpc服务（这里没用到 可以不搞）100.22.0.97部署jmeter （这是必须的） 2.统计指标： TPS Avg time（ms） cpu%...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值