I'm trying to create a string that has a set amount of different words I include in a list, however the code I use only uses one word at random, not a different word for every word printed. This i... More on stackoverflow.com

Another option you could look at is xkcdpass . More on reddit.com

Read the sidebar for how to post your code. Alternatively, upload to http://codepad.org/?lang=Python I'm not going to critique your actual code until it is more readable, but as for your algorithm, I think you would do better to include dipthongs (e.g. ou) as vowels and digraphs (e.g. sh) and blends (e.g. pt) as consonants. I recommend this because words aren't really strings of letters, but strings of syllables, which can be more closely estimated than simply in terms of vowels and consonants. As an example, just alternating consonants and vowels will always produce words like Pokawy or Renika, which tend to have a very distinctive and somewhat artificial sound (although words generated this way can be very similar to those of the native Hawaiian language), while including dipthongs, blends, and digraphs can produce words more along the lines of eptia or temmish. That being said, this still isn't a great system. Of course, depending on what real-life language you are trying to emulate (if any) your system is going to have to be different. But even assuming you're trying to make English-sounding words, improvements can certainly be made. For example, the frequency of certain sounds coming after others more closely matches those from a dictionary. But those innovations are up to you to implement, should you desire. You could even look into having suffix and prefix generators, really the possibilities are endless. This might be useful: http://school.judsonisd.org/webpages/cbianco/readinghelp.cfm?subpage=23376 More on reddit.com

Continuing where you left off yesterday. Make sure to specify that you're working in Java in the future.

This is a good opportunity to practice a few different APIs. Like I said yesterday, look into using a BufferedReader for reading a file line by line. Let's work through it together.

try (BufferedReader reader = new BufferedReader(new FileReader("path/to/dictionary.txt")) {
    // do stuff
} catch (IOException e) {
    // handle exception
}

This is called a try-with-resources block. When working with anything that handles files, sockets, or the like you need to make sure that you let the system know you are done working with the file (or socket or whatever). A try-with-resources block gives you a scope level BufferedReader called reader that will be automatically closed at the end of the block. If an exception occurs the BufferedReader will still be closed. Before Java 7 introduced try-with-resources the pattern was similar to this:

BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("path/to/dictionary.txt"));
    // do stuff
} catch (IOException e) {
    // handle exception
} finally {
    IOUtils.closeQuiety(reader); // often a static utility class to handle closing resources without rethrowing exceptions
}

If you're using Java 7 or above use try-with-resources.

Let's look at the next bit: BufferedReader reader = new BufferedReader(new FileReader("path/to/dictionary.txt")) This is using the standard library's java.io classes. Something that trips up new Java programmers is that java.io makes heavy use of the Decorator pattern. What we're doing here is creating a BufferedReader that is wrapping a FileReader that is pointing to your dictionary text file. You could in theory use just a FileReader for this, but it would be really cumbersome. Wrapping it with a BufferedReader gives you a lot of convenience methods like BufferedReader.readerLine().

So now that we've gotten a BufferedReader we need to read in the file line by line. I'm assuming the dictionary file contains one word per line. Of course we need somewhere to store these lines. For that we'll use a List. If you haven't used a List before think of it as an array that can store an arbitrary amount of elements.

List<String> words = new ArrayList<>(); // create a new ArrayList that can old just Strings
try (BufferedReader reader = new BufferedReader(new FileReader("path/to/dictionary.txt")) {
    String word;
    while ((word = reader.readLine()) != null) {
        words.add(word);
    }
} catch (IOException e) {
    // handle exception
}

We've now added a body to the try-with-resources that contains a while loop. The condition of the while loop might look kinda strange. (word = reader.readLine()) != null This is reading one line of the file and assigning it to word. It is then checking word to see if it is not null. If word is null that means we've hit the end of the file, as per the javadoc for BufferedReader.readLine(). So while we keep reading a line from the dictionary file we add those words one at a time to our List<String> words. Once we reach the end of the while loop we're done with the try-with-resources. The BufferedReader reader will be closed for us and your OS will be grateful that you're not keeping a handle on the dictionary file around.

Continued in next post.

More on reddit.com