AppPerfect

Java Internationalization (i18n)

Rules available in this category:

1. Avoid_string_concat_method
2. Avoid_getCurrencyInstance_method
3. Avoid_single_char_with_logical_comparison
4. Use_constants_for_char_literals
5. Avoid_Using_String_Split
6. Avoid_Using_String_IndexOf
7. Avoid_Using_toString_to_convert_BigInteger_to_String
8. Avoid_Using_toString_to_convert_BigDecimal_to_String
9. Avoid_Using_Constructor_String_Using_Bytes
10. Avoid_Using_String_compareTo_Method
11. Avoid_Using_Method_String_equals
12. Avoid_Using_Method_String_getBytes
13. Avoid_calling_java_lang_Byte_toString
14. Avoid_calling_java_lang_Short_toString
15. Avoid_using_java_io_FileReader
16. Avoid_using_java_io_FileWriter
17. Avoid_using_java_io_InputStreamReader_with_default_character_set
18. Avoid_using_java_io_OutputStreamWriter_with_default_character_set
19. Avoid_using_java_lang_Character_toLowerCase
20. Avoid_using_java_lang_Character_toUpperCase
21. Avoid_calling_java_util_Date_toString
22. Avoid_using_parseByte_on_java_lang_Byte
23. Avoid_using_charAt_on_java_lang_String
24. Avoid_using_valueOf_on_java_lang_String
25. Avoid_using_parseFloat_on_java_lang_Float
26. Avoid_using_parseInt_on_java_lang_Integer
27. Avoid_using_parseLong_on_java_lang_Long
28. Avoid_using_parseShort_on_java_lang_Short
29. Avoid_calling_toString
30. Avoid_using_java_awt_TextArea_directly
31. Avoid_using_java_awt_TextField_directly
32. Avoid_calling_Time_toString
33. Avoid_String_compareTo_method
34. Do_not_use_String_compareToIgnoreCase
35. Avoid_non_internationalized_string
36. Avoid_String_equals_method
37. Always_use_locale_specific_case_conversion
38. Do_not_use_String_CASE_INSENSITIVE_ORDER

Rule 1: Avoid_string_concat_method

Severity:  Medium
Rule:  Disallows string concatenation using 'String.concat ()' in an internationalized environment
Reason:  Disallows string concatenation using 'String.concat ()' in an internationalized environment

Usage Example: 

package com.rule;
class Avoid_string_concate_method_violation
{
	public void print()
	{
		//.............
		String s = "";
		s = s.concat("AppPerfect");	// VIOLATION
		//....
	}
}

Should be written as:

Use MessageFormat to concatenate strings in internationalized 
environment. MessageFormat provides a means to produce concatenated messages in language-neutral way.

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 2: Avoid_getCurrencyInstance_method

Severity:  Medium
Rule:  This method will return outdated currency for individual European countries, instead of returning the Euro.
Reason:  This method will return outdated currency for individual European countries, instead of returning the Euro.

Usage Example: 

import java.text.NumberFormat;
import java.util.Locale;

public class Test 
{
	public static void main(String[] args)
	{
		double value = 12345.678; 
		Locale defaultLocale = Locale.getDefault();
		NumberFormat nf = 
			NumberFormat.getCurrencyInstance(defaultLocale); // VIOLATION
		String formattedValue = nf.format(value);
		System.out.println(formattedValue); 
	}
}

Should be written as:

import java.text.NumberFormat;
import java.util.Locale;
import java.util.Currency;

public class Test 
{
	public static void main(String[] args) 
	{
		double value = 12345.678; 
		Currency currency = Currency.getInstance("EUR"); // CORRECTION
		Locale defaultLocale = Locale.getDefault();
		NumberFormat nf = NumberFormat.getCurrencyInstance(defaultLocale);
		nf.setCurrency(currency);
		String formattedValue = nf.format(value);
		System.out.println(formattedValue); 
	}

}

Reference:  No references available.

Rule 3: Avoid_single_char_with_logical_comparison

Severity:  Medium
Rule:  Avoid using single character with logic operators in an internationalized environment
Reason:  Avoid using single character with logic operators in an internationalized environment

Usage Example: 

package com.rule;

class Avoid_single_char_with_logical_comparison_violation
{
 	public void doAction()
	{
		char ch;
		// ...
		if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) // Violation
		{
			// ...
		}
	}
}

Should be written as:

package com.rule;

class Avoid_single_char_with_logical_comparison_correction
{
	public void doAction()
	{
		char ch;
		// ...
		if (Character.isLetter(ch))		// CORRECTION
		{
			// ...
		}
	}
}

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 4: Use_constants_for_char_literals

Severity:  Medium
Rule:  Put single character literals in constants.
Reason:  Put single character literals in constants.

Usage Example: 

