What is primitive types in Java?

In Java, primitive types are the most basic data types that store simple values. They are not objects and represent single values directly. Java has eight primitive types:

  • byte: 8-bit signed integer.
  • short: 16-bit signed integer.
  • int: 32-bit signed integer.
  • long: 64-bit signed integer.
  • float: 32-bit floating-point.
  • double: 64-bit floating-point.
  • char: 16-bit Unicode character.
  • boolean: Represents a value of either true or false.

Here is an example of declaring and using primitive types in Java:

// Example of primitive types in Java public class PrimitiveTypesExample { public static void main(String[] args) { byte byteValue = 100; short shortValue = 10000; int intValue = 100000; long longValue = 100000L; float floatValue = 10.5f; double doubleValue = 10.99; char charValue = 'A'; boolean booleanValue = true; System.out.println("Byte Value: " + byteValue); System.out.println("Short Value: " + shortValue); System.out.println("Int Value: " + intValue); System.out.println("Long Value: " + longValue); System.out.println("Float Value: " + floatValue); System.out.println("Double Value: " + doubleValue); System.out.println("Char Value: " + charValue); System.out.println("Boolean Value: " + booleanValue); } }

primitive types Java data types byte short int long float double char boolean

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?