Field/Data Types and Data Typing

Here are notes comparing the intricacies of how various programming environments use and convert among different data types.

Topics this page:

Data Naming Conventions

Literals & Constants, Hex

Strings

Currencies

Wrapper Classes

Type Casting/Conversion

Your comments???

Site Map
About this site

Primitive (Inherent) Datatypes

Storage
Type Java
Datatype Size Value Range
.MIN_VALUE to .MAX_VALUE Default
Value java.
sql.
Types printf Lotus
Script VB
.NET C#
.NET

Unsigned Integer
(Whole numbers, no decimals. positive integer values) All Java primitive numeric data types are signed. 8 bits
1 byte 0 to 2⁸-1
(+255) - - - - Byte b byte

8 bits
1 byte 0 to 2¹⁵-1
(+32,767) - - - - - ushort

32 bits
4 bytes 0 to 2³¹-1
(to 2,147,483,648) 0L - - - - uint

64 bits
8 bytes 0 to 2⁶³ - 1 0UL - - - ulong

Signed Integer
(Whole numbers, no decimals. Half the range handles negative integer values, the remaining half handles positive integer values)
byte
8 bits
1 byte -2^-7 to 2⁷-1
( -128 to +127 ) 0 TINYINT - - - sbyte
.SByte

short
16 bits
2 bytes -2^-15 to 2¹⁵-1
( -32,768 to +32,767 ) 0 SMALLINT - Integer Short short
.int16

int
32 bits
4 bytes -2^-31 to 2³¹
(±2,147,483,648 ) 0 INTEGER %d
%.nd - Single int
.int32

long
64 bits
8 bytes -2⁶³ to +2⁶³ - 1 0L BIGINT - Long long
.int64

IEEE 754 Signed Floating point precision
float
32 bits
4 bytes -1.4e^-45 to +3.4e³⁸
-1.40239846^-45 to
+3.40282347³⁸
[7 significant digits] 0.0F REAL %f
%m.nf Single Integer
Int32 float
.Single

double
64 bits
8 bytes -4.9e^-324 to +1.797e³⁰⁸
-4.94065645841246544-324^-324 to
+1.79769313486231570³⁰⁸
[15-16 significant digits] 0.0D FLOAT,
DOUBLE Double Long
Int64 double
.Double

- - 128 bits
16 bytes -1.0x10^-28 to +1.0x10²⁸
[28 significant digits] 0M - - - - Decimal

A Single two-byte Unicode character
char
16 in Java
8 in C 0 to 2¹⁶-1
( 0 to 65,535 )
\u0000 to \uFFFF \u0000
(null) - %c - Char
2 bytes char
.Char

-
boolean
1 bit true or false false BIT - - 2 bytes bool
.Boolean

A sequence of plain-text characters In C, an array of characters.
In Java, a string of characters is NOT considered a primitive data type but a complex data type implemented as a Java class. - %s
%ns String -

Date (In VB.NET, from January 1, 0001 to December 31, 9999) - - - - Date
8 bytes

MS .NET Framework Bittable

When data is transferred between Microsoft's dot Net Framework and unmanaged (DCOM) code (through P/Invoke), data types which do have the same in-memory representations -- known as non-blittable types -- require conversion (marshaling) as they are passed back and forth. These are Boolean, Char, String, Object, and arrays of these types.

C# Number Formatting

Character Description Example Code Output

C or c Currency Console.Write("{0:C}",2.5);
Console.Write("{0:C}",-2.5); $2.50
($2.50)

D or d Decimal Console.Write("{0:D5}",25); 00025

E or e Scientific Console.Write("{0:E}",250000); 2.500000E+005

F or f Fixed-point Console.Write("{0:F2}",25);
Console.Write("{0:F0}",25); 25.00
25

G or g General Console.Write("{0:G}",2.5); 2.5

N or n Number Console.Write("{0:N}",2500000); 2,500,000.00

X or x Hexadecimal Console.Write("{0:X}",250);
Console.Write("{0:X}",0xffff); FA
FFFF

The presentation of numbers (for the current culture) can be automatically formatted by specifying these codes within curly braces, listed in alphabetical order:

public void WriteAsBytes(int value){
	bytes[] = BitConverter.GetBytes(value);
	foreach(byte b in bytes){
		Console.Write("0x{0:X2}", b);
		string message = String.Format("0x{0:X2}", b);
		Debug.Write(message);
	}
	Debug.WriteLine("");
}

If the above code is called by WriteAsBytes(32), then this would display 0x20 0x00 0x00 0x00.

Parsing strings is the opposite process from formatting.

Implicit conversions & Casting

