Problema com buffer em leitura de variável

input.next();

BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in))

DataInputStream teclado = new DataInputStream(System.in);

String name = console.readLine("[Please Provide Your Name]: ");

import java.io.*;
import java.util.*;

/** Esta classe foi implementada no livro <b> Java Software Solutions: Foundations of Program Design </B>
de LEWIS, John e LOFTUS, W (2 ed., Adisson-Wesley, 2000). 
O objetivo dessa classe é facilitar a entrada/saída de valores via Console, sem a necessidade
de um conhecimento mais aprofundado da classes da API padrão do Java que definem essa funcionalidade.
@version 1.0
@author: 
 */ 

public class Console{
  //-----------------------------------------------------------------
  //  Prints the appropriate error message 
  //-----------------------------------------------------------------
  /** Imprime mensagem de erro */
  private static void error (String str){
   System.out.println (str);
  }

  //******************************************************************
  //               Tokenized Input Stream Section
  //******************************************************************

  private static String current_token = null;
  private static StringTokenizer reader;

  /** Esta variável in será utilizada para fazer os Inputs*/
  private static BufferedReader in = new BufferedReader 
                        (new InputStreamReader(System.in));

  //-----------------------------------------------------------------
  //  Gets the next input token assuming it may be on subsequent
  //  input lines.
  //-----------------------------------------------------------------
  /** Captura o próximo pedaço (token) assumindo que este deverá 
     estar nas linhas subsequentes de entrada */
  private static String getNextToken() {
   return getNextToken (true);
  }

  //-----------------------------------------------------------------
  //  Gets the next input token, which may already have been read.
  //-----------------------------------------------------------------
  /** Captura o próximo pedaço (token) que já foi lido */ 
  private static String getNextToken (boolean skip) {
   String token;

   if (current_token == null)
     token = getNextInputToken (skip);
   else
   {
     token = current_token;
     current_token = null;
   }
   return token;
  }

  //-----------------------------------------------------------------
  //  Gets the next token from the input, which may come from the
  //  current input line or a subsequent one. The parameter
  //  determines if subsequent lines are used.
  //-----------------------------------------------------------------
  /** Captura o próximo pedaço (token) de entrada, que deve vir da
     entrada na linha corrente ou subsequente. O Parâmetro determina
     se as linhas subsequentes serão utilizadas. */
  private static String getNextInputToken (boolean skip){
   final String delimiters = " \t\n\r\f";
   String token = null;

   try 
   {
     if (reader == null) 
      reader = new StringTokenizer(in.readLine(), delimiters, true);

     while (token == null || 
         ((delimiters.indexOf (token) >= 0) && skip))
     {
      while (!reader.hasMoreTokens()) 
        reader = new StringTokenizer(in.readLine(), delimiters,true);
      token = reader.nextToken();
     }
   }
   catch (Exception exception) 
   {
     token = null;
   }
   return token;
  }

  //-----------------------------------------------------------------
  //  Returns true if there are no more tokens to read on the
  //  current input line.
  //-----------------------------------------------------------------
  /** Retorna true se não existem mais pedaços (token) para
     serem lidos na linha corrente de entrada. */
  private static boolean endOfLine() {
   return !reader.hasMoreTokens();
  }

  //*****************************************************************
  //                      Reading Section  
  //*****************************************************************

  //-----------------------------------------------------------------
  //  Returns a boolean read from standard input.
  //-----------------------------------------------------------------

  /** Lê um valor do tipo primitivo boolean 
         @return retorna o valor booleano lido a partir da console
  */
  public static boolean readBoolean() {
   String token = getNextToken();
   boolean bool;
   try{
     if (token.equalsIgnoreCase("true"))
      bool = true;
     else if (token.equalsIgnoreCase("false")) 
        bool = false;
      else {
        error ("Error reading boolean data, please try again.");
        bool = readBoolean();
      }
   } catch (Exception exception){
     error ("Error reading boolean data, please try again.");
     bool = readBoolean();
   }
   return bool;
  }

  //-----------------------------------------------------------------
  //  Returns a character read from standard input.
  //-----------------------------------------------------------------

  /**Lê um valor do tipo primitivo char 
      @return retorna o valor caracter lido a partir da console
*/
  public static char readChar(){
   String token = getNextToken(false);
   char value;
   try {
     if (token.length() > 1)
      current_token = token.substring (1, token.length());
     else
      current_token = null;
     value = token.charAt (0);
   } catch (Exception exception) {
     error ("Error reading char data, please try again.");
     value = readChar();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns a byte read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo primitivo byte 
         @return retorna o valor byte lido a partir da console
  */
  public static byte readByte() 
  {
   String token = getNextToken();
   byte value;
   try {
     value = Byte.parseByte(token);
   } catch (Exception exception) {
     error ("Error reading byte data, please try again.");
     value = readByte();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns a short read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo primitivo short 
         @return retorna o valor short lido a partir da console
  */
  public static short readShort(){
   String token = getNextToken();
   short value;
   try {
     value = Short.parseShort(token);
   } catch (Exception exception) {
     error ("Error reading short data, please try again.");
     value = readShort();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns an integer read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo primitivo int 
         @return retorna o valor inteiro lido a partir da console
  */
  public static int readInt(){
   String token = getNextToken();
   int value;
   try 
   {
     value = Integer.parseInt(token);
   } 
   catch (Exception exception) 
   {
     error ("Error reading int data, please try again.");
     value = readInt();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns a long integer read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo primitivo long
         @return retorna o valor long lido a partir da console
 */
  public static long readLong(){
   String token = getNextToken();
   long value;
   try {
     value = Long.parseLong(token);
   } catch (Exception exception) {
     error ("Error reading long data, please try again.");
     value = readLong();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns a float read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo primitivo float 
         @return retorna o valor float lido a partir da console
*/
  public static float readFloat() 
  {
   String token = getNextToken();
   float value;
   try {
     value = (new Float(token)).floatValue();
   } catch (Exception exception) {
     error ("Error reading float data, please try again.");
     value = readFloat();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns a double read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo primitivo double 
         @return retorna o valor double lido a partir da console
*/
  public static double readDouble() {
   String token = getNextToken();
   double value;
   try {
     value = (new Double(token)).doubleValue();
   } catch (Exception exception) {
     error ("Error reading double data, please try again.");
     value = readDouble();
   }
   return value;
  }

  //-----------------------------------------------------------------
  //  Returns a string read from standard input.
  //-----------------------------------------------------------------
  /**Lê um valor do tipo String 
         @return retorna o valor da String lido a partir da console
*/
  public static String readString() {
   String str;
   try {
     str = getNextToken(false);
     while (! endOfLine()){
      str = str + getNextToken(false);
     }
   }catch (Exception exception) {
     error ("Error reading String data, please try again.");
     str = readString();
   }
   return str;
  }
}

Console.readString();