In InputStreams, `read()` calls are said to be &quot;blocking&quot; method calls. That means that if no data is available at the time of the method call, the method will wait for data to be made available.

The `available()` method tells you how many bytes can be read until the `read()` call will block the execution flow of your program. On most of the input streams, all call to `read()` are blocking, that&#39;s why available returns 0 by default.

However, on some streams (such as `BufferedInputStream`, that have an internal buffer), some bytes are read and kept in memory, so you can read them without blocking the program flow. In this case, the `available()` method tells you how many bytes are kept in the buffer.

Blocking doesn&#39;t relate to threading or synchronisation here. Instead it relates to blocking IO (see [this][1] for more info). If you issue a request to read, and the channel has none available, a blocking call will wait (or block) until data is available (or the channel is closed, throws an exception etc.)

So why use `available()` ? So you can determine how many bytes to read, or determine whether you&#39;re going to block.

Note that Java has non-blocking IO capabilities as well. See [here][2] for more details


  [1]: http://en.wikipedia.org/wiki/Asynchronous_I/O
  [2]: http://www.developer.com/java/article.php/3837316/Non-Blocking-IO-Made-Possible-in-Java.htm

I want to count the number of itemids in my array, can i get an example of how i would go about adding this to my code. code below;

    if (value != null &amp;&amp; !value.isEmpty()) {
        Set set = value.keySet();
        Object[] key = set.toArray();
        Arrays.sort(key);

        for (int i = 0; i &lt; key.length; i++) {
            ArrayList list = (ArrayList) value.get((String) key[i]);

            if (list != null &amp;&amp; !list.isEmpty()) {
                Iterator iter = list.iterator();
                double itemValue = 0;
                String itemId = &quot;&quot;;

                while (iter.hasNext()) {
                    Propertyunbuf p = (Propertyunbuf) iter.next();
                    if (p != null) {
                        itemValue = itemValue + p.getItemValue().doubleValue();
                        itemId = p.getItemId();
                    }

                    buf2.append(NL);
                    buf2.append(&quot;                  &quot; + itemId);

                }

                double amount = itemValue;
                totalAmount += amount;
            }
        }
    }


Count the number of items in my array list

I&#39;ve always preached to my developers that `SELECT *` is evil and should be avoided like the plague.

Are there any cases where it can be justified?

I&#39;m not talking about `COUNT(*)` - which most optimizers can figure out.

**Edit**

I&#39;m talking about production code.

And one great example I saw of this bad practice was a legacy asp application that used `select *` in a stored procedure, and used `ADO` to loop through the returned records, but got the columns by index. You can imagine what happened when a new field was added somewhere other than the end of the field list.

Can select * usage ever be justified?

What does `InputStream.available()` do in *Java*? I read the documentation, but I still cannot make it out.

The doc says:
&gt; Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream. The next caller might be the same thread or or another thread.
&gt;
&gt;The available method for class InputStream always returns 0.

What do they mean by *blocking*? Does it just mean a synchronized call?

And most of all, what is the purpose of the `available()` method?

What does InputStream.available() do in Java?

What does <code>InputStream.available()</code> do in Java? I read the documentation, but I still cannot make it out.
The doc says:
> Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream. The next caller might be the same thread or or another thread.
>
>The available method for class InputStream always returns 0.
What do they mean by blocking? Does it just mean a synchronized call?
And most of all, what is the purpose of the <code>available()</code> method?

    
    String lower = Name.toLowerCase();
    int a = Name.indexOf(&quot; &quot;,0);
    String first = lower.substring(0, a);
    String last = lower.substring(a+1);
    char f = first.charAt(0);
    char l = last.charAt(0);
    System.out.println(l);

how would i get the F and L variables converted to uppercase.

Converting a char to uppercase

I am working with Java. If I hit &lt;KBD&gt;Ctrl&lt;/KBD&gt;+&lt;KBD&gt;Shift&lt;/KBD&gt;+&lt;KBD&gt;F&lt;/KBD&gt; in Eclipse Helios, it will auto format my code. At a certain point, it wraps lines. I would like to increase the maximum line length. How can I do this?

Eclipse: Set maximum line length for auto formatting?

What is the simplest way to retrieve version number from maven&#39;s pom.xml in code, i.e., programatically?

Retrieve version from maven pom.xml in code

I need to sort an array of ints using a custom comparator, but Java&#39;s library doesn&#39;t provide a sort function for ints with comparators (comparators can be used only with objects). Is there any easy way to do this?

How to sort an array of ints using a custom comparator?

I asked this question to get to know how to increase the runtime call stack size in the JVM. I&#39;ve got an answer to this, and I&#39;ve also got many useful answers and comments relevant to how Java handles the situation where a large runtime stack is needed. I&#39;ve extended my question with the summary of the responses.

Originally I wanted to increase the JVM stack size so programs like runs without a `StackOverflowError`.

    public class TT {
      public static long fact(int n) {
        return n &lt; 2 ? 1 : n * fact(n - 1);
      }
      public static void main(String[] args) {
        System.out.println(fact(1 &lt;&lt; 15));
      }
    }