This table ablove lists data types from smallest to largest such that implicit conversions can flow from top to bottom, but not upstream.

byte > short > int > long > float > double

To explicitly cast to a smaller datatype in Java:

myInteger = (int) myLongInteger

java automatically casts to a larger datatype, but will throw a fit rather than going smaller.

To expliciitly cast to a smaller datatype in C#:

long longValue = Int64.MaxValue; 
int intValue = (int) longValue;

Note the .MaxValue property avialable only to C# programmers.

Also, with C#, unsigned can go signed, but not the other way.

Value

Reference

Value types Reference types

allocated on the stack allocated on the heap

Directly contain their data Store references to their data (known as objects)

Each has its own copy of data Two reference variables can reference same object

Operations on one cannot affect another Operations on one can affect another

"Boxing" transforms a value type to a reference type by creating a temporary reference type "box" on the heap.

A similar table

To convert a String to a double:

doubleOffset = Double.valueOf( offset ).doubleValue();

To convert a String to a floating point in Ruby (since the language is object oriented):

"1".to_i + 1

Object Identifier Naming Conventions

terse names

Instance identifiers (names) cannot be a Word Reserved for Java. Prefix to field names for indicating how the datum is stored:

include file adovbs.inc provides constants for values identifying data type:

adInteger 3
adSingle 4
adDouble 5
adCurrency 6
adDate 7
adBoolean 11
adVariant 12
adBinary 128
adChar 129
adNumeric 131
adDBDate 133
adDBTime 134
adDBTimeStamp 135

Terse	Primitive or Object Data Type	Example Component
a	array	aObjectProperties()
con	connection to a database
d,dbl	floating point double number
evt	event
e	Exception
f	frame
g	graphics	Swing paintComponent()
gi	global integer	giUsersLoggedInNow
h	handle (long)	hWnd
i	integer	iRowCount
l	long	lDistance2Pluto
o	object	oFlowchart
p	parameter
pS	printStream
ptr	pointer	float* ptrX1; ptrX1 = &ptrX2;
r	reference by Java	like a C pointer
s, str	string	sUserPassword
RS	Record Set from a database query
sa	string array	sa
seg	segment in database
tbl	table in database
u	user-defined type	uSmoots
v	variant	vPropertyValue
v	vector
w	window

Data Types

Jave primitive data type declarations for char, int, float, long, double are similar to the C language:
UML Data Types
Java reference data types include array, interface, and class.
Scalar data is atomic - not made up of other variable components. such as PL/SQL record and table.
Data types can be extended to create new data types which inherit from existing data types.
The PrintStream instance writes String instances using system print & println methods from the SDK's java.util class. import ... FileOutputStream fOS = new FileOutputStream( filestream ); PrintStream pS = new PrintStream( fOS ); pS.print("I am writing to a file"); pS.println("Just like System.out"); fOS.close( );
Each variable defined within a class is considered a member of that class. So Instance Variables are also referred to as Member data or Properties. Class variables, which can be shared among all objects of its class, are defined using the static keyword.
The behavior of an object is determined by instance variables (mouseover = on, etc.) The Java Beans API considers methods whose names begin with set or get to represent special design patterns for manipulating the properties of an object.
The current values of an object defines its state.
An object can change its state by sending it a message, invoking its methods, or calling its member functions.

Numeric Sign Default

char

This is dependent on the design of the processor used by your compiler.

Early PDP-11 and VAX-11 computers had automatic sign extention of char. This means that the range of char is from -128 through to +127. The trend is toward unsigned char as the default.

        char a;
        unsigned char b;

        a = b = 128;
        a >>= 1;
        b >>= 1;
	printf ( "\nChar is %ssigned by default.\n\n", 
		a == b ? "un" : "" );
        }

SQL Data Types

Data Type	Usage	Max Bytes
binary	Fixed length	8,000
bit	value 1 or 0	1
char	Fixed length	8,000
nchar	Fixed length two-byte "national" Unicode	4,000

blocks

Oracle-SQL has no data type boolean. The Oracle character set can be displayed by using these SQL statements:

SQL> select * from nls_database_parameters; SQL> select * from nls_database_parameters where parameter like '%CHARACTERSET%';

BLOBs and Other SQL3 Datatypes

Java Type	SQL Type from java.sql.Types
java.sql.Date	DATE
java.sql.Time	TIME
java.sql.Timestamp	TIMESTAMP
java.sql.Blob	BLOB
java.sql.Clob	CLOB
java.sql.Array	ARRAY
java.sql.Ref	REF
java.sql.Struct	STRUCT
java.math.BigDecimal	NUMERIC
java.lang.String	VARCHAR or LONGVARCHAR
byte[] array	VARBINARY or LONGVARBINARY

