From 3d1502a2ac2ffb6dd3cb81d916b985a7a9e77f98 Mon Sep 17 00:00:00 2001 From: AutumnLight Date: Mon, 4 Apr 2016 21:37:43 +0800 Subject: [PATCH 01/21] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E7=BF=BB=E8=AF=91=20?= =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=97=AE=E9=A2=98why-is-printing-b-dramatica?= =?UTF-8?q?lly-slower-than-printing=E7=9A=84=E7=BF=BB=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...ing-b-dramatically-slower-than-printing.md | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 contents/why-is-printing-b-dramatically-slower-than-printing.md diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md new file mode 100644 index 0000000..9070221 --- /dev/null +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -0,0 +1,62 @@ +##为什么打印B要比打印#慢很多？ + +###问题 +我生成了两个大小为 1000 * 1000 的矩阵 +第一个矩阵：O和# +第二个矩阵：O和B +使用一下代码，第一个矩阵仅用时8.25s就完成了： +` +Random r = new Random(); +for (int i = 0; i < 1000; i++) { + for (int j = 0; j < 1000; j++) { + if(r.nextInt(4) == 0) { + System.out.print("O"); + } else { + System.out.print("#"); + } + } + + System.out.println(""); + } +` +而使用相同的代码时，第二个矩阵却执行了259.152s +` +Random r = new Random(); +for (int i = 0; i < 1000; i++) { + for (int j = 0; j < 1000; j++) { + if(r.nextInt(4) == 0) { + System.out.print("O"); + } else { + System.out.print("B"); + } + } + + System.out.println(""); + } +` +为什么两者的执行时间会有如此巨大的差距？ +--- +评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） +另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 + +测试条件： +1.Netbeans 7.2，结果输出在IDE的控制台 +2.使用`System.nanoTime()`度量时间 + + +###回答 +纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)， +而'#'视为一个非单词字符(non-word character)。因此当输出到达行尾时，控制台会搜索一个空白符来换行，当遇到'#'时可以立即执行换行； +然而遇到'B'时，控制台必须继续搜索，因为后面可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 +但是，这仅仅是理论推测。 + + +**译者注：** +对于"word-wrapping"和"character-wrapping"，我的理解是，换行时不在一个单词内部分割，例如需要在 charac-ter 中的-处换行，"word-wrapping"会将 character 全部移到下一行， +而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 +"word-wrapping" +`******* +character` +"character-wrapping" +`*******charac +ter` From fc805433f78cc28117ab09fc737c9bed5558bfc4 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 21:49:47 +0800 Subject: [PATCH 02/21] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 添加了一些空白作为换行使用 --- ...ing-b-dramatically-slower-than-printing.md | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 9070221..1f6a874 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -1,10 +1,10 @@ ##为什么打印B要比打印#慢很多？ -###问题 -我生成了两个大小为 1000 * 1000 的矩阵 -第一个矩阵：O和# -第二个矩阵：O和B -使用一下代码，第一个矩阵仅用时8.25s就完成了： +###问题 +我生成了两个大小为 1000 * 1000 的矩阵 +第一个矩阵：O和# +第二个矩阵：O和B +使用一下代码，第一个矩阵仅用时8.25s就完成了： ` Random r = new Random(); for (int i = 0; i < 1000; i++) { @@ -19,7 +19,7 @@ for (int i = 0; i < 1000; i++) { System.out.println(""); } ` -而使用相同的代码时，第二个矩阵却执行了259.152s +而使用相同的代码时，第二个矩阵却执行了259.152s ` Random r = new Random(); for (int i = 0; i < 1000; i++) { @@ -33,22 +33,22 @@ for (int i = 0; i < 1000; i++) { System.out.println(""); } -` -为什么两者的执行时间会有如此巨大的差距？ +` +为什么两者的执行时间会有如此巨大的差距？ --- -评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） -另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 +评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） +另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 -测试条件： -1.Netbeans 7.2，结果输出在IDE的控制台 -2.使用`System.nanoTime()`度量时间 +测试条件： +1.Netbeans 7.2，结果输出在IDE的控制台 +2.使用`System.nanoTime()`度量时间 -###回答 -纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)， -而'#'视为一个非单词字符(non-word character)。因此当输出到达行尾时，控制台会搜索一个空白符来换行，当遇到'#'时可以立即执行换行； -然而遇到'B'时，控制台必须继续搜索，因为后面可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 -但是，这仅仅是理论推测。 +###回答 +纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)， +而'#'视为一个非单词字符(non-word character)。因此当输出到达行尾时，控制台会搜索一个空白符来换行，当遇到'#'时可以立即执行换行； +然而遇到'B'时，控制台必须继续搜索，因为后面可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 +但是，这仅仅是理论推测。 **译者注：** From 0fd17c73a075270f85650dd691eb6c95fb67a070 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 21:50:45 +0800 Subject: [PATCH 03/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- contents/why-is-printing-b-dramatically-slower-than-printing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 1f6a874..1129e29 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -33,7 +33,7 @@ for (int i = 0; i < 1000; i++) { System.out.println(""); } -` +` 为什么两者的执行时间会有如此巨大的差距？ --- 评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） From 7cc0b6dfd50014e83d7cabe310916130fbb345c0 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 21:52:25 +0800 Subject: [PATCH 04/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- contents/why-is-printing-b-dramatically-slower-than-printing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 1129e29..0760afa 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -1,4 +1,4 @@ -##为什么打印B要比打印#慢很多？ +##为什么打印B要比打印#慢很多？ ###问题 我生成了两个大小为 1000 * 1000 的矩阵 From f43f9c3936aa60887840b85cf43536517677e1b7 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 21:56:50 +0800 Subject: [PATCH 05/21] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 代码块的格式修改 --- ...why-is-printing-b-dramatically-slower-than-printing.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 0760afa..05e3537 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -5,7 +5,7 @@ 第一个矩阵：O和# 第二个矩阵：O和B 使用一下代码，第一个矩阵仅用时8.25s就完成了： -` +```java Random r = new Random(); for (int i = 0; i < 1000; i++) { for (int j = 0; j < 1000; j++) { @@ -18,9 +18,9 @@ for (int i = 0; i < 1000; i++) { System.out.println(""); } -` +```` 而使用相同的代码时，第二个矩阵却执行了259.152s -` +````java Random r = new Random(); for (int i = 0; i < 1000; i++) { for (int j = 0; j < 1000; j++) { @@ -33,7 +33,7 @@ for (int i = 0; i < 1000; i++) { System.out.println(""); } -` +```` 为什么两者的执行时间会有如此巨大的差距？ --- 评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） From 57fddc5ce856bbc360ed1111a77f9837418c2fce Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:02:47 +0800 Subject: [PATCH 06/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- .../why-is-printing-b-dramatically-slower-than-printing.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 05e3537..a7f51bf 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -36,12 +36,12 @@ for (int i = 0; i < 1000; i++) { ```` 为什么两者的执行时间会有如此巨大的差距？ --- -评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） +评论中一些人建议仅执行```System.out.print("#");`以及`System.out.print("B");```，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） 另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 测试条件： 1.Netbeans 7.2，结果输出在IDE的控制台 -2.使用`System.nanoTime()`度量时间 +2.使用```System.nanoTime()```度量时间 ###回答 From 1c81fb9d94d220c917a0da5a177f1bde281adb3b Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:03:23 +0800 Subject: [PATCH 07/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- contents/why-is-printing-b-dramatically-slower-than-printing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index a7f51bf..9df8ba2 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -36,7 +36,7 @@ for (int i = 0; i < 1000; i++) { ```` 为什么两者的执行时间会有如此巨大的差距？ --- -评论中一些人建议仅执行```System.out.print("#");`以及`System.out.print("B");```，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） +评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） 另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 测试条件： From 1032374b6168a6b247131f93141a0c25c6328840 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:04:29 +0800 Subject: [PATCH 08/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- contents/why-is-printing-b-dramatically-slower-than-printing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 9df8ba2..e090b57 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -35,7 +35,7 @@ for (int i = 0; i < 1000; i++) { } ```` 为什么两者的执行时间会有如此巨大的差距？ ---- +- - - 评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） 另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 From 0b430d4e7343dd2c690460d08e597e757411f4fa Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:05:59 +0800 Subject: [PATCH 09/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- ...why-is-printing-b-dramatically-slower-than-printing.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index e090b57..8164987 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -40,8 +40,8 @@ for (int i = 0; i < 1000; i++) { 另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 测试条件： -1.Netbeans 7.2，结果输出在IDE的控制台 -2.使用```System.nanoTime()```度量时间 +- Netbeans 7.2，结果输出在IDE的控制台 +- 使用`System.nanoTime()`度量时间 ###回答 @@ -55,8 +55,8 @@ for (int i = 0; i < 1000; i++) { 对于"word-wrapping"和"character-wrapping"，我的理解是，换行时不在一个单词内部分割，例如需要在 charac-ter 中的-处换行，"word-wrapping"会将 character 全部移到下一行， 而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 "word-wrapping" -`******* +`******* character` "character-wrapping" -`*******charac +`*******charac ter` From e9aa0d7a4e7af2cf493306f5b1dd1ab42afed376 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:09:48 +0800 Subject: [PATCH 10/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- ...s-printing-b-dramatically-slower-than-printing.md | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 8164987..b7092b7 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -55,8 +55,12 @@ for (int i = 0; i < 1000; i++) { 对于"word-wrapping"和"character-wrapping"，我的理解是，换行时不在一个单词内部分割，例如需要在 charac-ter 中的-处换行，"word-wrapping"会将 character 全部移到下一行， 而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 "word-wrapping" -`******* -character` +``` +******* +character +``` "character-wrapping" -`*******charac -ter` +``` +*******charac +ter +``` From efba4d073849d22e03c2279c3c1996bd31e4753e Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:12:09 +0800 Subject: [PATCH 11/21] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=E5=92=8C?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../why-is-printing-b-dramatically-slower-than-printing.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index b7092b7..a7c9d8c 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -4,7 +4,7 @@ 我生成了两个大小为 1000 * 1000 的矩阵 第一个矩阵：O和# 第二个矩阵：O和B -使用一下代码，第一个矩阵仅用时8.25s就完成了： +使用以下代码，第一个矩阵仅用时8.25s就完成了： ```java Random r = new Random(); for (int i = 0; i < 1000; i++) { @@ -45,9 +45,7 @@ for (int i = 0; i < 1000; i++) { ###回答 -纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)， -而'#'视为一个非单词字符(non-word character)。因此当输出到达行尾时，控制台会搜索一个空白符来换行，当遇到'#'时可以立即执行换行； -然而遇到'B'时，控制台必须继续搜索，因为后面可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 +纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)，而'#'视为一个非单词字符(non-wordcharacter)。因此当输出到达行尾时，控制台会搜索一个空白符来换行，当遇到'#'时可以立即执行换行；然而遇到'B'时，控制台必须继续搜索，因为后面可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 但是，这仅仅是理论推测。 From 0ca6523d9273a649ea1d70ec58549ae0568bf5ad Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:13:18 +0800 Subject: [PATCH 12/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- .../why-is-printing-b-dramatically-slower-than-printing.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index a7c9d8c..5621e9b 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -50,8 +50,7 @@ for (int i = 0; i < 1000; i++) { **译者注：** -对于"word-wrapping"和"character-wrapping"，我的理解是，换行时不在一个单词内部分割，例如需要在 charac-ter 中的-处换行，"word-wrapping"会将 character 全部移到下一行， -而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 +对于"word-wrapping"和"character-wrapping"，我的理解是，换行时不在一个单词内部分割，例如需要在 charac-ter 中的-处换行，"word-wrapping"会将 character 全部移到下一行，而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 "word-wrapping" ``` ******* From cab2daafe28228e66be7569e4067887032bf8616 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:15:03 +0800 Subject: [PATCH 13/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- contents/why-is-printing-b-dramatically-slower-than-printing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 5621e9b..11b05f2 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -50,7 +50,7 @@ for (int i = 0; i < 1000; i++) { **译者注：** -对于"word-wrapping"和"character-wrapping"，我的理解是，换行时不在一个单词内部分割，例如需要在 charac-ter 中的-处换行，"word-wrapping"会将 character 全部移到下一行，而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 +对于"word-wrapping"和"character-wrapping"，我的理解是，它们的区别在于换行时是否在一个单词内部分割，例如在 charac-ter 中的-处换行，"word-wrapping"会将character全部移到下一行，而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 "word-wrapping" ``` ******* From 67426d416d94769e42ba62452018d3c4dbcd3e1c Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:15:51 +0800 Subject: [PATCH 14/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- .../why-is-printing-b-dramatically-slower-than-printing.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 11b05f2..e77209d 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -50,13 +50,13 @@ for (int i = 0; i < 1000; i++) { **译者注：** -对于"word-wrapping"和"character-wrapping"，我的理解是，它们的区别在于换行时是否在一个单词内部分割，例如在 charac-ter 中的-处换行，"word-wrapping"会将character全部移到下一行，而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置 -"word-wrapping" +对于"word-wrapping"和"character-wrapping"，我的理解是，它们的区别在于换行时是否在一个单词内部分割，例如在 charac-ter 中的-处换行，"word-wrapping"会将character全部移到下一行，而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置。 +**word-wrapping** ``` ******* character ``` -"character-wrapping" +**character-wrapping** ``` *******charac ter From b6dadb347eebe0af83eeb5c6d9985cf4380e829b Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:27:28 +0800 Subject: [PATCH 15/21] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E7=94=A8=E8=AF=8D=E4=B8=8D=E5=BD=93=E7=9A=84=E5=9C=B0=E6=96=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../why-is-printing-b-dramatically-slower-than-printing.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index e77209d..7952752 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -36,19 +36,17 @@ for (int i = 0; i < 1000; i++) { ```` 为什么两者的执行时间会有如此巨大的差距？ - - - -评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`，前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） +评论中一些人建议仅执行`System.out.print("#");`以及`System.out.print("B");`前者用时7.8871s，而后者仍然在打印（即花费时间过多--译者注） 另外有些人指出在他们那里工作正常（即两者花费时间差不错--译者注），我在[Ideone.com](http://ideone.com/)环境中运行两段代码，执行时间也差不多。 测试条件： - Netbeans 7.2，结果输出在IDE的控制台 - 使用`System.nanoTime()`度量时间 - ###回答 -纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)，而'#'视为一个非单词字符(non-wordcharacter)。因此当输出到达行尾时，控制台会搜索一个空白符来换行，当遇到'#'时可以立即执行换行；然而遇到'B'时，控制台必须继续搜索，因为后面可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 +纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)，而'#'视为一个非单词字符(non-wordcharacter)。因此当输出到达行尾时，控制台搜索一个位置用来换行，当遇到'#'时可以立即执行换行；然而遇到'B'时，控制台必须继续搜索，并且可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 但是，这仅仅是理论推测。 - **译者注：** 对于"word-wrapping"和"character-wrapping"，我的理解是，它们的区别在于换行时是否在一个单词内部分割，例如在 charac-ter 中的-处换行，"word-wrapping"会将character全部移到下一行，而"character-wrapping"则将ter移到下一行，而charac依旧在原来的位置。 **word-wrapping** From dc14925708e799fdb2241780f58a13b8a0c03658 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Mon, 4 Apr 2016 22:28:05 +0800 Subject: [PATCH 16/21] Update why-is-printing-b-dramatically-slower-than-printing.md --- contents/why-is-printing-b-dramatically-slower-than-printing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contents/why-is-printing-b-dramatically-slower-than-printing.md b/contents/why-is-printing-b-dramatically-slower-than-printing.md index 7952752..31ad0d5 100644 --- a/contents/why-is-printing-b-dramatically-slower-than-printing.md +++ b/contents/why-is-printing-b-dramatically-slower-than-printing.md @@ -44,7 +44,7 @@ for (int i = 0; i < 1000; i++) { - 使用`System.nanoTime()`度量时间 ###回答 -纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)，而'#'视为一个非单词字符(non-wordcharacter)。因此当输出到达行尾时，控制台搜索一个位置用来换行，当遇到'#'时可以立即执行换行；然而遇到'B'时，控制台必须继续搜索，并且可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 +纯推测：你正在使用的终端试图进行[“自动换行”(word-wrapping)](http://en.wikipedia.org/wiki/Word_wrap)，而不是“字符换行”(character-wrapping)，并且将'B'视为一个单词字符(word character)，而'#'视为一个非单词字符(non-word character)。因此当输出到达行尾时，控制台搜索一个位置用来换行，当遇到'#'时可以立即执行换行；然而遇到'B'时，控制台必须继续搜索，并且可能有更多的字符需要换行（这个操作在一些控制台上可能花销很大，例如，输出退格，然后输出空白字符来覆盖那些需要被换行的字符）。 但是，这仅仅是理论推测。 **译者注：** From e4e292d33ad5ef9600b216bb115126cb65d7500c Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Sat, 1 Oct 2016 21:35:00 +0800 Subject: [PATCH 17/21] Setting multiple jars in java classpath MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 添加问题Setting multiple jars in java classpath的翻译 --- ...setting-multiple-jars-in-java-classpath.md | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 contents/setting-multiple-jars-in-java-classpath.md diff --git a/contents/setting-multiple-jars-in-java-classpath.md b/contents/setting-multiple-jars-in-java-classpath.md new file mode 100644 index 0000000..9200ff8 --- /dev/null +++ b/contents/setting-multiple-jars-in-java-classpath.md @@ -0,0 +1,36 @@ +##如何在classpath中设置多个jar包？ + +###问题 +是否有一个方法可以在classpath选项中包含一个文件夹（目录）下的所有jar包？ +我尝试运行`java -classpath lib/*.jar:. my.package.Program`，但是无法找到相应的类文件，可是这些类文件确实存在于命令中的jar包中。我是否需要在classpath中分别指定所有的jar包？ + +###回答 +在使用Java6或者以上版本时，classpath选项可以支持通配符(wildcards)。使用方法如下： +* 使用直接引用(`"`) +* 使用 `*` 而不是 `*.jar` + +**Windows平台** +`java -cp "Test.jar;lib/*" my.package.MainClass` + +**Unix平台** +`java -cp "Test.jar:lib/*" my.package.MainClass` + +Unix平台与Windows平台基本一样，除了使用冒号 `:` 替代分号 `;` 之外。如果你不能使用通配符，也可以使用`bash`完成上述功能，命令如下（其中lib是一个包含所有jar包的目录）： +`java -cp $(echo lib/*.jar | tr ' ' ':')` + +注意事项：classpath选项与-jar选项并不能兼容。可以查看：[Execute jar file with multiple classpath libraries from command prompt](http://stackoverflow.com/questions/13018100/execute-jar-file-with-multiple-classpath-libraries-from-command-prompt) + +**对于通配符的理解** +来自[Classpath](http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html)文档： + +类路径可以包含一个基本文件名通配符`*`，其等价于指定一个特定目录下的所有以.jar或.JAR为后缀的文件的列表。例如，一个类路径的条目为`foo/*`，其指定了foo目录下的所有jar文件。一个仅仅包含`*`的classpath条目(entry)指定了当前目录下的所有jar包。 + +一个包含了`*`的classpath条目不能匹配特定目录下的class文件。为了既能匹配foo目录下的类文件，也能匹配jar包，可以使用`foo;foo/*`或`foo/*;foo`。对于前者而言，类文件和资源选择的顺序先是foo目录下的类文件和资源，之后才是jar包；而后者则正好相反。 + +通配符并不能递归地搜索子目录下的jar包。例如，`foo/*`只找`foo`目录下的jar包，而不会寻找`foo/bar`，`foo/baz`等目录下的jar包。 + +一个目录中的jar包枚举顺序并不固定，这不仅和平台有关，甚至可能会在同一个机器上因为时间不同而表现不同。一个结构良好（well-constructed）的应用不应该依赖于某个特定的顺序。如果特定顺序是不可避免的时候，就需要在classpath中显示枚举所有的jar包了。 + +在类加载进程中，通配符的扩展在早期完成，优先于程序main函数的调用，而不是在其后。每个包含通配符的类路径都被替换为所在目录下所有jar包的序列。例如，如果目录`foo`包含`a.jar`，`b.jar`以及`c.jar`，因此类路径`foo/*`被扩展为`foo/a.jar;foo/b.jar;foo/c.jar`，并且以上字符串被作为系统属性`java.class.path`的值。 + +环境变量`CLASSPATH`与命令行选项-classpath或者-cp并没有什么不同。也就是说，通配符既可以应用于命令行`-classpath/-cp`选项中，也可以应用于环境变量`CLASSPATH`中。 \ No newline at end of file From 5241878f3005b2d394aa1d6b8e94e8269d14e2b3 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Sun, 2 Oct 2016 09:58:58 +0800 Subject: [PATCH 18/21] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- contents/setting-multiple-jars-in-java-classpath.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/contents/setting-multiple-jars-in-java-classpath.md b/contents/setting-multiple-jars-in-java-classpath.md index 9200ff8..6549e70 100644 --- a/contents/setting-multiple-jars-in-java-classpath.md +++ b/contents/setting-multiple-jars-in-java-classpath.md @@ -10,9 +10,11 @@ * 使用 `*` 而不是 `*.jar` **Windows平台** + `java -cp "Test.jar;lib/*" my.package.MainClass` **Unix平台** + `java -cp "Test.jar:lib/*" my.package.MainClass` Unix平台与Windows平台基本一样，除了使用冒号 `:` 替代分号 `;` 之外。如果你不能使用通配符，也可以使用`bash`完成上述功能，命令如下（其中lib是一个包含所有jar包的目录）： From 7829a0d8878bac418a9a257aba54ceb1c8d45a94 Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Tue, 4 Oct 2016 17:00:34 +0800 Subject: [PATCH 19/21] how-can-i-generate-an-md5-hash MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 添加问题how-can-i-generate-an-md5-hash的翻译 --- contents/how-can-i-generate-an-md5-hash.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 contents/how-can-i-generate-an-md5-hash.md diff --git a/contents/how-can-i-generate-an-md5-hash.md b/contents/how-can-i-generate-an-md5-hash.md new file mode 100644 index 0000000..453f6c3 --- /dev/null +++ b/contents/how-can-i-generate-an-md5-hash.md @@ -0,0 +1,18 @@ + + + + + + + + +```java +import java.security.*; + +... + +byte[] bytesOfMessage = yourString.getBytes("UTF-8"); +MessageDigest md = MessageDigest.getInstance("MD5"); +byte[] digest = md.digest(bytesOfMessage); +``` + From 01c7578d0c1350bc9cff299302cf1335e5d2d68e Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Tue, 4 Oct 2016 17:33:41 +0800 Subject: [PATCH 20/21] =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- contents/how-can-i-generate-an-md5-hash.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/contents/how-can-i-generate-an-md5-hash.md b/contents/how-can-i-generate-an-md5-hash.md index 453f6c3..8347dc9 100644 --- a/contents/how-can-i-generate-an-md5-hash.md +++ b/contents/how-can-i-generate-an-md5-hash.md @@ -1,10 +1,19 @@ +##如何生成MD5哈希码？ +###问题 +在Java中是否有方法可以生成一个字符串的哈希码？ +###回答 +**被采纳答案** +可以使用`java.security.MessageDigest`。调用`getInstance("MD5")`来获得一个MD5消息摘要实例(message digest)，然后使用该实例得到MD5哈希码。 +**最高票答案** +`MessageDigest`类可以为你提供一个MD5摘要实例。 +在处理字符串和加密类时，一定要指定字节表示的编码方式。如果你只是使用`string.getBytes()`，那字节的编码方式与平台相关，且并不是多有的平台的默认方式都是一致的。 ```java import java.security.*; @@ -16,3 +25,4 @@ MessageDigest md = MessageDigest.getInstance("MD5"); byte[] digest = md.digest(bytesOfMessage); ``` +如果你有大量的数据需要处理，可以查看`update(byte[])`方法，该方法可以被重复调用。然后再调用`digest()`方法来包含md5哈希码。 \ No newline at end of file From 58229b7829557b85b7ba3c2395f100f6b79027db Mon Sep 17 00:00:00 2001 From: Zhao Lei Date: Tue, 4 Oct 2016 17:46:00 +0800 Subject: [PATCH 21/21] =?UTF-8?q?Revert=20"=E6=A0=BC=E5=BC=8F=E4=BF=AE?= =?UTF-8?q?=E6=94=B9"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 01c7578d0c1350bc9cff299302cf1335e5d2d68e. --- contents/how-can-i-generate-an-md5-hash.md | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/contents/how-can-i-generate-an-md5-hash.md b/contents/how-can-i-generate-an-md5-hash.md index 8347dc9..453f6c3 100644 --- a/contents/how-can-i-generate-an-md5-hash.md +++ b/contents/how-can-i-generate-an-md5-hash.md @@ -1,19 +1,10 @@ -##如何生成MD5哈希码？ -###问题 -在Java中是否有方法可以生成一个字符串的哈希码？ -###回答 -**被采纳答案** -可以使用`java.security.MessageDigest`。调用`getInstance("MD5")`来获得一个MD5消息摘要实例(message digest)，然后使用该实例得到MD5哈希码。 -**最高票答案** -`MessageDigest`类可以为你提供一个MD5摘要实例。 -在处理字符串和加密类时，一定要指定字节表示的编码方式。如果你只是使用`string.getBytes()`，那字节的编码方式与平台相关，且并不是多有的平台的默认方式都是一致的。 ```java import java.security.*; @@ -25,4 +16,3 @@ MessageDigest md = MessageDigest.getInstance("MD5"); byte[] digest = md.digest(bytesOfMessage); ``` -如果你有大量的数据需要处理，可以查看`update(byte[])`方法，该方法可以被重复调用。然后再调用`digest()`方法来包含md5哈希码。 \ No newline at end of file