package com.rule;
class Use_constants_for_char_literals_violation
{
	public char method(int i)
	{
		char cResult = 'N';		// VIOLATION
		if(i == 0)
		{
			cResult = 'Y';		// VIOLATION
		}
		return cResult;
	}
}

Should be written as:

package com.rule;
class Use_constants_for_char_literals_correction
{
	public static final char YES = 'Y';		// CORRECTION
	public static final char NO = 'N';		// CORRECTION

	public char method(int i)
	{
		char cResult = NO;
		if(i == 0)
		{
			cResult = YES;
		}
		return cResult;
	}
}

Reference:  http://java.sun.com/docs/books/tutorial/i18n/

Rule 5: Avoid_Using_String_Split

Severity:  Medium
Rule:  Split doesn't support strings containing combining characters and strings containing characters 
which are canonically equivalent.
Reason:  Split doesn't support strings containing combining characters and strings containing characters 
which are canonically equivalent.

Usage Example: 

public class Test extends {
	 public void myMethod() 
	{
	 	String value = new String("Text Message" );
	 	String str = new String("compare");
	 	str.split(value); //violation
	}
}

Should be written as:

public class Test extends {
	 public void myMethod() 
	{
	 	String value = new String("Text Message" );
	 	String str = new String("compare");
	 	str.split(value); //Fixed
	}
}

Reference: 

Rule 6: Avoid_Using_String_IndexOf

Severity:  Medium
Rule:  IndexOf does not properly support certain unicode characters before J2SE 1.5.0.
Reason:  IndexOf does not properly support certain unicode characters before J2SE 1.5.0.

Usage Example: 

public class Test extends ClassLoader{
public void myMethod() 
	{	
		 String value = new String("Text Message" );
	 	String s = new String("Text");
	 	String str = new String("compare");
	 	if(s.indexOf(3) == value.indexOf(3,3)) //violation
	 	{
	 		System.out.println("Test.myMethod()" + value.indexOf(3)); //violation
	 	}
	}
}

Should be written as:

public class Test extends ClassLoader{
public void myMethod() 
	{	
		 String value = new String("Text Message" );
	 	String s = new String("Text");
	 	String str = new String("compare");
	 	if(s.indexOf(3) == value.indexOf(3,3)) //violation
	 	{
	 		System.out.println("Test.myMethod()" + value.indexOf(3)); //violation
	 	}
	}
}

Reference:  http://oss.software.ibm.com/icu/userguide/searchString.html

Rule 7: Avoid_Using_toString_to_convert_BigInteger_to_String

Severity:  Medium
Rule:  It may not correctly handle all locales.
Reason:  It may not correctly handle all locales.

Usage Example: 

package base;

import java.math.BigInteger;

public class Test extends {
	 public void myMethod() {
	 	BigInteger big = new BigInteger("15");
	 	System.out.println(big.toString()); //violation
	 }
}

Should be written as:

package base;

import java.math.BigInteger;

public class Test extends {
	 public void myMethod() {
	 	BigInteger big = new BigInteger("15"); 
	 	System.out.println(big); //Fixed
	 }
}

Reference:  No Refrences Available.

Rule 8: Avoid_Using_toString_to_convert_BigDecimal_to_String

Severity:  Medium
Rule:  It may not correctly handle all locales.
Reason:  It may not correctly handle all locales.

Usage Example: 

package base;

import java.math.BigInteger;
import java.util.Date;

public class Test extends {
	 public void myMethod() {
	 	BigInteger big = new BigInteger("15");
	 	System.out.println(big.toString()); //violation
	 }
}

Should be written as:

package base;

import java.math.BigInteger;
import java.util.Date;

public class Test extends {
	 public void myMethod() {
	 	BigInteger big = new BigInteger("15");
	 	System.out.println(big); //Fixed
	 }
}

Reference:  No Refrences available.

Rule 9: Avoid_Using_Constructor_String_Using_Bytes

Severity:  Medium
Rule:  These constructors interpret the byte array according to the default character set and may produce unexpected results
Reason:  These constructors interpret the byte array according to the default character set and may produce unexpected results

Usage Example: 

package base;

public class Test 
{
  	 public void myMethod() {
	 	String value = new String("Text Message");
	 	String str = new String(value.getBytes()); //violation
	 }
}

Should be written as:

package base;

public class Test 
{
  	 public void myMethod() {
	 	String value = new String("Text Message");
	 	String str = new String(value.getBytes()); //Fixed
	 }
}

Reference:  No Refrences Available.

Rule 10: Avoid_Using_String_compareTo_Method

Severity:  Medium
Rule:  These methods do not properly handle locale-sensitive strings and string with Unicode supplementary characters.
Reason:  These methods do not properly handle locale-sensitive strings and string with Unicode supplementary characters.

Usage Example: 

package base;

public class Test extends ClassLoader{
 public void myMethod() {
	 	String value = new String("Text Message");
	 	String str = new String("compare");
	 	value.compareTo(str); //violation
	 	value.compareTo((Object)"hello"); //violation
	 	value.compareToIgnoreCase(str);  //violation
	 }
}

