Thursday, October 30, 2008

generating random characters

        import java.util.*;

public class Test {

private static Random rn = new Random();

private Test()

public static int rand(int lo, int hi)
int n = hi - lo + 1;
int i = rn.nextInt() % n;
if (i < 0)
i = -i;
return lo + i;

public static String randomstring(int lo, int hi)
int n = rand(lo, hi);
byte b[] = new byte[n];
for (int i = 0; i < n; i++)
b[i] = (byte)rand('a', 'z');
return new String(b, 0);

public static String randomstring()
return randomstring(5, 25);
Actual random numbers are obtained using nextInt(), and then knocked down to the relevant range using the modulo ("%") operator.

Monday, October 20, 2008

Valid characters in URL

Be careful with the characters you use in the OBJECT tag attribute. The set of "safe" characters in a URL is severely restricted by the various ways in which they are transported. According to the standard for URL syntax (Request For Comments 1738), only the following characters are allowed unescaped in URLs, aside from letters of the alphabet and digits:

+  -  =  .  _  /  *      (  )  ,  @  '  $  :  ;  &  !  ?

The special characters used in MINSE have been carefully chosen from this set so that you don't have to "escape" them in URLs (using a percent character and a hexadecimal number). After we set aside the parentheses, the comma, and the characters on the left, which are commonly used in expressions, we are left with just six choices for the macro escape character (the ampersand is inconvenient, because it needs to be represented as an entity; but much worse, far too many browsers are broken and will not parse SGML entities in attribute values). The single-quote was chosen for convenience, because it is a non-shifted key on North-American keyboards.

Anything that is not part of the "safe" character set must always be escaped in a URL. In particular, the percent character ("%") and the space must be escaped. Use the following codes:

for:     space     %
use: %20 %25
Sorry about that, but i can't change the standard. There are good reasons for the decisions made in that document.

Valid characters in URL

URL encoding introduction


URL character encoding issues


URLs are sequences of characters, i.e., letters, digits, and special
characters. A URLs may be represented in a variety of ways: e.g., ink
on paper, or a sequence of octets in a coded character set. The
interpretation of a URL depends only on the identity of the
characters used.

In most URL schemes, the sequences of characters in different parts
of a URL are used to represent sequences of octets used in Internet
protocols. For example, in the ftp scheme, the host name, directory
name and file names are such sequences of octets, represented by
parts of the URL. Within those parts, an octet may be represented by
the chararacter which has that octet as its code within the US-ASCII
[20] coded character set.

In addition, octets may be encoded by a character triplet consisting
of the character "%" followed by the two hexadecimal digits (from
"0123456789ABCDEF") which forming the hexadecimal value of the octet.
(The characters "abcdef" may also be used in hexadecimal encodings.)

Octets must be encoded if they have no corresponding graphic
character within the US-ASCII coded character set, if the use of the
corresponding character is unsafe, or if the corresponding character
is reserved for some other interpretation within the particular URL

No corresponding graphic US-ASCII:

URLs are written only with the graphic printable characters of the
US-ASCII coded character set. The octets 80-FF hexadecimal are not
used in US-ASCII, and the octets 00-1F and 7F hexadecimal represent
control characters; these must be encoded.


Characters can be unsafe for a number of reasons. The space
character is unsafe because significant spaces may disappear and
insignificant spaces may be introduced when URLs are transcribed or
typeset or subjected to the treatment of word-processing programs.
The characters "<" and ">" are unsafe because they are used as the
delimiters around URLs in free text; the quote mark (""") is used to
delimit URLs in some systems. The character "#" is unsafe and should
always be encoded because it is used in World Wide Web and in other
systems to delimit a URL from a fragment/anchor identifier that might
follow it. The character "%" is unsafe because it is used for
encodings of other characters. Other characters are unsafe because
gateways and other transport agents are known to sometimes modify
such characters. These characters are "{", "}", "|", "\", "^", "~",
"[", "]", and "`".

All unsafe characters must always be encoded within a URL. For
example, the character "#" must be encoded within URLs even in
systems that do not normally deal with fragment or anchor
identifiers, so that if the URL is copied into another system that
does use them, it will not be necessary to change the URL encoding.


Many URL schemes reserve certain characters for a special meaning:
their appearance in the scheme-specific part of the URL has a
designated semantics. If the character corresponding to an octet is
reserved in a scheme, the octet must be encoded. The characters ";",
"/", "?", ":", "@", "=" and "&" are the characters which may be
reserved for special meaning within a scheme. No other characters may
be reserved within a scheme.

Usually a URL has the same interpretation when an octet is
represented by a character and when it encoded. However, this is not
true for reserved characters: encoding a character reserved for a
particular scheme may change the semantics of a URL.

Thus, only alphanumerics, the special characters "$-_.+!*'(),", and
reserved characters used for their reserved purposes may be used
unencoded within a URL.

On the other hand, characters that are not required to be encoded
(including alphanumerics) may be encoded within the scheme-specific
part of a URL, as long as they are not being used for a reserved

main parts of URL

In general, URLs are written as follows:


A URL contains the name of the scheme being used () followed
by a colon and then a string (the ) whose
interpretation depends on the scheme.

Scheme names consist of a sequence of characters. The lower case
letters "a"--"z", digits, and the characters plus ("+"), period
("."), and hyphen ("-") are allowed. For resiliency, programs
interpreting URLs should treat upper case letters as equivalent to
lower case in scheme names (e.g., allow "HTTP" as well as "http").

using secure random and message direct to generate random nad unique number

The following method uses SecureRandom and MessageDigest :

  • upon startup, initialize SecureRandom (this may be a lengthy operation)
  • when a new identifier is needed, generate a random number using SecureRandom
  • create a MessageDigest of the random number
  • encode the byte[] returned by the MessageDigest into some acceptable textual form
  • check if the result is already being used ; if it is not already taken, it is suitable as a unique identifier
The MessageDigest class is suitable for generating a "one-way hash" of arbitrary data. (Note that hash values never uniquely identify their source data, since different source data can produce the same hash value. The value of hashCode, for example, does not uniquely identify its associated object.) A MessageDigest takes any input, and produces a String which :
  • is of fixed length
  • does not allow the original input to be easily recovered (in fact, this is very hard)
  • does not uniquely identify the input ; however, similar input will produce dissimilar message digests
MessageDigest is often used as a checksum, for verifying that data has not been altered since its creation.



public class GenerateId {

public static void main (String... arguments) {
try {
//Initialize SecureRandom
//This is a lengthy operation, to be done only upon
//initialization of the application
SecureRandom prng = SecureRandom.getInstance("SHA1PRNG");

//generate a random number
String randomNum = new Integer( prng.nextInt() ).toString();

//get its digest
MessageDigest sha = MessageDigest.getInstance("SHA-1");
byte[] result = sha.digest( randomNum.getBytes() );

System.out.println("Random number: " + randomNum);
System.out.println("Message digest: " + hexEncode(result) );
catch ( NoSuchAlgorithmException ex ) {

* The byte[] returned by MessageDigest does not have a nice
* textual representation, so some form of encoding is usually performed.
* This implementation follows the example of David Flanagan's book
* "Java In A Nutshell", and converts a byte array into a String
* of hex characters.
* Another popular alternative is to use a "Base64" encoding.

static private String hexEncode( byte[] aInput){
StringBuilder result = new StringBuilder();
char[] digits = {'0', '1', '2', '3', '4','5','6','7','8','9','a','b','c','d','e','f'};
for ( int idx = 0; idx < aInput.length; ++idx) {
byte b = aInput[idx];
result.append( digits[ (b&0xf0) >> 4 ] );
result.append( digits[ b&0x0f] );
return result.toString();

Example run :

>java -cp . GenerateId
Random number: -1103747470
Message digest: c8fff94ba996411079d7114e698b53bac8f7b037

generate unique ID using UUID utility in Java5

mport java.util.UUID;

public class UniqueID {

public static void main(String args[]){
UUID one = UUID.randomUUID();
UUID two = UUID.randomUUID();





to generate random characters


public class RandomCharacters {

private static void doRandomCharacters() {

double randomNumber;
double randomNumberSetup;
char randomCharacter;


for (int i = 0; i < 10; i++) {
randomNumber = Math.random();
randomNumberSetup = (randomNumber * 26 + 'a');
randomCharacter = (char) randomNumberSetup;
System.out.print(randomCharacter + ": ");
switch(randomCharacter) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u': System.out.print("vowel");
case 'y':
case 'w': System.out.print("sometimes a vowel");
default: System.out.print("consonant");
System.out.println(" - Random number was (" + randomNumber + ")");


* Sole entry point to the class and application.
* @param args Array of String arguments.
public static void main(String[] args) {


Thursday, October 16, 2008

what characters are valid in url?

The specification for URLs, RFC1738, limits the use of allowed characters to only a limited subset of the US-ASCII character set (2.2 URL Character Encoding Issues):

"The lower case letters "a"--"z", digits, and the characters plus ("+"), period("."), and hyphen ("-") are allowed.... In addition, octets may be encoded by a character triplet consisting of the character "%" followed by the two hexadecimal digits (from"0123456789ABCDEF") which forming (sic) the hexadecimal value of the octet. (The characters "abcdef" may also be used in hexadecimal encodings.)"

To insert, for example, the French accented à, you would use %E0 instead of the letter.

Tuesday, October 14, 2008

snake game

When the snake game executes it looks like here

parsing a string


You are to create a console application that accepts exactly one command-line argument. If it doesn’t receive the argument, the application must display an error message and exit. The application must parse the text input and output the number of times each letter of the alphabet occurs in the text. Case sensitivity is not required.

For example, if the command-line argument is “baaad” the displayed result must be:

There are 3 A's
There are 1 B's
There are 0 C's
There are 1 D's
There are 0 E's
There are 0 F's

Result: In this we use Stream Tokenizer.


public class Class1 {

public static void main(String[] av) throws IOException {
StreamTokenizer tf = new StreamTokenizer(new BufferedReader(new InputStreamReader(;
String s = null;
char a[] = {'A', 'B', 'C', 'D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R',

int count = 0;
int i, r=0,m=0;

while ((i = tf.nextToken()) != StreamTokenizer.TT_EOF) {
switch (i) {
/* case StreamTokenizer.TT_EOF:
System.out.println("End of file");
case StreamTokenizer.TT_EOL:
System.out.println("End of line");
case StreamTokenizer.TT_NUMBER:
System.out.println("Number " + tf.nval);

case StreamTokenizer.TT_WORD:
s = tf.sval.toUpperCase();
System.out.println("Word, length " + tf.sval.length() + " " );

{if (s.charAt(p) == a[r])



System.out.println("There are " +count +a[r]);

count=0; r++; }



System.out.println("What is it? i = " + i);

} } } }

Thursday, October 9, 2008

requirements for key generator

new class KeyGenerator
lives in a package: edu.gvsu.cri.utils

1. valid web characters for the url address
2. random key of n characters where n is the parameter of method
3. research methods of randomness i.e. method based on time stand.