The corresponding configuration setting is the `java -Xss...` command-line flag with a large enough value. For the program `TT` above, it works like this with OpenJDK&#39;s JVM:

    $ javac TT.java
    $ java -Xss4m TT

One of the answers has also pointed out that the `-X...` flags are implementation dependent. I was using

    java version &quot;1.6.0_18&quot;
    OpenJDK Runtime Environment (IcedTea6 1.8.1) (6b18-1.8.1-0ubuntu1~8.04.3)
    OpenJDK 64-Bit Server VM (build 16.0-b13, mixed mode)

It is also possible to specify a large stack only for one thread (see in one of the answers how). This is recommended over `java -Xss...` to avoid wasting memory for threads that don&#39;t need it.

I was curious how large a stack the program above exactly needs, so I&#39;ve run it `n` increased:

   * -Xss4m can be enough for `fact(1 &lt;&lt; 15)`
   * -Xss5m can be enough for `fact(1 &lt;&lt; 17)`
   * -Xss7m can be enough for `fact(1 &lt;&lt; 18)`
   * -Xss9m can be enough for `fact(1 &lt;&lt; 19)`
   * -Xss18m can be enough for `fact(1 &lt;&lt; 20)`
   * -Xss35m can be enough for `fact(1 &lt;&lt; 21)`
   * -Xss68m can be enough for `fact(1 &lt;&lt; 22)`
   * -Xss129m can be enough for `fact(1 &lt;&lt; 23)`
   * -Xss258m can be enough for `fact(1 &lt;&lt; 24)`
   * -Xss515m can be enough for `fact(1 &lt;&lt; 25)`

From the numbers above it seems that Java is using about 16 bytes per stack frame for the function above, which is reasonable.

The enumeration above contains *can be enough* instead of *is enough*, because the stack requirement is not deterministic: running it multiple times with the same source file and the same `-Xss...` sometimes succeeds and sometimes yields a `StackOverflowError`. E.g. for 1 &lt;&lt; 20, `-Xss18m` was enough in 7 runs out of 10, and `-Xss19m` wasn&#39;t always enough either, but `-Xss20m` was enough (in all 100 runs out of 100). Does garbage collection, the JIT kicking in, or something else cause this nondeterministic behavior?

The stack trace printed at a `StackOverflowError` (and possibly at other exceptions as well) shows only the most recent 1024 elements of the runtime stack. An answer below demonstrates how to count the exact depth reached (which might be a lot larger than 1024).

Many people who responded has pointed out that it is a good and safe coding practice to consider alternative, less stack-hungry implementations of the same algorithm. In general, it is possible to convert to a set of recursive functions to iterative functions (using a e.g. `Stack` object, which gets populated on the heap instead of on the runtime stack). For this particular `fact` function, it is quite easy to convert it. My iterative version would look like:

    public class TTIterative {
      public static long fact(int n) {
        if (n &lt; 2) return 1;
        if (n &gt; 65) return 0;  // Enough powers of 2 in the product to make it (long)0.
        long f = 2;
        for (int i = 3; i &lt;= n; ++i) {
          f *= i;
        }
        return f;
      }
      public static void main(String[] args) {
        System.out.println(fact(1 &lt;&lt; 15));
      }
    }

FYI, as the iterative solution above shows it, the `fact` function cannot compute the exact factorial of numbers above 65 (actually, even above 20), because the Java built-in type `long` would overflow. Refactoring `fact` so it would return a `BigInteger` instead of `long` would yield exact results for large inputs as well.

How to increase the Java stack size?

1. What&#39;s the difference between:

- **Asynchronous**,
- **Non-Blocking**, and
- **Event-base** architectures?

2. Can something be both *asynchronous* and *non-blocking* (and *event-based*)?

3. What&#39;s most important in programming, to have something: asynchronous, non-blocking and/or event-base (or all 3)?

If you could provide examples, that would be great.

This question is being asked because I was reading this great [StackOverflow][1] article on a similar topic but it doesn&#39;t answer my questions above.

  [1]: https://stackoverflow.com/questions/2625493/asynchronous-vs-non-blocking

What&#39;s the difference between: Asynchronous, Non-Blocking, Event-Base architectures?

I searched the web on some technical details about blocking I/O and non blocking I/O and I found several people stating that non-blocking I/O would be faster than blocking I/O. For example in [this document][1].

If I use blocking I/O, then of course the thread that is currently blocked can&#39;t do anything else... Because it&#39;s blocked. But as soon as a thread starts being blocked, the OS can switch to another thread and not switch back until there is something to do for the blocked thread. So as long as there is another thread on the system that needs CPU and is not blocked, there should not be any more CPU idle time compared to an event based non-blocking approach, is there?

