Question: Basically title. I can run them all in a row or all at once. I need the first one to run to load data for the rest.

Any ideas?

Answer: 
So here is why it worked like it did:

`StreamTokenizer` regards its input much like a programming language tokenizer. That is, it breaks it up into tokens that are "words", "numbers", "quoted strings", "comments", and so on, based on the syntax the programmer sets up for it. The programmer tells it which characters are word characters, plain characters, comment characters etc.

So in fact it does rather sophisticated tokenizing - recognizing comments, quoted strings, numbers. Note that in a programing language, you can have a string like `a = a+b;`. A simple tokenizer that merely breaks the text by whitespace would break this into `a`, `=` and `a+b;`. But `StreamTokenizer` would break this into `a`, `=`, `a`, `+`, `b`, and `;`, and will also give you the "type" for each of these tokens, so your "language" parser can distinguish identifiers from operators. `StreamTokenizer`'s types are rather basic, but this behavior is the key to understanding what happened in your case.

It wasn't recognizing the `@` as whitespace. In fact, it was parsing it and returning it as a token. But its value was in the `ttype` field, and you were probably just looking at the `sval`.

A `StreamTokenizer` would recognize your line as:

```
The word Student
The number 6.0
The word Name6
The word LastName6
The word del6
The character @
The word uni.at
The word Competition
The word speech
The word University
The word of
The word Innsbruck

```

(This is the actual output of a little demo I wrote tokenizing your example line and printing by type).

In fact, by telling it that `@` was an "ordinary character", you were telling it to take the `@` as its own token (which it does anyway by default). The [`ordinaryChar()` documentation](http://docs.oracle.com/javase/7/docs/api/java/io/StreamTokenizer.html#ordinaryChar(int)) tells you that this method:

> 
> Specifies that the character argument is "ordinary" in this tokenizer.
>  It removes any special significance the character has as a comment
>  character, word component, string delimiter, white space, or number
>  character. **When such a character is encountered by the parser, the
>  parser treats it as a single-character token and sets ttype field to
>  the character value.**
> 
> 
> 

(My emphasis).

In fact, if you had instead passed it to `wordChars()`, as in `tokenizer.wordChars('@','@')` it would have kept the whole e-mail together. My little demo with that added gives:

```
The word Student
The number 6.0
The word Name6
The word LastName6
The word del6@uni.at
The word Competition
The word speech
The word University
The word of
The word Innsbruck

```

If you need a programming-language-like tokenizer, `StreamTokenizer` may work for you. Otherwise your options depend on whether your data is line-based (each line is a separate record, there may be a different number of tokens on each line), where you would typically read lines one-by-one from a reader, then split them using `String.split()`, or if it is just a whitespace-delimited chain of tokens, where `Scanner` might suit you better.
In order to simply split a `String`, see [the answer](https://stackoverflow.com/a/236425/1587329) to [this question](https://stackoverflow.com/questions/236387/whats-the-best-way-to-have-stringtokenizer-split-up-a-line-of-text-into-predefi) (adapted for whitespace):

> 
> The best way is to not use a StringTokenizer at all, but use String's
>  split method. It returns an array of Strings, and you can get the
>  length from that.
> 
> 
> For each line in your file you can do the following:
> 
> 
> String[] tokens = line.split(" +");
> 
> 
> tokens will now have 6 - 8 Strings. Use tokens.length() to find out
>  how many, then create your object from the array.
> 
> 
> 

This is sufficient for the given line, and might be sufficient for everything. Here is some code that uses it (it reads `System.in`):

```
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class T {
    public static void main(String[] args) {
        BufferedReader st = new BufferedReader(new InputStreamReader(System.in));

        String line;
        try {
            while ( st.ready() ) {
                line = st.readLine();
                String[] tokens = line.split(" +");
                for( String token: tokens ) {
                    System.out.println(token);
                }
            }
        } catch ( IOException e ) {
            throw new RuntimeException(e); // handle error here
        }
    }
}

```