Possible Duplicate: Read/convert an InputStream to a String I'm trying to append data from a InputStream object to a string as follows: byte[] buffer = new byte[8192]; InputStream stdout; String s = ""; while(IsMoreInputDataAvailable()) { int length = this.stdout.read(buffer); s += new String(this.buffer, 0, length, "ASCII"); Is there an easier way of doing this without us
可能重复： 读取/转换InputStream为字符串 我试图将InputStream对象的数据附加到一个字符串，如下所示： byte[] buffer = new byte[8192]; InputStream stdout; String s = ""; while(IsMoreInputDataAvailable()) { int length = this.stdout.read(buffer); s += new String(this.buffer, 0, length, "ASCII"); 有没有更简单的方法来做到这一点，而不使用Apache或这样的库？ 从InputStream读取字符数据的
This question already has an answer here: Read/convert an InputStream to a String 56 answers What about Apache Commons IOUtils.readLines()? Get the contents of an InputStream as a list of Strings, one entry per line, using the default character encoding of the platform. Or if you just want a single string use IOUtiles.toString(). Get the contents of an InputStream as a String using the
这个问题在这里已经有了答案： 将InputStream读取/转换为字符串56个答案 那么Apache Commons IOUtils.readLines（）呢？ 获取InputStream的内容作为字符串列表，每行一个条目，使用平台的默认字符编码。 或者，如果您只想使用一个字符串，请使用IOUtiles.toString（）。 使用平台的默认字符编码将InputStream的内容作为字符串获取。 [更新]根据关于这个在J2ME上可用的评论，我承认我错过了这个条件，但是IOUtils源代
Possible Duplicates: How do I convert an InputStream to a String in Java? In Java how do a read an input stream in to a string? I have an InputSteam and need to simply get a single simple String with the complete contents. How is this done in Java? 这是对Gopi的答案的一种修改，它没有行结束问题，并且更有效，因为它不需要每行都有临时的String对象，并且避免了BufferedReader中的冗余复制和readLin
可能重复： 如何将InputStream转换为Java中的字符串？ 在Java中，如何将输入流读入字符串？ 我有一个InputSteam ，只需要获得一个简单的String和完整的内容。 这在Java中如何完成？ 这是对Gopi的答案的一种修改，它没有行结束问题，并且更有效，因为它不需要每行都有临时的String对象，并且避免了BufferedReader中的冗余复制和readLine（）中的额外工作。 public static String convertStreamToString( InputStream is,
This question already has an answer here: Read/convert an InputStream to a String 56 answers 取决于您所熟悉的许可证，这是雅加达共享IO库的一个班轮。 Do specify the character encoding. Do not waste code, introduce bugs, and slow execution with a BufferedReader . Here is an example. You could parameterize it with a buffer size, encoding, etc. static String readString(InputStream is) throws
这个问题在这里已经有了答案： 将InputStream读取/转换为字符串56个答案 取决于您所熟悉的许可证，这是雅加达共享IO库的一个班轮。 请指定字符编码。 不要浪费代码，引入错误，并用BufferedReader缓慢执行。 这是一个例子。 你可以用缓冲区大小，编码等参数化它。 static String readString(InputStream is) throws IOException { char[] buf = new char[2048]; Reader r = new InputStreamReader(is, "UTF-8"); S
Possible Duplicate: In Java how do a read/convert an InputStream in to a string? Hi I want to put this BufferedInputStream into my string how can I do this? BufferedInputStream in = new BufferedInputStream(sktClient.getInputStream() ); String a= in.read(); BufferedInputStream in = new BufferedInputStream(sktClient.getInputStream()); byte[] contents = new byte[1024]; int bytesRead = 0; Strin
可能重复： 在Java中，如何将InputStream读取/转换为字符串？ 您好，我想把这个BufferedInputStream放入我的字符串中，我该怎么做？ BufferedInputStream in = new BufferedInputStream(sktClient.getInputStream() ); String a= in.read(); BufferedInputStream in = new BufferedInputStream(sktClient.getInputStream()); byte[] contents = new byte[1024]; int bytesRead = 0; String strFileContents; while((bytesR
So with regex in java, I want to write a regex that will match if and only if the pattern is not preceded by certain characters. For example: String s = "foobar barbar beachbar crowbar bar "; I want to match if bar is not preceded by foo. So output would be: barbar beachbar crowbar bar I know this is probably a very simple question. I am trying to learn regex, but in the meantime I need so
所以用java中的正则表达式，我想写一个匹配的正则表达式，当且仅当该模式没有被特定字符前缀时。 例如： String s = "foobar barbar beachbar crowbar bar "; 如果bar没有被foo前缀，我想匹配。 所以输出将是： barbar beachbar crowbar bar 我知道这可能是一个非常简单的问题。 我正在尝试学习正则表达式，但是现在我需要一些东西来工作。 你想要像这样使用negative lookbehind ： w*(?<!foo)bar 其中(?<!x)意
I was going through the Java Tutorial on Quantifiers. There is a difference mentioned among Differences Among Greedy, Reluctant, and Possessive Quantifiers. I am not able to understand what's the difference exactly. Explanation provided as follows: Enter your regex: .*foo // greedy quantifier Enter input string to search: xfooxxxxxxfoo I found the text "xfooxxxxxxfoo" starting at inde
我正在通过量词的Java教程。 在贪心，不情愿和拥有量词的差异中有所不同。 我无法理解到底有什么区别。 说明如下： Enter your regex: .*foo // greedy quantifier Enter input string to search: xfooxxxxxxfoo I found the text "xfooxxxxxxfoo" starting at index 0 and ending at index 13. Enter your regex: .*?foo // reluctant quantifier Enter input string to search: xfooxxxxxxfoo I found the text "xfoo
This question already has an answer here: My regex is matching too much. How do I make it stop? 4 answers {1} in regex is redundant since any element without specified quantifier needs to be found once. Also making it reluctant doesn't make sense since it doesn't describe range of possible repetitions (like {min,max} where adding ? would tell regex engine to make number of repetiti
这个问题在这里已经有了答案： 我的正则表达式匹配得太多了。 我如何让它停止？ 4个答案 在正则表达式中{1}是多余的，因为任何没有指定量词的元素都需要被找到一次。 也使它不情愿没有意义，因为它没有描述可能重复的范围（如{min,max} ，其中添加?会告诉regex引擎使该范围内的重复次数尽可能接近min ）。 这里{n}描述了精确的重复次数，所以min = max = n 。 现在，您应该可以通过使.+ （括号内的内容）不愿意来解决
There are examples and descriptions of regex quantifiers in Java Tutorial. Greedy - eats full string then back off by one character and try again Regex: .*foo // greedy String to search: xfooxxxxxxfoo Found "xfooxxxxxxfoo" Reluctant - start at the beginning then eat one character at a time Regex: .*?foo // reluctant quantifier String to search: xfooxxxxxxfoo Found "xfoo", "xxxxxxfoo" Pos
在Java Tutorial中有正则表达式量词的例子和描述。 贪婪 - 吃完整的字符串，然后退出一个字符，然后再试一次 Regex: .*foo // greedy String to search: xfooxxxxxxfoo Found "xfooxxxxxxfoo" 不情愿 - 从一开始就开始，然后一次吃一个角色 Regex: .*?foo // reluctant quantifier String to search: xfooxxxxxxfoo Found "xfoo", "xxxxxxfoo" 拥有 - 吃整个字符串尝试一次匹配 Regex: .*+foo // possessive quantifier
I was practicing regular expressions of java in the tutorial of Oracle. In order to understand greedy, reluctant, and possessive quantifiers better, I created some examples. My question is how those quantifiers work while capturing groups. I didn't understand using quantifiers in that manner, for example, reluctant quantifier looks as if it doesn't work at all. Also, I searched a lot
我在Oracle教程中练习java的正则表达式。 为了更好地理解贪婪，不情愿和占有量词，我创造了一些例子。 我的问题是这些量词在捕捉群体时如何工作。 我不明白以这种方式使用量词，例如，不情愿的量词看起来好像根本不起作用。 此外，我在互联网上搜索了很多，只看到像（。*？）这样的表达式。 为什么人们通常用这种语法使用量词，而不是像“（.foo）??”？ 这是一个不情愿的例子： 输入你的正则表达式：（.foo）?? 输入要