Besides reducing the time the CPU is idle I see one more option to increase the number of tasks a computer can perform in a given time frame: Reduce the overhead introduced by switching threads. But how can this be done? And is the overhead large enough to show measurable effects? Here is an idea on how I can picture it working:

 1. To load the contents of a file, an application delegates this task to an event-based i/o framework, passing a callback function along with a filename
 2. The event framework delegates to the operating system, which programs a DMA controller of the hard disk to write the file directly to memory
 3. The event framework allows further code to run.
 4. Upon completion of the disk-to-memory copy, the DMA controller causes an interrupt.
 5. The operating system&#39;s interrupt handler notifies the event-based i/o framework about the file being completely loaded into memory. How does it do that? Using a signal??
 6. The code that is currently run within the event i/o framework finishes.
 7. The event-based i/o framework checks its queue and sees the operating system&#39;s message from step 5 and executes the callback it got in step 1.

Is that how it works? If it does not, how does it work? That means that the event system can work without ever having the need to explicitly touch the stack (such as a real scheduler that would need to backup the stack and copy the stack of another thread into memory while switching threads)? How much time does this actually save? Is there more to it?

  [1]: http://code.danyork.com/2011/01/25/node-js-doctors-offices-and-fast-food-restaurants-understanding-event-driven-programming/

Is non-blocking I/O really faster than multi-threaded blocking I/O? How?

In iOS 5, `NSManagedObjectContext` has a couple of new methods, `performBlock:` and `performBlockAndWait:`. What are these methods actually used for? What do they replace in older versions? What kind of blocks are supposed to be passed to them? How do I decide which to use? If anyone has some examples of their use it would be great.

What is NSManagedObjectContext&#39;s performBlock: used for?

I&#39;m currently trying to learn nodejs and a small project I&#39;m working is writing an API to control some networked LED lights.

The microprocessor controlling the LEDs has a processing delay, and I need to space commands sent to the micro at least 100ms apart. In C# I&#39;m used to just calling Thread.Sleep(time), but I have not found a similar feature in node.

I have found several solutions using the setTimeout(...) function in node, however, this is asynchronous and does not block the thread ( which is what I need in this scenario).

Is anyone aware of a blocking sleep or delay function? Preferably something that does not just spin the CPU, and has an accuracy of +-10 ms?

How to create a sleep/delay in nodejs that is Blocking?

I have some questions about the usage of the close() method when using Java InputStreams.  From what I see and read from most developers, you should always explicitly call close() on an InputStream when it is no longer needed.  But, today I was looking into using a Java properties file, and every example I have found has something like this:

    Properties props = new Properties();
    try {
        props.load(new FileInputStream(&quot;message.properties&quot;));
        //omitted.
    } catch (Exception ex) {}

With the above example, there is no way to explicitly call close() because the InputStream is unreachable after it is used.  I have seen many similar uses of InputStreams even though it seems to contradict what most people say about explicitly closing.  I read through Oracle&#39;s JavaDocs and it does not mention if the Properties.load() method closes the InputStream.  I am wondering if this is generally acceptable or if it is preferred to do something more like the following:

    Properties props = new Properties();
    InputStream fis = new FileInputStream(&quot;message.properties&quot;);
    try {
        props.load(fis);
        //omitted.
    } catch (Exception ex) {
        //omitted.
    } finally {
        try {
            fis.close();
        } catch (IOException ioex) {
            //omitted.
        }
    }

Which way is better and/or more efficient?  Or does it really matter?

Closing Java InputStreams

[Apache Commons IO][1] has a nice convenience method [IOUtils.toString()][2] to read an `InputStream` to a String.

Since I am trying to move away from Apache Commons and to [Guava][3]: is there an equivalent in Guava? I looked at all classes in the `com.google.common.io` package and I couldn&#39;t find anything nearly as simple.

**Edit:** I understand and appreciate the issues with charsets. It just so happens that I know that all my sources are in ASCII (yes, ASCII, not ANSI etc.), so in this case, encoding is not an issue for me.


  [1]: http://commons.apache.org/io
  [2]: http://commons.apache.org/io/api-release/org/apache/commons/io/IOUtils.html#toString%28java.io.InputStream%29
  [3]: http://code.google.com/p/guava-libraries/

Guava equivalent for IOUtils.toString(InputStream)

I have a method which expects the one of the input variable to be of java.io.File type but what I get is only InputStream. Also, I cannot change the signature of the method.

How can I convert the InputStream into File type with out actually writing the file on to the filesystem?

How to convert InputStream to virtual File

I have a method that takes an InputStream and reads data from it. I would like to use this method with a ByteBuffer also. Is there a way to wrap a ByteBuffer so it can be accessed as a stream?

Wrapping a ByteBuffer with an InputStream

With Java:

I have a `byte[]` that represents a file.

How do I write this to a file (ie. `C:\myfile.pdf`)



I know it&#39;s done with InputStream, but I can&#39;t seem to work it out.

Content Type	Original Author	Original Content on Stackoverflow
Question	Albus Dumbledore	View Question on Stackoverflow
Solution 1 - Java	Vivien Barousse	View Answer on Stackoverflow
Solution 2 - Java	Brian Agnew	View Answer on Stackoverflow

What does InputStream.available() do in Java?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Can select * usage ever be justified?

Count the number of items in my array list

Attributions