What's the Difference Between Primitive and Reference Types

What's the difference between primitive and reference types?

These are the primitive types in Java:

• boolean
• byte
• short
• char
• int
• long
• float
• double

All the other types are reference types: they reference objects.

This is the first part of the Java tutorial about the basics of the language.

Primitive value vs Reference value

A variable can hold one of two value types: primitive values or reference values.

• Primitive values are data that are stored on the stack.
• Primitive value is stored directly in the location that the variable accesses.
• Reference values are objects that are stored in the heap.
• Reference value stored in the variable location is a pointer to a location in memory where the object is stored.
• Primitive types include Undefined, Null, Boolean, Number, or String.

The Basics:

Objects are aggregations of properties. A property can reference an object or a primitive. Primitives are values, they have no properties.

Updated:

JavaScript has 6 primitive data types: String, Number, Boolean, Null, Undefined, Symbol (new in ES6). With the exception of null and undefined, all primitives values have object equivalents which wrap around the primitive values, e.g. a String object wraps around a string primitive. All primitives are immutable.

Primitive type and reference type objects

A primitive type is an object which the language has given a
predefined value

Why? Even references can have predefined values as noted. For primitive (built in) types you may want to say these are types that a language provides built in support for. What your instructor might be glad to hear about is if you say that most primitive types are also value types in C# and you might want to discuss value types semantics (e.g., value type variable directly contains value - whereas a reference variable just contains an address to some object in memory).

About reference types again you may say that a reference variable doesn't contain the value or object directly - rather just a reference to it. Now again you may want to discuss reference semantics. For example if you have two reference variables pointing to same object - and you change the object from one reference change will be visible from another reference too - because both references point to same object. This is not the case with value types. If you assign same value type object to two different value type variables and change one variable - this change will not be visible in the second value type variable because each of them holds the value directly (e.g. each will have its own copy of the value type variable it was assigned to).

Static types you have already described.

When to use primitive and when reference types in Java

In which case should you use primitive
types(int) or reference types
(Integer)?

As a rule of thumb, I will use a primitive (such as int) unless I have to use a class that wraps a primitive.

One of the cases were one must use a wrapper class such as Integer is in the case of using generics, as Java does not support the use of primitive types as type parameters:

List<int> intList = new ArrayList<int>();               // Not allowed.
List<Integer> integerList = new ArrayList<Integer>();   // Allowed.

And, in many cases, I will take advantage of autoboxing and unboxing, so I don't have to explicitly perform conversions from primitives to its wrapper class and vice versa:

// Autoboxing will turn "1", "2", "3" into Integers from ints.
List<Integer> numbers = Arrays.asList(1, 2, 3); 

int sum = 0;

// Integers from the "numbers" List is unboxed into ints.
for (int number : numbers) {
  sum += number;
}

Also, as an additional note, when converting from primitives to its wrapper class objects, and unique instances of objects are not necessary, use the valueOf method provided by the wrapper method, as it performs caching and return the same instance for a certain value, reducing the number of objects which are created:

Integer i1 = Integer.valueOf(1);   // Prefer this.
Integer i2 = new Integer(1);       // Avoid if not necessary.

For more information on the valueOf methods, the API specification for the Integer.valueOf method can serve as a reference for how those methods will behave in the wrapper classes for primitives.

Difference between primitive value and primitive type?

Hmm ... maybe you have a confusion with "primitive type". Most of the time "primitive type" (or primitive data type) and "primitive values" are used to speak the same things: boolean, null, undefined ...

But you can check these links to know more about it and find a better answer:

• Official Primitive docs
• Primitive values vs Reference values

what is difference between data type and primitive type in javascript?

Types represent groups or sets of values. Some have only one value, e.g. the Undefined Type has exactly one value: undefined, the Null Type also has exactly one value: null. The Boolean Type has two values: true and false.

Other Types have lots of possible values, such as the String Type and Number Type.

A primitive value represents a value at the lowest level, e.g. 3 is a primitive value of the Number Type, "a" is a primitive value of the String Type.

Objects belong to the Object Type, they are not primitives. Objects may have properties whose values are either primitives or references to other objects.

What is the difference between a primitive class and primitive data type?

They're confusing their vernacular here.

A primitive is a data type which is not an object. int, float, double, long, short, boolean and char are examples of primitive data types. You can't invoke methods on these data types and they don't have a high memory footprint, which is their striking difference from classes.

Everything else is a class (or class-like in the case of interfaces and enums). Pretty much everything that begins with an upper-case letter, like String, Integer are classes. Arrays also classify as not-primitives, even though they may hold them. int[] isn't a primitive type but it holds primitives.

The only thing that could realistically come close would be the wrapper classes, as explained by the JLS, but even then, they're still classes, and not primitives.

What are Java's primitive types?

In Java, every variable has a type declared in the source code. There are two kinds of types: reference types and primitive types. Reference types are references to objects. Primitive types directly contain values. There are 8 primitive types:

• byte
• short
• int
• long
• char
• float
• double
• boolean

---

Related Topics