Should be written as:

package base;

public class Test extends ClassLoader{
 public void myMethod() {
	 	String value = new String("Text Message");
	 	String str = new String("compare");
	 	value.compareTo(str); //violation
	 	value.compareTo((Object)"hello"); //violation
	 	value.compareToIgnoreCase(str);  //violation
	 }
}

Reference:  No Reference Available.

Rule 11: Avoid_Using_Method_String_equals

Severity:  Medium
Rule:  These methods are not locale-sensitive.
Reason:  These methods are not locale-sensitive.

Usage Example: 

package base;

public class Test 
{
	 public void myMethod() 
		{
	 		String value = new String("Text Message");
		 	String str = new String("compare");
		 	if(str.equals(value) //violation
			{
				System.out.println("match");
			}	
	}
}

Should be written as:

package base;

public class Test 
{
	 public void myMethod() 
		{
	 		String value = new String("Text Message");
		 	String str = new String("compare");
		 	if(str.equals(value) //fixed
			{
				System.out.println("match");
			}	
	}
}

Reference:  No References available.

Rule 12: Avoid_Using_Method_String_getBytes

Severity:  Medium
Rule:  If the string-to-byte conversion using the default character set fails, the data will be lost.
Reason:  If the string-to-byte conversion using the default character set fails, the data will be lost.

Usage Example: 

package base;

public class Test 
{
	 public void myMethod() {
	 	String value = new String("Text Message");
	 	String s = new String(value.getBytes()); //violation
	 }
}

Should be written as:

package base;

public class Test 
{
	 public void myMethod() {
	 	String value = new String("Text Message");
	 	String s = new String(value.getBytes()); //violation
	 }
}

Reference:  No References available.

Rule 13: Avoid_calling_java_lang_Byte_toString

Severity:  Medium
Rule:  Avoid calling toString() on an object of type java.lang.Byte.
Reason:  Avoid calling toString() on an object of type java.lang.Byte.

Usage Example: 

public class BTS
{
	public static void main( String[] args ) 
	{
		byte b = (byte) 0x80;
		Byte B = new Byte( b );
		System.out.println(Byte.toString( b ) ); // VIOLATION
		System.out.println( B.toString() ); // VIOLATION
	}
}

Should be written as:

public class BTS
{
	public static void main(String[] args)
	{
		byte b = (byte) 0x80;
		Byte B = new Byte(b);
		java.text.NumberFormat f;
		java.util.Locale l;

		l = java.util.Locale.ENGLISH;
		f = java.text.NumberFormat.getNumberInstance(l);
		System.out.println(" English: " + f.format(b)); //$NON-NLS-1$
		System.out.println(" English: " + f.format(B)); //$NON-NLS-1$

		l = new java.util.Locale("ar", "AE"); //$NON-NLS-1$ //$NON-NLS-2$
		f = java.text.NumberFormat.getNumberInstance(l);
		System.out.println(" Arabic: " + f.format(b)); //$NON-NLS-1$
		System.out.println(" Arabic: " + f.format(B)); //$NON-NLS-1$

		l = new java.util.Locale("mk", "MK"); //$NON-NLS-1$ //$NON-NLS-2$
		f = java.text.NumberFormat.getNumberInstance(l);
		System.out.println("Macedonia: " + f.format(b)); //$NON-NLS-1$
		System.out.println("Macedonia: " + f.format(B)); //$NON-NLS-1$
	}
}

Reference:  No references available.

Rule 14: Avoid_calling_java_lang_Short_toString

Severity:  Medium
Rule:  Avoid calling toString() on an object of type java.lang.Short.
Reason:  Avoid calling toString() on an object of type java.lang.Short.

Usage Example: 

public class BTS
{
	public static void main( String[] args ) 
	{ 
		short s = -12345; 
		Short S = new Short(s); 
		System.out.println(Short.toString(s));  // VIOLATION
		System.out.println(S.toString());  // VIOLATION
	} 

}

Should be written as:

public class BTS
{
	public static void main(String[] args)
	{
		short n = -12345;
		Short N = new Short(n);
		java.text.NumberFormat f;
		java.util.Locale l;

		l = java.util.Locale.ENGLISH;
		f = java.text.NumberFormat.getNumberInstance(l);
		System.out.println(Messages.getString("ShortToString_Solution1.0") + f.format(n)); //$NON-NLS-1$
		System.out.println(" English: " + f.format(N)); //$NON-NLS-1$

		l = new java.util.Locale("ar", "AE"); //$NON-NLS-1$ //$NON-NLS-2$
		f = java.text.NumberFormat.getNumberInstance(l);
		System.out.println(" Arabic: " + f.format(n)); //$NON-NLS-1$
		System.out.println(" Arabic: " + f.format(N)); //$NON-NLS-1$

		l = new java.util.Locale("mk", "MK"); //$NON-NLS-1$ //$NON-NLS-2$
		f = java.text.NumberFormat.getNumberInstance(l);
		System.out.println("Macedonia: " + f.format(n)); //$NON-NLS-1$
		System.out.println("Macedonia: " + f.format(N)); //$NON-NLS-1$
	}

}

Reference:  No references available.

Rule 15: Avoid_using_java_io_FileReader

Severity:  Medium
Rule:  Avoid using java.io.FileReader because the constructors have no charset parameters.
Reason:  Avoid using java.io.FileReader because the constructors have no charset parameters.

Usage Example: 

public class NoFileReader
{
	public static void main( String[] args ) 
	{ 
		// Assume default charset ISO-8859-1 and file with UTF-16BE content
		FileReader fileReader = null;
		try 
		{
			fileReader = new java.io.FileReader( "file1" ); //$NON-NLS-1$// VIOLATION
			System.out.println( fileReader.read() ); 
		}
		 catch ( IOException e ) 
		{
			e.printStackTrace();
		} 
	}

}

Should be written as:

public class NoFileReader
{
	public static void main( String[] args ) 
	{ 
		// Assume default charset ISO-8859-1 and file with UTF-16BE content
		InputStreamReader reader = null;
		try 
		{
			reader = new InputStreamReader( new FileInputStream("file1"), "UTF-16BE");// CORRECTION
			System.out.println( reader.read() ); 
		} 
		catch ( IOException e ) 
		{
			e.printStackTrace();
		}
	}
	
}

Reference:  No references available.

Rule 16: Avoid_using_java_io_FileWriter

Severity:  Medium
Rule:  Avoid using java.io.FileWriter because the constructors have no charset parameters.
Reason:  Avoid using java.io.FileWriter because the constructors have no charset parameters.

Usage Example: 

public class NoFileWriter
{
	public static void main( String[] args ) 
	{
		FileWriter fileWriter = null;
		try 
		{
			fileWriter = new FileWriter("file1"); //$NON-NLS-1$  // VIOLATION
			fileWriter.write( "\uceba" ); //$NON-NLS-1$
		} 
		catch ( IOException e ) 
		{
			e.printStackTrace();
		}
	}

}

Should be written as:

public class NoFileWriter
{
	public static void main( String[] args ) 
	{
		OutputStreamWriter writer = null;
		try 
		{
			writer = new OutputStreamWriter(new FileOutputStream("file1"), //$NON-NLS-1$
			"UTF-16BE"); //$NON-NLS-1$ // CORRECTION
			writer.write( "\uceba" ); //$NON-NLS-1$
			writer.flush();
		} 
		catch ( IOException e ) 
		{
			e.printStackTrace();
		}
	}
	
}

Reference:  No references available.

Rule 17: Avoid_using_java_io_InputStreamReader_with_default_character_set

Severity:  Medium
Rule:  Avoid using java.io.InputStreamReader with the default character set.
Reason:  Avoid using java.io.InputStreamReader with the default character set.

Usage Example: 

public class ISR
{
	public static void main(String[] args)
	{
		try 
		{
			String fileName = "UnicodeSample.txt"; //$NON-NLS-1$
			java.io.FileInputStream fileInput = null;
			java.io.InputStreamReader reader = null;
			fileInput = new java.io.FileInputStream(fileName);
			reader = new java.io.InputStreamReader(fileInput);//UTF-16BE  // VIOLATION
			System.out.println(reader.read());
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
}

Should be written as:

public class ISR
{
	public static void main(String[] args)
	{
		try 
		{
			java.io.FileInputStream fileInput;
			java.io.InputStreamReader reader;
			fileInput = new java.io.FileInputStream("file1"); //$NON-NLS-1$
			reader = new java.io.InputStreamReader(fileInput,"UTF-16BE"); 				//$NON-NLS-1$ // CORRECTION
			System.out.println(reader.read());
		}
		catch (Exception e)	
		{
			e.printStackTrace();
		}
	}
}

Reference:  No references available.

Rule 18: Avoid_using_java_io_OutputStreamWriter_with_default_character_set

Severity:  Medium
Rule:  Avoid using java.io.OutputStreamWriter with the default character set.
Reason:  Avoid using java.io.OutputStreamWriter with the default character set.

Usage Example: 

public class OSR
{
	public static final void main(String[] args) 
	{
		try 
		{
			String str = "\uceba"; //UTF-16BE //$NON-NLS-1$
			FileOutputStream fileOutput = new FileOutputStream("file1"); //UTF-16BE //$NON-NLS-1$
			OutputStreamWriter writer = new OutputStreamWriter(fileOutput); // VIOLATION
			writer.write(str);
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
}

Should be written as:

public class OSR
{
	public static final void main(String[] args) 
	{
		String str = "\uceba"; //str is a UTF-16BE //$NON-NLS-1$
		try 
		{
			FileOutputStream fileOutput = new FileOutputStream("test.txt"); //$NON-NLS-1$
			OutputStreamWriter write = new OutputStreamWriter(fileOutput,
			java.nio.charset.Charset.forName("UTF-16BE").newEncoder()); //$NON-NLS-1$
			write.write(str);
			write.flush();
			write.close();
		} 
		catch (java.io.FileNotFoundException e1) 
		{
			System.out.println(e1.toString());
		} 
		catch (java.io.IOException e2) 
		{
			System.out.println(e2.toString());
		}
	}

}

Reference:  No references available.

Rule 19: Avoid_using_java_lang_Character_toLowerCase

Severity:  Medium
Rule:  Avoid using java.lang.Character.toLowerCase, because it does not support supplementary characters properly.
Reason:  Avoid using java.lang.Character.toLowerCase, because it does not support supplementary characters properly.

Usage Example: 

public class CtoLower
{
	public static void main(String[] args)
	{
		char ch = '\u4e2d'; 
		System.out.println(Character.toLowerCase(ch));	// VIOLATION	
	}

}

Should be written as:

public class CtoLower
{
	public static void main(String[] args)
	{
		int c1 = 0x10400;
		int c2 = Character.toLowerCase(c1);		// CORRECTION
	}

}

Reference:  http://java.sun.com/developer/technicalArticles/Intl/Supplementary/

Rule 20: Avoid_using_java_lang_Character_toUpperCase

Severity:  Medium
Rule:  Avoid using java.lang.Character.toUpperCase, because it does not support supplementary characters properly.
Reason:  Avoid using java.lang.Character.toUpperCase, because it does not support supplementary characters properly.

Usage Example: 

public class CtoUpper
{
	public static void main(String[] args)
	{
		char ch = '\u4e2d';
		System.out.println(Character.toUpperCase(ch)); // VIOLATION
	}

}

Should be written as:

public class CtoUpper
{
	public static void main(String[] args)
	{
		int c1 = 0x10428; 
		int c2 = Character.toUpperCase(c1); // CORRECTION
	}

}

Reference:  http://java.sun.com/developer/technicalArticles/Intl/Supplementary/

Rule 21: Avoid_calling_java_util_Date_toString

Severity:  Medium
Rule:  Avoid calling toString() on an object of type java.util.Date.
Reason:  Avoid calling toString() on an object of type java.util.Date.

Usage Example: 

public class DTS
{
	public static void main( String[] args ) 
	{
		java.util.Date date = new java.util.Date(); 
		System.out.println( date.toString() ); 		// VIOLATION
	}

}

Should be written as:

public class DTS
{
	public static void main(String[] args)
	{
		Date myDate = new Date();

		DateFormat df = DateFormat.getDateInstance(DateFormat.FULL, 
		java.util.Locale.GERMAN);
		System.out.println( df.format(myDate) );
	}

}

Reference:  No references available.

Rule 22: Avoid_using_parseByte_on_java_lang_Byte

Severity:  Medium
Rule:  Avoid calling parseByte() on an object of type java.lang.Byte.
Reason:  Avoid calling parseByte() on an object of type java.lang.Byte.

Usage Example: 

public class PB
{
	public static void main( String[] args ) 
	{
		String strByte = "126-"; //126- is -126 in ar_EG //$NON-NLS-1$
		try 
		{
			System.out.println( Byte.parseByte(strByte ) );
		 } 
		 catch ( Exception e ) 
		{
			// NumberFormatException
			e.printStackTrace();
		}
	}
}

Should be written as:

public class PB
{
	public static void main(String[] args) 
	{
		java.util.Locale loc = new Locale("ar", "EG"); //$NON-NLS-1$ //$NON-NLS-2$
		String strByte = "126-";; //$NON-NLS-1$
		try 
		{
			byte data = java.text.NumberFormat.getNumberInstance(loc).parse(
					strByte).byteValue();
			System.out.println(data);
		} 
		catch (Exception e) 
		{
			System.out.println(e.toString());
		}
	}
}

Reference:  No references available.

Rule 23: Avoid_using_charAt_on_java_lang_String

Severity:  Medium
Rule:  Avoid calling charAt() on an object of type java.lang.String.
Reason:  Avoid calling charAt() on an object of type java.lang.String.

Usage Example: 

public class NoCharAt
{
	public static void main(String[] args)
	{
		String str = "ABC\ud800\udc00"; 
		char ch = str.charAt(3); 			// VIOLATION
		System.out.println("String.charAt(3) = 0x" + Integer.toHexString(ch)); 		
		System.out.println("The output should be \"String.charAt(3) = 0x10000\""); 		}

}

Should be written as:

public class NoCharAt
{
	public static void main(String[] args)
	{
		String str = "ABC\ud800\udc00";
		int codepoint = str.codePointAt(3); 	// CORRECTION
		System.out.print("String.codePointAt(3) = 0x");
		System.out.println(Integer.toHexString(codepoint));
	}
}

Reference:  http://java.sun.com/developer/technicalArticles/Intl/Supplementary/

Rule 24: Avoid_using_valueOf_on_java_lang_String

Severity:  Medium
Rule:  Avoid calling valueOf() on an object of type java.lang.String.
Reason:  Avoid calling valueOf() on an object of type java.lang.String.

Usage Example: 

public class NoValueOf
{
	public static void main(String[] args)
	{
		double d = 1234567.89;
		long l = 123456789;
		int i = 1234567;
		float f = (float) 12345.678;

		System.out.println(String.valueOf(d));
		System.out.println(String.valueOf(f));
		System.out.println(String.valueOf(l));
		System.out.println(String.valueOf(i));
	}
}

Should be written as:

public class NoValueOf
{
	public static void main(String[] args)
	{
		NumberFormat nf_en = NumberFormat.getNumberInstance(new 							Locale("en", "US"));
		double d = 1234567.89;
		float f = (float) 12345.678;
		long l = 123456789;
		int i = 1234567;

		System.out.println(nf_en.format(d));
		System.out.println(nf_en.format(f));
		System.out.println(nf_en.format(l));
		System.out.println(nf_en.format(i));
	}
}

Reference:  No references available.

Rule 25: Avoid_using_parseFloat_on_java_lang_Float

Severity:  Medium
Rule:  Avoid calling parseFloat() on an object of type java.lang.Float.
Reason:  Avoid calling parseFloat() on an object of type java.lang.Float.

Usage Example: 

public class PB
{
	public static void main( String[] args ) 
	{
		public static void main( String[] args ) 
		{
			String strFloat = "4 125,53"; //4 125,53 is 4125.53 in fr_FR //$NON-NLS-1$
			try 
			{ 
				System.out.println( Float.parseFloat( strFloat ) );
			} 
			catch (Exception e) 
			{
				// NumberFormatException
				e.printStackTrace();
				System.out.println(e.getMessage()); 
			}
		}

	}
}

Should be written as:

public class PB
{
	public static void main(String[] args)
	{
		String strFloat = "4 125,53"; // Note: the space used in string is no-break space instead of space. //$NON-NLS-1$
		try 
		{
			float data = java.text.NumberFormat.getNumberInstance(java.util.Locale.FRENCH).parse(strFloat).floatValue();
			System.out.println(data); 
		} 
		catch (Exception e) 
		{
			System.out.println(e.toString());
		}
	}

}

Reference:  No references available.

Rule 26: Avoid_using_parseInt_on_java_lang_Integer

Severity:  Medium
Rule:  Avoid calling parseInt() on an object of type java.lang.Integer.
Reason:  Avoid calling parseInt() on an object of type java.lang.Integer.

Usage Example: 

public class PB
{
	public static void main ( String[] args ) 
	{
		String strInteger = "125-"; // 125- is -125 in locale ar_EG //$NON-NLS-1$
		try 
		{
			System.out.println( Integer.parseInt(strInteger) );
		} 
		catch (Exception e) 
		{
			// NumberFormatException 
			e.printStackTrace();
			System.out.println( e.getMessage() ); 
		}
	}

}

Should be written as:

public class PB
{
	public static void main(String[] args) 
	{
		java.util.Locale loc = new Locale("ar", "EG"); //$NON-NLS-1$ //$NON-NLS-2$
		String strInteger = "125-"; //$NON-NLS-1$
		try 
		{
			int data = java.text.NumberFormat.getIntegerInstance(loc).parse(
				strInteger).intValue();
			System.out.println(data);
		} 
		catch (Exception e) 
		{
			System.out.println(e.toString());
		}
	}

}

Reference:  No references available.

Rule 27: Avoid_using_parseLong_on_java_lang_Long

Severity:  Medium
Rule:  Avoid calling parseLong() on an object of type java.lang.Long.
Reason:  Avoid calling parseLong() on an object of type java.lang.Long.

Usage Example: 

public class PB
{
	public static void main ( String[] args ) 
	{
		String strLong = "12345-"; // 12345- is -12345 in locale ar_EG //$NON-NLS-1$
		try 
		{
			System.out.println( Long.parseLong( strLong ) );
		} 
		catch (Exception e) 
		{
			// NumberFormatException 
			e.printStackTrace();
			System.out.println( e.getMessage() ); 
		}
	}

}

Should be written as:

public class PB
{
	public static void main(String[] args)
	{
		String strLong = "12345-"; //$NON-NLS-1$
		try 
		{
			long data = java.text.NumberFormat.getNumberInstance(java.util.Locale.FRENCH).parse(strLong).longValue();
			System.out.println(data); 
		} 
		catch (Exception e) 
		{
			System.out.println(e.toString());
		}
	}

}

Reference:  No references available.

Rule 28: Avoid_using_parseShort_on_java_lang_Short

Severity:  Medium
Rule:  Avoid calling parseShort() on an object of type java.lang.Short.
Reason:  Avoid calling parseShort() on an object of type java.lang.Short.

Usage Example: 

public class PB
{
	public static void main ( String[] args ) 
	{
		String strShort = "125-"; // 125- is -125 in locale ar_EG //$NON-NLS-1$
		try 
		{
			System.out.println( Short.parseShort(strShort) );
		} 
		catch (Exception e) 
		{
			// NumberFormatException 
			e.printStackTrace();
			System.out.println( e.getMessage() ); 
		}
	}

}

Should be written as:

public class PB
{
	public static void main(String[] args)
	{
		java.util.Locale loc = new Locale("ar", "AE"); //$NON-NLS-1$ //$NON-NLS-2$
		String strShort = "125-"; //$NON-NLS-1$
		try 
		{
			short data = java.text.NumberFormat.getNumberInstance(loc).parse(strShort).shortValue();
			System.out.println(data); 
		} 
		catch (Exception e) 
		{
			System.out.println(e.toString());
		}
	}

}

Reference:  No references available.

Rule 29: Avoid_calling_toString

Severity:  Medium
Rule:  Do not use toString() Method on Numerical data types in an internationalized environment e.g. Integer, Float..etc
Reason:  Do not use toString() Method on Numerical data types in an internationalized environment e.g. Integer, Float..etc

Usage Example: 

package com.rule;

class Avoid_calling_toString_violation
{
	public void method()
	{
		final long ONE = 1;

		String str = new Long(ONE).toString();	// VIOLATION
	}
}

Should be written as:

package com.rule;

class Avoid_calling_toString_correction
{
	public void method()
  	{
  		final long ONE = 1;
  		String str = NumberFormat.getInstance(Locale.getDefault()).format(ONE);	// CORRECTION
	}
}

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 30: Avoid_using_java_awt_TextArea_directly

Severity:  Medium
Rule:  java.awt.TextArea has certain incompatiblities relating to strings.
Reason:  java.awt.TextArea has certain incompatiblities relating to strings.

Usage Example: 

public class BadAwt
{
	public static void main(String[] args)
	{
		String CJKString = "\u4e1c\u897f\u5357\u5317\u4e2d";
		java.awt.TextArea textarea = new java.awt.TextArea();	// VIOLATION
		textarea.setText(CJKString);
	}
}

Should be written as:

public class BadAwt
{
	public static void main(String[] args)
	{
		String CJKString = "\u4e1c\u897f\u5357\u5317\u4e2d";
		javax.swing.JTextArea textarea = new javax.swing.JTextArea();// CORRECTION	
		textarea.setText(CJKString);
	}
}

Reference:  No references available.

Rule 31: Avoid_using_java_awt_TextField_directly

Severity:  Medium
Rule:  java.awt.TextField has certain incompatiblities relating to strings.
Reason:  java.awt.TextField has certain incompatiblities relating to strings.

Usage Example: 

public class BadAwt
{
	public static void main(String[] args)
	{
		String CJKString = "\u4e1c\u897f\u5357\u5317\u4e2d";
		java.awt.TextField textfield = new java.awt.TextField();	// VIOLATION
		textfield.setText(CJKString);
	}
}

Should be written as:

public class BadAwt
{
	public static void main(String[] args)
	{
		String CJKString = "\u4e1c\u897f\u5357\u5317\u4e2d";
		javax.swing.JTextField textfield = new javax.swing.JTextField();// CORRECTION	
		textfield.setText(CJKString);
	}
}

Reference:  No references available.

Rule 32: Avoid_calling_Time_toString

Severity:  Medium
Rule:  Do not call Time.toString() to avoid issues related to internationalization
Reason:  Do not call Time.toString() to avoid issues related to internationalization

Usage Example: 

package com.rule;

import java.sql.Time;

class Avoid_calling_Time_toString_violation
{
	void printTime(Time t)
	{
		System.out.println(t.toString());	// VIOLATION
	}
}

Should be written as:

package com.rule;

import java.sql.Time;
import java.text.DateFormat;
import java.util.Locale;

class Avoid_calling_Time_toString_correction
{
	void printTime(Time t)
	{
		DateFormat timeFormatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, Locale.getDefault());
		System.out.println(timeFormatter.format(t));		// CORRECTION
	}
}

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 33: Avoid_String_compareTo_method

Severity:  Medium
Rule:  Avoid String.compareTo() method to avoid issues related to internationalization
Reason:  Avoid String.compareTo() method to avoid issues related to internationalization

Usage Example: 

package com.rule;

class Avoid_String_compareTo_method_violation
{
	String name = "myname";

	boolean isSame(String nm)
	{
		return name.compareTo(nm) == 0;		// VIOLATION
	}
}

Should be written as:

package com.rule;

import java.text.Collator;

class Avoid_String_compareTo_method_correction
{
	String name = "myname";

	boolean isSame(String nm)
	{
		Collator myCollator = Collator.getInstance ();
		return (myCollator.compare(name, nm) < 0);		// CORRECTION
	}
}

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 34: Do_not_use_String_compareToIgnoreCase

Severity:  Medium
Rule:  Do not use compareToIgnoreCase in internationalized environment.
Reason:  Do not use compareToIgnoreCase in internationalized environment.

Usage Example: 

package com.rule;
public class Do_not_use_String_compareToIgnoreCase_violation
{
	public void method()
	{
		"String".compareToIgnoreCase("String"); // VIOLATION
	}
}

Should be written as:

package com.rule;
public class Do_not_use_String_compareToIgnoreCase_correction
{
	public void method()
	{
		new MyCollator().compare("String", "String"); // CORRECTION
	}
	
	class MyCollator extends java.text.Collator
	{
		public int compare(String source, String target)
		{
			return 0;
		}
		public java.text.CollationKey getCollationKey(String source)
		{
			return null;
		}
		public int hashCode()
		{
			return 0;
		}
	}
}

Reference:  http://www.javaworld.com/jw-01-1999/jw-01-internationalize-p2.html
http://java.sun.com/j2se/1.3/docs/api/java/lang/String.html#compareToIgnoreCase(java.lang.String)

Rule 35: Avoid_non_internationalized_string

Severity:  Medium
Rule:  Put String literals in constants.
Reason:  Put String literals in constants.

Usage Example: 

package com.rule;

class Avoid_non_internationalized_string_violation
{
	public void showStatus(Label lbl, boolean bStatus)
	{
		if (bStatus)
		{
			lbl.setText("Process was completed succesfully!");
		}
		else
		{			
			lbl.setText("Process failed!");
		}
	}
}

Should be written as:

Create a resource file and load it using ResourceBundle class.
http://java.sun.com/docs/books/tutorial/i18n/resbundle/index.html

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 36: Avoid_String_equals_method

Severity:  Medium
Rule:  Do not use String.equals() method to avoid issues related to internationlization
Reason:  Do not use String.equals() method to avoid issues related to internationlization

Usage Example: 

package com.rule;

class Avoid_String_equals_method_violation
{
	String name = "myname";

	boolean isSame(String nm)
	{
		return name.equals(nm);		// VIOLATION
	}
}

Should be written as:

package com.rule;

import java.text.Collator;

class Avoid_String_equals_method_correction
{
	String name = "myname";

	boolean isSame(String nm)
	{
		Collator myCollator = Collator.getInstance ();
		return (myCollator.compare(name, nm) == 0);	// CORRECTION
	}
}

Reference:  http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html

Rule 37: Always_use_locale_specific_case_conversion

Severity:  Medium
Rule:  When using String.toUpperCase() or String.toLowerCase(), always specify the locale.
Reason:  When using String.toUpperCase() or String.toLowerCase(), always specify the locale.

Usage Example: 

package com.rule;

public class Always_use_locale_specific_case_conversion_violation
{
	private static final String ID = "SOME_ID";
	
	public boolean hasID(String str)
	{
		return ID.toLowerCase().equals(str); // VIOLATION
	}
}

Should be written as:

package com.rule;

import java.util.Locale;

public class Always_use_locale_specific_case_conversion_correction
{
	private static final String ID = "SOME_ID";
	
	public boolean hasID(String str, String langStr)
	{
		Locale l = new Locale(langStr);
		return ID.toLowerCase(l).equals(str); // CORRECTION
	}
}

Reference:  No reference available.

Rule 38: Do_not_use_String_CASE_INSENSITIVE_ORDER

Severity:  Medium
Rule:  Do not use String.CASE_INSENSITIVE_ORDER in internationalized environment.
Reason:  Do not use String.CASE_INSENSITIVE_ORDER in internationalized environment.

Usage Example: 

package com.rule;
public class Do_not_use_String_CASE_INSENSITIVE_ORDER_violation
{
	public void method()
	{
		String.CASE_INSENSITIVE_ORDER.compare("String", "String"); // VIOLATION
	}
}

Should be written as:

package com.rule;
public class Do_not_use_String_CASE_INSENSITIVE_ORDER_correction
{
	public void method()
	{
		new MyCollator().compare("String", "String"); // CORRECTION
	}
	
	class MyCollator extends java.text.Collator
	{
		public int compare(String source, String target)
		{
			return 0;
		}
		public java.text.CollationKey getCollationKey(String source)
		{
			return null;
		}
		public int hashCode()
		{
			return 0;
		}
	}
}

Reference:  http://java.sun.com/j2se/1.3/docs/api/java/lang/String.html#CASE_INSENSITIVE_ORDER