java修改前后差异_java代码优化前后性能对比测试

最新推荐文章于 2022-08-22 17:07:48 发布
最新推荐文章于 2022-08-22 17:07:48 发布
阅读量248 收藏
点赞数
文章标签： java修改前后差异
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30322969/article/details/114825890
版权

importjava.util.ArrayList;

importjava.util.Date;

importjava.util.HashMap;

importjava.util.Iterator;

importjava.util.Map;

importjava.util.Set;

importjava.util.StringTokenizer;

publicclassTest {

publicstaticvoidmain(String argv[]) {

/*

* 避免在循环条件中使用复杂表达式

* @author yifangyou

* @since 2011-08-16 09:35:00

*

*/

//      test0();

/*

* 如果只是查找单个字符的话，用charAt()代替startsWith()

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//      test1();

/*

* 能够使用移位的乘除，最好用移位

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//       test2();

/*

* 只有一个字符的字符串拼接，用''代替""

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//       test3();

/**

* try catch最好不要放在循环里

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//       test4();

/**

* switch的实现 map比较稳定,if最慢，switch在数量少于10个时最快，随着数量增加下降厉害

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//      test5();

/*

* 对于常量字符串，用'String' 代替 'StringBuffer' ,节省空间,节省时间

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//      test6();

/*

* 用'StringTokenizer' 代替 'indexOf()' 和'substring()'

* 字符串的分析在很多应用中都是常见的。使用indexOf

* ()和substring()来分析字符串容易导致StringIndexOutOfBoundsException。

* 而使用StringTokenizer类来分析字符串则会容易一些，效率也会低一些。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//       test7();

/*

* 不要在循环体中实例化变量 在循环体中实例化临时变量将会增加内存消耗

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//       test8();

/*

* 确定 StringBuffer的容量

* StringBuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小

* ，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建

* StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//       test9();

/*

* 尽可能的使用栈变量

*

* 如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。static?

* local?还是实例变量？访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//      test10();

/**

* 复制数组最好用System.arraycopy 逐个复制,最慢；批量复制,最快

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//      copyArray();

/*

* 复制ArrayList数组最好用addAll addAll，最快;clone,次之,逐个最慢

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

//      copyArrayList();

/*

* 复制Map最好用逐个复制最快，putAll最简单

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

copyMap();

}

intlocalN =0;

staticintstaticN =0;

/*

* 避免在循环条件中使用复杂表达式

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest0() {

ArrayList a =newArrayList();

for(inti =0; i <10000000; i++) {

a.add(i);

}

longstartTime;

// 循环条件中使用复杂表达式

startTime =newDate().getTime();

for(inti =0; i 

intj = a.get(i);

}

System.out.println(newDate().getTime() - startTime);

// 循环条件中不使用复杂表达式

startTime =newDate().getTime();

for(inti =0, maxlen = a.size(); i 

intj = a.get(i);

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 如果只是查找单个字符的话，用charAt()代替startsWith()

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest1() {

String s ="sdfsdfsdfsdfdssssssssssssssssssssssssssssdfffffffffffffffa";

longstartTime;

// startsWith

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

if(s.startsWith("a")) {

}

}

System.out.println(newDate().getTime() - startTime);

// charAt

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

if(s.charAt(0) =='a') {

}

}

System.out.println(newDate().getTime() - startTime);

// charAt

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

if("ab".equals("abcdssdds".substring(0,2))) {

}

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 能够使用移位的乘除，最好用移位

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest2() {

longstartTime;

inta;

//

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

a =333333333/8;

}

System.out.println(newDate().getTime() - startTime);

// charAt

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

a =333333333>>3;

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 只有一个字符的字符串拼接，用''代替""

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest3() {

longstartTime;

startTime =newDate().getTime();

String s ="123";

for(inti =0; i <10000000; i++) {

String a = s +"d";

}

System.out.println(newDate().getTime() - startTime);

// charAt

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

String a = s +'d';

}

System.out.println(newDate().getTime() - startTime);

}

/**

* try catch最好不要放在循环里

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest4() {

longstartTime;

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

try{

inta = Integer.parseInt("1");

}catch(Exception e) {

}

}

System.out.println(newDate().getTime() - startTime);

startTime =newDate().getTime();

try{

for(inti =0; i <10000000; i++) {

inta = Integer.parseInt("1");

}

}catch(Exception e) {

}

System.out.println(newDate().getTime() - startTime);

}

/**

* switch的实现 map比较稳定,if最慢，switch在数量少于10个时最快，随着数量增加下降厉害,在switch最好把出现次数最多的判断放在最前面

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest5() {

HashMap types =newHashMap() {

{

inti =0;

this.put("a", i++);

this.put("b", i++);

this.put("c", i++);

this.put("d", i++);

this.put("e", i++);

}

};

String a ="e";

intb =0;

longstartTime;

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

if("a".equals(a)) {

b =0;

}elseif("b".equals(a)) {

b =1;

}elseif("c".equals(a)) {

b =2;

}elseif("d".equals(a)) {

b =3;

}elseif("e".equals(a)) {

b =4;

}

}

System.out.println(newDate().getTime() - startTime);

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

b = types.get(a);

}

System.out.println(newDate().getTime() - startTime);

intc =14;//改为0的话则最快

startTime =newDate().getTime();

for(inti =0; i <10000000; i++) {

switch(c) {

case0:

break;

case1:

break;

case2:

break;

case3:

break;

case4:

break;

case5:

break;

case6:

break;

case7:

break;

case8:

break;

case9:

break;

case10:

break;

case11:

break;

case12:

break;

case13:

break;

case14:

break;

default:

break;

}

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 对于常量字符串，用'String' 代替 'StringBuffer' ,节省空间,节省一半时间

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest6() {

StringBuffer s =newStringBuffer("Hello");

intmaxlen=1000000;

longstartTime;

startTime =newDate().getTime();

for(inti =0; i 

String t =newString("Hello ") +"World!";

}

System.out.println(newDate().getTime() - startTime);

startTime =newDate().getTime();

for(inti =0; i 

StringBuffer t =newStringBuffer("Hello ").append("World!");

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 用'StringTokenizer' 代替 'indexOf()' 和'substring()'

* 字符串的分析在很多应用中都是常见的。使用indexOf

* ()和substring()来分析字符串容易导致StringIndexOutOfBoundsException。

* 而使用StringTokenizer类来分析字符串则会容易一些，效率也会低一些。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest7() {

String domain ="www.a.com.";

longstartTime;

startTime =newDate().getTime();

for(inti =0; i <100000; i++) {

intindex =0;

while((index = domain.indexOf(".", index +1)) != -1) {

domain.substring(index +1, domain.length());

// System.out.println(domain.substring(index+1,

// domain.length()));

}

}

System.out.println(newDate().getTime() - startTime);

startTime =newDate().getTime();

for(inti =0; i <100000; i++) {

StringTokenizer st =newStringTokenizer(domain,".");

while(st.hasMoreTokens()) {

st.nextToken();

// System.out.println(st.nextToken());

}

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 不要在循环体中实例化变量 在循环体中实例化临时变量将会增加内存消耗

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest8() {

ArrayList a =newArrayList();

intmaxlen =10000000;

for(inti =0; i 

a.add(i);

}

longstartTime;

startTime =newDate().getTime();

for(inti =0; i 

Object o =newObject();

o = a.get(i);

}

System.out.println(newDate().getTime() - startTime);

Object o =newObject();

startTime =newDate().getTime();

for(inti =0; i 

o = a.get(i);

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 确定 StringBuffer的容量

* StringBuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存

* ，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建

* StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest9() {

intmaxlen =1000000;

longstartTime;

startTime =newDate().getTime();

for(inti =0; i 

StringBuffer buffer =newStringBuffer();// violation

buffer.append("hellosdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

}

System.out.println(newDate().getTime() - startTime);

startTime =newDate().getTime();

for(inti =0; i 

StringBuffer buffer =newStringBuffer(128);// violation

buffer.append("hellosdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

}

System.out.println(newDate().getTime() - startTime);

}

/*

* 尽可能的使用栈变量 如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。static?

* local?还是实例变量？访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

publicstaticvoidtest10() {

intmaxlen =100000000;

longstartTime;

intn =0;

Test test =newTest();

// 局部变量

startTime =newDate().getTime();

for(inti =0; i 

n = i;

}

System.out.println(newDate().getTime() - startTime);

// 类变量

startTime =newDate().getTime();

for(inti =0; i 

test.localN = i;

}

System.out.println(newDate().getTime() - startTime);

// 静态变量

startTime =newDate().getTime();

for(inti =0; i 

Test.staticN = i;

}

System.out.println(newDate().getTime() - startTime);

}

//

//  /*1.尽量使用final修饰符。

//带有final修饰符的类是不可派生的。在JAVA核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。

//   */

//  public static void test11() {

//      int maxlen = 10000000;

//      long startTime;

//      int n = 0;

//

//      // 普通类

//      startTime = new Date().getTime();

//      A a = new A();

//      for (int i = 0; i 

//          a.inc();

//      }

//      System.out.println(new Date().getTime() - startTime);

//

//      // final类

//      startTime = new Date().getTime();

//      FinalA finalA = new FinalA();

//      for (int i = 0; i 

//          finalA.inc();

//      }

//      System.out.println(new Date().getTime() - startTime);

//  }

/**

* 复制数组最好用System.arraycopy 逐个复制,最慢；批量复制,最快

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

staticvoidcopyArray() {

int[] array1 =newint[10000000];

int[] array2 =newint[10000000];

for(inti =0, maxlen = array1.length; i 

array1[i] = i;

}

longstartTime;

// 逐个复制,最慢

startTime =newDate().getTime();

for(inti =0, maxlen = array2.length; i 

array2[i] = array1[i];// Violation

}

System.out.println(newDate().getTime() - startTime);

// 批量复制,最快

startTime =newDate().getTime();

System.arraycopy(array1,0, array2,0,10000);

System.out.println(newDate().getTime() - startTime);

}

/*

* 复制ArrayList数组最好用addAll addAll，最快;clone,次之,逐个最慢

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

staticvoidcopyArrayList() {

intmaxlen =1000000;

ArrayList array1 =newArrayList();

ArrayList array2 =newArrayList();

ArrayList array3 =newArrayList();

ArrayList array4;

for(inti =0; i 

array1.add(i);

}

longstartTime;

// 逐个复制,最慢

startTime =newDate().getTime();

for(inti =0; i 

array2.add(array1.get(i));// Violation

}

System.out.println(newDate().getTime() - startTime);

// 批量复制，最快

startTime =newDate().getTime();

array3.addAll(array1);

System.out.println(newDate().getTime() - startTime);

// 克隆，次快

startTime =newDate().getTime();

array4 = (ArrayList) array1.clone();

System.out.println(newDate().getTime() - startTime);

array4.set(0,4);

System.out.println("array1[0]="+ array1.get(0));

System.out.println("array4[0]="+ array4.get(0));

}

/*

* 复制Map最好用逐个复制最快，putAll最简单

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

staticvoidcopyMap() {

intmaxlen =1000000;

Map map1 =newHashMap();

Map map2 =newHashMap();

Map map3 =newHashMap();

Map map4 =newHashMap();

for(inti =0; i 

map1.put(i, i);

}

longstartTime;

// 逐个复制，最快

startTime =newDate().getTime();

Set key = map1.keySet();

for(Iterator it = key.iterator(); it.hasNext();) {

Integer k = (Integer) it.next();

map2.put(k, map1.get(k));

}

System.out.println(newDate().getTime() - startTime);

// 批量复制，最慢

startTime =newDate().getTime();

map3.putAll(map1);

System.out.println(newDate().getTime() - startTime);

System.out.println("map2[9999]="+ map2.get(9999));

System.out.println("map3[9999]="+ map3.get(9999));

// 逐个复制，次快

startTime =newDate().getTime();

Set> set = map1.entrySet();

for(Iterator> it = set.iterator(); it

.hasNext();) {

Map.Entry entry = (Map.Entry) it

.next();

map4.put(entry.getKey(), entry.getValue());

}

System.out.println(newDate().getTime() - startTime);

}

}

鲸拍房
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java jvm及性能优化_javajvm优化_Java性能分析_
09-30
Java助力需要jvm学习及优化与性能瓶颈分析参考
java-操作记录-对比操作前后不同
weixin_42943586的博客
12-30 1179
xkbeancomparator xkbeancomparator是一个 java bean对比修改并输出差异的工具。github地址 适用场景：用户编辑提交时，需要记录修改内容，修改前后的值对比，生成操作记录；可以选择记录的字段和字段说明，自定义操作记录。 （1）依赖 dependency： <dependency> <groupId>com.github.xkzhangsan</groupId> <artifactId>xkbean
修改了别人的代码、优化前与优化后的对比，唉，写个好代码真不容易啊
通用权限管理系统
01-04 1219
   最近紧急接手别人做了一半的项目，看了一些代码，惨不忍睹，也号称是上海的IT公司写的代码，还说自己是做了很多年的政府项目，自信得很，态度很高傲、目中无人，我是彻底服了，我已经很嚣张了，居然比我还嚣张很多很多，项目做得一塌糊涂，代码质量还这么差，当然也不是说我的代码写得有多好，只是想说，写代码需要认真再认真，需要仔细做好每件事、日积月累，才能有个良好的技术积累、项目积累，想赚钱也会容易很
java修改前后差异_java中比较两条数据结构相同的数据的不同值（对一条数据修改前和修改后的不同）代码...
weixin_30000283的博客
02-27 1494
之前做的一个微信端的项目：项目有一个需求是修改数据的时候，将进行修改了的数据记录下来，然后修改了多少数据加一定的积分。最近做了个项目：项目的需求是对一张单子的某几项进行修改，然后和修改之前的单子进行比较，展示修改了哪些内容，这两张单子都是可以在数据库不同表查出来的，但是这两张表的数据结构是相同的。代码是这样写的：第一个是主要方法，第二个是部分实体类。其实主要就是运用了反射。public Listq...
java代码优化前后性能对比测试
weixin_34080903的博客
08-17 64
下面的代码是我用来比较代码优化前后的性能 importjava.util.ArrayList; importjava.util.Date; importjava.util.HashMap; importjava.util.Iterator; importjava.util.Map; importjava.util.Set; importjav...
Java性能优化之数据结构实例代码
08-28
主要介绍了Java性能优化之数据结构实例代码，具有一定借鉴价值,需要的朋友可以参考下
java前后端分离快速开发 代码生成器
11-29
java前后端分离，快速开发，代码生成器，nginx发布前端页面
Java编程代码性能优化
09-03
本文介绍了 Java 代码优化的过程,总结了优化 Java 程序的一些最佳实践,分析了进行优化的方法,并解释了性能提升的原因,需要的朋友可以参考下
Java代码性能优化的35个方法总结
08-31
本篇文章主要介绍了Java代码性能优化的35个方法，具有很好的参考价值，下面跟着小编一起来看下吧
C++代码优化总结
Kelvin_Yan的专栏
04-24 1624
※使用循环展开技术 由于循环体的内容相对简单，以至于这个循环实际执行过程中差不多一半的指令都在为检查循环执行的条件而服务。如果计算循环索引和测试循环条件的循环开销部分所占比重过大，这时就可以考虑使用一种被称作"循环展开"的方式来优化代码。所谓循环展开就是通过在每次迭代中执行更多的数据操作来减小循环开销的影响。其基本思想是设法把操作对象线性化，并且在一次迭代中访问线性数据中的一小组而非单独的某
Java实现记录对象修改前后的变化
tianyuxu的博客
03-10 9347
记录Java Bean修改明细 需求描述 今天接到一个需求，修改数据时需要记录修改详情。详情包括，被修改的字段，修改前的值和修改后的值。 解决思路 分别比较修改前后两个Bean实例的所有成员变量，当值不一致时，记录变量名称，以及修改前后的值。 对于该方案，可以解决特定类型的Bean。 如果有其它类型的Bean也有这种需求，则需要新写一套逻辑，处理相应的需求。 上述方案不能复用，如果有多个这样的Bean需要比较，则每个Bean都需要新写一套逻辑。然而，利用泛型和反射技术，则可以达到一次编码，多处复用的效果
JAVA对象对比JSON对象找出差异值结合swagger-ApiModel无需自定义注解
能让你写代码●写出拯救全世界的感觉
08-22 938
对比俩个对象相同字段修改前后值的变化 --工具类 --自定义修改 [对比嵌套对象和嵌套list 和 VO单属性]
用Java语言实现文本内容对比的算法和程序
weixin_43274704的博客
11-10 7666
前言 近日，鄙人在工作中接到甲方提出的一项研发需求，就是用程序将修改后的文件内容和修改前的文件内容进行比对，找出其中差异的部分进行展示，以便能够一眼看出修改人对文件做出了哪些修改。 刚接到这项需求时，感到颇有难度，但是我相信世界上没有无算法可以解决的问题，也没有程序实现不了的功能。经过深入思考，终于想出来实现文本内容对比的算法，并且写成程序得以实现。现将编程思想、算法和代码公布，欢迎各位软件研发人...
字符串修改前后比较不同
qq_29539827的博客
04-06 1210
页面上有一个勾选列表，需要实现页面修改之后被新增、修改、删除的数据实现同步后台数据库表里。做法是先是查数据库表原有的数据的主键（逗号拼接成字符串形式）然后与页面修改之后传到后台的字符串进行比较，找出勾选的不同之处。然后把新勾选的插入数据库，勾选去的从数据库删除，仍保留勾选的对数据库字段进行更新。 下面是找出新老两个字符串哪些是新增哪些是删除哪些是保留的方法 package yulisao.test; import org.apache.commons.lang3.StringUtils; import
java中修改对象类的数据_java 记录对象前后修改的内容(工具类)
weixin_29783407的博客
02-24 1293
有时候业务需要，需记录一条记录的修改历史，但是不能为完成任务而硬编码，不靠谱这种情况可以使用java反射来完成对对象属性的描述可以通过自定义注解来完成，读取里面的属性进而记录修改历史。在对象的属性上面加上注解，value设置为属性的中文描述工具了代码如下util类(BeanChangeUtil)importjava.beans.PropertyDescriptor;importjava.lang....
JAVA 记录每个修改的字段的前后值
Moonbow
02-14 6869
工具类：UpdateLogUtil.java   package com.newsee.util; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.math.BigDecimal; import java.text.DecimalFormat; import java.tex...
java 比较两个对象属性值变化情况，用于记录日志使用
热门推荐
I__Rookie的博客
09-21 1万+
package com.cdc.console.controller;import java.beans.PropertyDescriptor; import java.lang.reflect.Field; import java.lang.reflect.Method;public class Test<T> { public String contrastObj(Object oldBe
java io 和nio_java对比IO和NIO的文件读写性能测试
最新发布
05-31
Java IO 和 NIO 都可以用于文件读写操作，但是它们的实现方式不同，因此在性能上也略有差异。 针对文件读写操作，我们可以通过编写测试程序来对比 Java IO 和 NIO 的性能。下面是一个简单的测试程序： ```java import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class FileReadWriteTest { private static final int BUFFER_SIZE = 1024 * 1024; public static void main(String[] args) throws Exception { String file = "test.txt"; int size = 1024 * 1024 * 100; // 测试 Java IO 的文件写入性能 long start = System.currentTimeMillis(); FileOutputStream fos = new FileOutputStream(file); for (int i = 0; i < size; i++) { fos.write('a'); } fos.close(); long end = System.currentTimeMillis(); System.out.println("Java IO 文件写入耗时：" + (end - start) + "ms"); // 测试 Java IO 的文件读取性能 start = System.currentTimeMillis(); FileInputStream fis = new FileInputStream(file); byte[] buffer = new byte[BUFFER_SIZE]; int len; while ((len = fis.read(buffer)) != -1) { // do nothing } fis.close(); end = System.currentTimeMillis(); System.out.println("Java IO 文件读取耗时：" + (end - start) + "ms"); // 测试 NIO 的文件写入性能 start = System.currentTimeMillis(); FileChannel fc = new FileOutputStream(file).getChannel(); ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE); for (int i = 0; i < size / BUFFER_SIZE; i++) { fc.write(byteBuffer); byteBuffer.clear(); } fc.close(); end = System.currentTimeMillis(); System.out.println("NIO 文件写入耗时：" + (end - start) + "ms"); // 测试 NIO 的文件读取性能 start = System.currentTimeMillis(); fc = new FileInputStream(file).getChannel(); byteBuffer = ByteBuffer.allocate(BUFFER_SIZE); while (fc.read(byteBuffer) != -1) { byteBuffer.flip(); byteBuffer.clear(); } fc.close(); end = System.currentTimeMillis(); System.out.println("NIO 文件读取耗时：" + (end - start) + "ms"); } } ``` 该测试程序分别测试了 Java IO 和 NIO 的文件写入和文件读取性能。其中，文件大小为 100MB，缓冲区大小为 1MB。 运行该测试程序，可以得到如下结果： ``` Java IO 文件写入耗时：220ms Java IO 文件读取耗时：219ms NIO 文件写入耗时：248ms NIO 文件读取耗时：177ms ``` 可以看出，在该测试条件下，Java IO 和 NIO 的文件读取性能差异不大，但是 NIO 的文件写入性能略逊于 Java IO。不过需要注意的是，这只是一个简单的测试，实际情况下可能会因为多种因素而产生差异。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值