BLOB

CLOBs

Type conversion between SQL and Java in Castor

Unlike C or C++, Java primitive (inherent) datatypes are portable because they each occupy exactly the same amount of memory on all Java-supporting machines.

Type Conversion Functions

variant

Java does not have a method to convert boolean data types (False == 0) to numeric data type.

Roedy Green presents Java type conversion code as a HTML table or a Java 1.4 applet with source code that considers implied encoding translation when interconverting byte [] and String. "8859_1" encoding simply chops the high byte off or pads the high byte with 0s.

When arithmetic is performed using two variables of different types, the value of the variables with the norrower type is promoted to wider type. This is called arithmetic-promotion conversion.

Built-in Javascript Function Action

escape(charstring) Returns the conversion of charstring into a form that displays in the browser without HTML markup.
unescape(charstring) Returns the conversion of charstring back into a form that displays in the browser with HTML markup (the opposite of escape).
eval(codestring) Evaluates codestring as JavaScript code, returning anything that JavaScript returns.
isNaN(numvalue) Returns true if numvalue is not a number, otherwise returns false — used with parseFloat and parseInt.
parseFloat(numstring) Returns numstring converted to a floating point number. If it cannot be converted, returns the reserved value NaN.
parseInt(numstring) Returns numstring converted to an integer. If it cannot be converted, returns the reserved value NaN.

Literals

Literal

Data Type Java Coding Sample Note

Boolean boolean isBig = true;
boolean isSmall = false; Identifier prefix is "is". True or false value spec is not encased.

Character char c = "w";
char c1 = '\u1234'; Single quotes are used to encase value spec

Integer (32 bit) int X = 256;

Long Integer (64 bit) long longL = 24445345L; Don't use lower-case l to avoid confusion.

Single Float float floatA = 1.32E+2F; Don't use lower-case f to avoid confusion.

Double Float float floatB = 1.32E+2D; Don't use lower-case d to avoid confusion.

Because, by default, a numeric literal is either a double or an int, double and float literals are declared a special way. So remember to append the symbol shown in the "Default Value" column above.

To avoid confusion, use the upper-case code (L) even though the lower case (l) is valid.

Constants

Constant

$\pi$

Math.PI

M_PI

~=2.718281828459045... — Leonhard Euler's number e, the base of natural logarithms, such that ln(e^1) = 1 defined by
Math.E in Java and M_E in C's Math library.

The names of constants are by convention UPPER CASE. However, in Java boolean true and false are in lower case.

The C programming language defines these constants as double datatypes in its ISO C99 Standard: 7.12 Mathematics C /usr/include/Math.h library:

Constant Description BSD/GNU Name BSD/GNU Value

The maximum value of a single-precision floating-point number. HUGE 3.40282347e+38F

Positive infinity: +infinity on machines that support IEEE-754 and DBL_MAX otherwise. HUGE_VAL 1e500

The maximum value of a non-infinite single-precision floating point number. MAXFLOAT 3.40282347e+38F
3.40282346638528860e+38

The base of natural logarithms (e). M_E
M_El 2.7182818284590452354
2.7182818284590452353602874713526625L

The base-2 logarithm of e. M_LOG2E
M_LOG2El 1.4426950408889634074
1.4426950408889634073599246810018921L

The base-10 logarithm of e. M_LOG10E M_LOG10El 0.43429448190325182765
0.4342944819032518276511289189166051L

The natural logarithm of 2. M_LN2
M_LN2l 0.69314718055994530942
0.6931471805599453094172321214581766L

The natural logarithm of 10. M_LN10
M_LN10l 2.30258509299404568402
2.3025850929940456840179914546843642L

$\pi$ . M_PI
M_PIl 3.14159265358979323846
3.1415926535897932384626433832795029L

$\pi$ /2 (Pi divided by 2). M_PI_2
M_PI_2l 1.57079632679489661923
1.5707963267948966192313216916397514L

$\pi$ /4 (Pi divided by 4). M_PI_4
M_PI_4l 0.78539816339744830962
0.7853981633974483096156608458198757L

1/ $\pi$ (inverse of Pi). M_1_PI
M_1_PIl 0.31830988618379067154
0.3183098861837906715377675267450287L

2/ $\pi$ (2 divided by Pi). M_2_PI
M_2_PIl 0.63661977236758134308
0.6366197723675813430755350534900574L

2/ $\sqrt{\pi}$ (2 divided by the square root of Pi). M_2_SQRTPI
M_2_SQRTPIl 1.12837916709551257390
1.1283791670955125738961589031215452L

