diff --git a/src/libstd/rt/io/buffered.rs b/src/libstd/rt/io/buffered.rs
index fc6d43f551aa2..8afb7183d77b0 100644
--- a/src/libstd/rt/io/buffered.rs
+++ b/src/libstd/rt/io/buffered.rs
@@ -73,9 +73,17 @@ pub struct BufferedReader<R> {
 impl<R: Reader> BufferedReader<R> {
     /// Creates a new `BufferedReader` with with the specified buffer capacity
     pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
+        // It's *much* faster to create an uninitialized buffer than it is to
+        // fill everything in with 0. This buffer is entirely an implementation
+        // detail and is never exposed, so we're safe to not initialize
+        // everything up-front. This allows creation of BufferedReader instances
+        // to be very cheap (large mallocs are not nearly as expensive as large
+        // callocs).
+        let mut buf = vec::with_capacity(cap);
+        unsafe { vec::raw::set_len(&mut buf, cap); }
         BufferedReader {
             inner: inner,
-            buf: vec::from_elem(cap, 0u8),
+            buf: buf,
             pos: 0,
             cap: 0
         }
@@ -183,9 +191,12 @@ pub struct BufferedWriter<W> {
 impl<W: Writer> BufferedWriter<W> {
     /// Creates a new `BufferedWriter` with with the specified buffer capacity
     pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
+        // See comments in BufferedReader for why this uses unsafe code.
+        let mut buf = vec::with_capacity(cap);
+        unsafe { vec::raw::set_len(&mut buf, cap); }
         BufferedWriter {
             inner: inner,
-            buf: vec::from_elem(cap, 0u8),
+            buf: buf,
             pos: 0
         }
     }