Don't tailor from-memory standard library questions to bits of code that almost nobody ever has to use.
For example:
Whenever I'm dealing with a data processing pipeline I tend to design things as if they would be used from a unix command line. I tell the team to make their classes etc as if they would be wrapped with a simple chunk of code to parse a text stream then serialize to it later. During the course of testing, I almost always will then write those tools to allow simple command line pipes to push test data around. It helps prevent reliance on certain toolsets and certainly helps stop us from conflating bugs in our code with bugs or operator error about a pipeline framework. Later we can go back and more closely integrate with the chosen operating environment, if performance demands it. On the other hand going from a situation where code is written to the environment and migrating to another environment can be very daunting, difficult and error prone.
So seriously? You almost never need to read & write to streams?
Again, most of us write real apps, not command line utilities.
Doesn't matter. For this problem it is just a conveniently available InputStream. How often do you read from an InputStream? I'd hope the answer to that isn't 0.
> I also programmed in Java for nearly a decade in the late nineties till about 2004 and have never used System.in for anything.
Okay, then change the problem to implementing this interface:
public interface Copier {
public void copy(java.io.InputStream in, java.io.PrintStream out);
}
That doesn't change the problem.Your interface does not change the problem, but it does phrase the problem in a more familiar way and would have been much more easy for me to respond to (in my Java hey day that is).
It's an online quiz. You don't have to do it from memory.
Java didn't grow up in the world of unix where scripts that read from stdin and write to stdout get chained to produce pipelines. It grew up in the world of long-running stand-alone applications that communicate over sockets (like web applications). Java, because of the virtual machine, has a particularly slow start-up time and would be a poor choice for implementing mini pipeline components like this anyway.
import java.io.*;
public static void main(String[] args) {
byte[] buf = new byte[4096];
while (true) {
int numRead = System.in.read(buf);
if (numRead < 0) {
// hit EOF, terminate
System.out.flush();
System.exit(0);
}
System.out.write(buf,0,numRead);
}
} public class SimpleJavaTest
{
public interface RunnableEx
{
// can't use Callable<Void> because that run method needs to return a value
public abstract void run() throws Exception;
}
public static void main(String[] args)
{
// write standard in to standard out:
uncheck( () -> {
int c;
while( (c = System.in.read()) > -1)
{
System.out.write(c);
}
} ).run();
}
public static Runnable uncheck(RunnableEx r)
{
return () -> {
try
{
r.run();
}
catch(Exception e)
{
throw new RuntimeException(e.getMessage(), e);
}
};
}
}... And here's a fine example of Java culture.
2 lines do stuff, everything else is fluff, and it is considered prettier.
BTW: I did not run this specific code, but dropping the buffer is likely to make this code take much, much more CPU (unless HotSpot is much better these days than it was in 2010 when I last used it). That's another pillar of Java culture - care not about performance.
Disclaimer: I didn't test this, and any mention of performance requires testing, rather than reasoning. I don't have a Java compiler handy anymore, or I would test it.
e.g. if the File implementation had an internal buffer (C stdio's "FILE " does), and the read from that* buffer was inlined (from my past experience up to date as of early 2011, HotSpot doesn't, but LuaJIT does), it might not make any difference.
Seriously, LuaJIT does things I've never thought I'd see a compiler (JIT or AOT) for any language (dynamic or statically typed) do. I used to reply to "sufficiently smart compiler" with "one hasn't appeared yet, despite at least 3 decades of waiting". But LuaJIT has appeared.
Yeah, but you've probably done a read and write independently. This is just about joining the two together.
> There's a method in one of the apache commons libraries for that.
Yup, and that's great to use that, and you'll no doubt end up with more efficient code most of the time if you do. But... you still should be able to write correct code for reading bytes from one stream, writing to another, without losing data in between.
With access to Google and the library documentation sure, but I don't use those APIs often enough to be worth keeping in memory.
Why the heck would you need Google
> and the library documentation
It's an online quiz.
> sure, but I don't use those APIs often enough to be worth keeping in memory.
You don't worry about it, but it tends to accumulate in one's mind anyway.
Here's the thing though. People are posting solutions on HN... and getting it wrong.
I guess I've been stuck in webapps and NoSQL libraries for a while now.
The methods are the same with a buffered input reader.
> I've written a command line in Java that reads commands, runs native commands, streams output to the console and even that doesn't need to read stdio as a stream.
So, the thing that you are struggling with is how to get to System.in? But no problem doing System.out?
That's not even what the various code samples that have been posted have failed.
> It's not that Java can't do that, it's that there are better idioms for most problems.
Java's actually very good at doing IO efficiently, and as has been demonstrated, the code for this is quite simple. Sure, you wouldn't implement "cat" in Java, but you would read and write to sockets & files with it, which provides all the knowledge one might need to figure out how to solve this. As has been pointed out, the Apache Commons libraries make it so this is a two line program with no branching or looping. That's about as simple as it gets.
Yeah, but there is nothing different from this and having to copy data from an input stream to an output stream. If you can't remember how to do that, it kind of raises the question of what you were doing in Java.
Not knowing if you need to buffer is actually fine in my book. That's an optimization thing. Not knowing how to make the code correct though...
[1] http://en.wikipedia.org/wiki/Pipeline_%28Unix%29#Pipelines_i...
Off the top of my head, right now, in this text box, without google, I can't write the code to copy standard input to standard output.
System.out.println(System.in)? That's wrong. You need some kind of InputReader, or BufferedInputReader, or Buffered...something. I think System.in is an InputStream, so presumably I need to do new InputReader(System.in)? Or BufferedInputReader? Should I buffer the output?
Ok, let's do some API googling (ie, not StackOverflow).
So I was... pretty wrong. I think what you want is:
public class CopyInput { public static void main(String[] args) { while (true) System.out.write(System.in.read); } }
I haven't tried to run this though.
In my defence, I have never, in all my years of working, had to ever read standard input, let alone write it out again.