The positive square root of 2. M_SQRT2
M_SQRT2l 1.41421356237309504880
1.4142135623730950488016887242096981L

The positive square root of 1/2. M_SQRT1_2
M_SQRT1_2l 0.70710678118654752440
0.7071067811865475244008443621048490L

Bessel function limit of significance pi*2**52 — the maximum absolute value of the ordinate before we assume total loss of significance, per ISO/IEC 10967-1:1994 Information Technology - Language Independent Arithmetic - Part 1: Integer and floating-point arithmetic. Defined in <values.h> X_TLOSS 1.41484755040568800000e+16

Other constants:

Constant Description BSD/GNU Name BSD/GNU Value

Avogadro's number N_A 6.025 X 10²³g mole^-1

Planck's constant h 6.626068 X 10^-34 Js (Joule seconds)

Free space velocity of light c 3.00 X 10⁸ms^-1

Electron charge e 1.602 X 10^-19C

Electron rest mass m_e 9.11 X 10^-13kg

Specific electron charge e/m 1.760 X 10¹¹Ckg^-1

Atomic mass unit amu 1.660 X 10^-27kg

Proton rest mass m_p 1.6724 X 10^-27kg

Stefan-Boltzmann constant sigma 5.67 X 10^-8Jm^-2K^-4S^-1

Universal gas constant R 8.31JK^-1g mole^-1

Universal gravitation constant G 6.673 x 10^-11Nm²kg^-2

Boltzmann constant k 1.381 x 10²³JK^-1

Java does not automatically declare φ (Greek letter Phi pronounced "fee") ~=1.61803... — (1+the square root of 5)/2 — the basis for the Golden Rectangles and Spirals found in nature (sunflowers, nautilus shells, and the formation of galaxies). Phi is the limit of the ratios of the numbers in the Fibonnacci sequence, where each number is the sum of the two before it (q = 1 + 1/q) for

Dividing each number by the number before it (eg., 55/34) yields Phi (through convergence by oscillation).

To define constant PHI in Java:

private static final int PHI = 1.61803;

To define constant PHI in Oracle SQL:

PHI := 1.618034;

2, 3, 4, 5, 7, 9, 12, 16, 21

from the formula (1/p + 1/p² or p³ - p - 1), called the Padovan sequence series after architect Richard Padovan of Padua (100 miles from Pisa where Fibonacci lived) [Nexus Network Journal, vol 4, no. 3 (Summer 2002)]

The ratio between adjacent numbers yield a constant ratio of 1.324718. This was nicknamed the "Plastic Number" in 1928 by its discoverer Dom Hans Van Der Laan because it generates amazing, interconnected commensurate design patterns, many of which suggest 3D applications.

Hex

a leading 0 (zero) means octal;
a leading 0x or 0X means Hexadecimal, such as 0xFFFFFF

For example, decimal 63 is written as '63' in decimal, '077' in octal, or 0x3F, 0X3F, 0x3f, or 0X3f in hexadecimal format. All integer constants are treated as 32-bit integers. Negative numbers are obtained by prefacing the integer constant with the unary negation operator (-).

Java Literal References defined in the java.lang package are used to test Bit Patterns of returned values defined in IEEE 754:

Erroneous calculation	IEEE 754 return value
Divide by zero	n/a - ArithmeticException is thrown
???	Float.NaN
???	Double.NaN
square root of a negative number	Float.NEGATIVE_INFINITY
	Float.POSITIVE_INFINITY
	Double.NEGATIVE_INFINITY
	Double.POSITIVE_INFINITY

These literals are considered non-ordinal. Tthe comparison x == Float.NaN returns false even if x contains Float.NaN. So test for them using static methods Float.isNaN(float) or Double.isNaN(double) from the java.lang package.

Method Constant

.isDigit -

.isLetter -

.isLetterOrDigit -

.isLowerCase .LOWERCASE_LETTER

.isUpperCase .UPPERCASE_LETTER

.isSpaceChar -

.isDefined in Unicode -

.isWhitespace
.isSpaceChar
.isSpace -

- .CONNECTOR_PUNCTUATION

- .MATH_SYMBOL

To determine the properties, use the java.lang.Character class in the SDK:

char ch;
//
if (Character.isLetter(ch));
//
if (Character.getType('a') == Character.LOWERCASE_LETTER);

With JavaScript, isNaN(numvalue) returns true if numvalue from parseFloat and parseInt is Not a Number.

String Objects

char* s,t; const char* cs, ct;
c is an char converted to type int; int n;

Code Usage

char *strcpy(s,ct) copy ct into s, including ``\0''; return s

char *strncpy(s,ct,n) copy ncharcater of ct into s,
return s

char *strncat(s,ct) concatenate ct to end of s;
return s

char *strncat(s,ct,n) concatenate n character of ct to end of s,
terminate with ``\0''; return s

int strcmp(cs,ct) compare cs and ct;
return 0 if cs=ct, <0 if cs0 if cs>ct

char *strchr(cs,c) return pointer to first occurence of c in cs
or NULL if not encountered

size_t strlen(cs) return length of cs

Without special operators to manipulate strings, the C language manipulates strings using routines in the standard string library string.h and pointers. The name of an array is a pointer to its first element.

char *string_1 = "Hello"; char string_2[] = "Hello"; // compiler calculates char string_3[6] = "Hello"; // 5+null character

The C language reads a string until it encounters a null character (\0). So a trick C programmers use to quickly truncate a string is to inserting a null character in that string causes all remaining characters in that string to be ignored.

strcat(dest, src); is therefore risky.
To code defensively:

assert(dest != NULL); assert(src != NULL); strncat(dest, src, sizeof(dest)-strlen(dest)-1); dest[sizeof(dest)-1] = '\0';

strcpy(dest, src); is risky.
To code defensively,

assert(dest != NULL); assert(src != NULL); strncpy(dest, src, sizeof(dest));

Unlike later versions of the javac compiler, awareness of assert is disabled by default in version 1.4. So you will have to activate it as part of the compilation command:

javac -source 1.4 com/myDirectory/MyClass.java

Java

tostring()

String s1 = "something";

String s1 = new String( "something" );

Java does not actually create another object if both s1 and s2 have the same value. So initialize strings with different values or use StringBuffer.

The use of "==" between two strings will always return false because that operator evaluates the addresses rather than the value of two objects.
So use one of these string methods to test the difference between two string objects:

if( s1.equals(s2) )
if( s1.equalsIgnoreCase(s2) )
if( s1.compareTo(s2) < 0 )

Best of all, make localized comparisons using the default locale:

Collator myCollator = Collator.getInstance();
if( myCollator.compare("abc", "ABC") < 0 )

To compare the same key several times, or to compare strings which are likely to be different even from the first characters, convert objects for bitwise comparison using CollationKey

Collator myCollator = Collator.getInstance();
CollationKey[] keys = new CollationKey[3];
keys[0] = myCollator.getCollationKey("Tom");
sort( keys );
...
if( keys[i].compareTo( keys[j] ) > 0 )

Insteading of hard-coding strings in programs, use a resource file method that looks up the value of the string. This allows you to dynamically change the text without recompiling.

For best performance, such as within tight running loops threads, 1) declare the size of strings, 2) use StringBuffer, and 3) append to strings rather than concatenating them with the + plus operator. Examples:

StringBuffer sb = new StringBuffer(50); sb.append("Hello"); sb.append("there");

Unlike a String, StringBuffers are mutable (can be modified).

Currency Data Type

Currency

function

Dates

java.lang._____.TYPE

java.util.Date

Programming Date, Time, and Calendar Functions

Wrapper Classes

Each primitive class in Java has an associated Wrapper class, which simply contains the primitive value.

The primitive name is usually the lowercase version of the wrapper, except for char and int.

A Wrapper class object is created by calling the Wrapper class constructor with the appropriate primitive value as a parameter to the constructor. For every Wrapper class except character, you can also construct a Wrapper class object by passing in a string representation of the value into the constructor. For example:

int MyInt = 409;
Integer intObject = new Integer(MyInt);
Integer intObject2 = new Integer("409");

If the string you pass to the constructor is not formatted correctly for the Wrapper class type, the constructor will throw a NumberFormatException exception error. equals method provided by the base Object class. For example, based on the previous example, the following would be true:

if(intObject.equals(intObject2))

To get a primitive value back out of a wrapper, use a method provided by each Wrapper class object:

Byte -> public byte byteValue();

Any of the numeric Wrapper classes can also be retrieved into any numeric type. The Wrapper classes include a valueOf() method which accepts a string parameter representing a value, then constructs and returns a Wrapper class instance of the same class.

Field/Data Types and Data Typing

Primitive (Inherent) Datatypes

byte

short

int

long

float

double

char

boolean

MS .NET Framework Bittable

C# Number Formatting

Implicit conversions & Casting

Object Identifier Naming Conventions

Data Types

Numeric Sign Default

SQL Data Types

binary

bit

char

nchar

BLOBs and Other SQL3 Datatypes

Type Conversion Functions

Literals

Constants

Hex

String Objects

Java

Currency Data Type

Dates

Wrapper Classes