text: How to Convert a Long Primitive Data Type to a String Type in Java?
  In every Java program, you will encounter several primitive data types — byte, short, int, long, float, double, boolean or char—declared and manipulated. They drive the inner workings of most Java applications. String is not a data type but a class in java that represents character strings.
  New to Java? Learn to code in Java with a course in udemy.com
  int x = 5; // integer variable declaration double d = 56.7; // double variable declaration String s = “hello45678%”; // String object declaration
  In Java, the primitive data types can be cast to a String. This means variable x and d in the above example can be turned to a String object and assigned to a String variable. This can be achieved in more than one ways.
  Convert Java Long to String
  One way to cast a long primitive type to String is by using String concatenation. The ‘+’ operator in java is overloaded as a String concatenator. Anything added to a String object using the ‘+’ operator becomes a String.
  For example:
  class longToString1 { Public static void main(String[] arg) { long num1 = 4587; // declare a long variable String longString = “ ” + num1; // concatenate the long and an empty String System.out.println(longString); } }
  OUTPUT:
  4587
  In the above example, the output “4587” is a String type and is no longer a long.
  In the concatenation step, you can include an actual string instead of an empty string.
  So if we modify that step to the following code:
  String longString = “hello” + num1;
  This modification will give the output: hello4587. But since we only want the string form of the long variable, we can use just an empty String.
  A second method to convert long to String is by using a static method of the class Long. The class Long is one of the wrapper classes in java that lets you wrap a primitive data type into an object. There is a matching wrapper class for every primitive type. Following are primitive data types and their corresponding wrapper classes:
  char – Character
  boolean – Boolean
  byte – Byte
  int – Integer
  double – Double
  short – Short
  long – Long
  float – Float
  Wrapper classes are very useful when you want to add primitives to Collections. You may want to add long variables to an arraylist. An arraylist, however, will not accept long variables. In such cases, you can wrap the long variable with a wrapper— turn a long variable to a Long object. The arraylist would now accept the long variables.
  For example:
  Wrapping a long variable:
  long x = 34533355;
  Long xWrap = new Long(x);
  Unwrapping a Long object:
  long xUnwrap = xWrap.longValue();
  In Java 5.0 and later versions, the wrapping and unwrapping is done automatically. A concept called autoboxing takes care of the hassle of manually wrapping and unwrapping primitive data types that are supposed to go to a collection’s class.
  Learn important Java concepts through a course in Udemy
  Wrapper classes have several static methods that will allow you to change a primitive variable to a String. A Java long type can be converted to String using the toString(long x).
  For example:
  class longToString2 { Public static void main(String[] arg) { long num2 = 4587; // declare a long variable String longString2 = Long.toString(num2); // convert the long variable num2 to a String System.out.println(longString2); } }
  OUTPUT:
  4587
  If you declare a variable of the type Long, you can convert it to a String object by using the simple toString().
  The Long class along with other wrapper classes is included in the java.lang package. This means you will not have to import any class in order to use the methods of the wrapper classes.
  The toString method of Long class also has an additional overloaded method: toString(long i, int radix).
  It is defined as: public static String toString(long i, int radix)
  The method takes in two arguments — a long and an int — and returns a String type.
  Applications of Java long to String by overriding toString()
  In java, the toString() method is defined in the Object class, which means you do not have to extend any class in order to use the toString() in your class. The toString() method is very useful to provide concise and clear information about an object. You can fully implement this method by overriding it in your class and creating your own version that can display detailed information about any object in your class.
  Consider the following example:
  Let’s say you are building a bank-related application that stores customer information. The application will contain several long variables like bank account numbers and other numeric codes. You can build a toString version that displays all details of a customer as one String object.
  import java.util.*; class CusDetails { String name; // declare variables long acc; long SortCode; public CusDetails(String s, long a, long b) // take in customer details through constructor { this.name = s; this.acc = a; this.SortCode = b; } @Override // although not necessary, using the @override symbol is considered good practice public String toString() // override the Object class’s toString method. { return "Name of the customer: " + this.name + "\nBank Account number:" + this.acc + "\nBank Code: " + this.SortCode + "\n\n"; } } class PrintDetails{ public static void main(String[] arg) { ArrayList<CusDetails> cd = new ArrayList(); cd.add(new CusDetails("Ann", 34567778, 3466)); cd.add(new CusDetails("Mary", 23434536, 2353)); Iterator<CusDetails> itr = cd.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } }
  OUTPUT:
  Name of the customer: Ann
  Bank Account number: 34567778
  Bank Code: 3466
  Name of the customer: Mary
  Bank Account number: 23434536
  Bank Code: 2353
  Notice in the above example that we did not have to explicitly call the toString method because the System.out.print method implicitly calls it.
  Learn how to use built-in methods and classes in Java API through a java programming course
  How to Convert a String into a long in Java?
  The String object on the other hand can be converted to primitive data types.
  The Long class includes methods to convert String to long. Other wrapper classes such as Integer, Double, Float or Boolean can also convert a String to their corresponding types provided; the string object is actually a textual representation of the specific type.
  Let’s look at the following example.
  Class ParseString { Public static void main(String[] arg) { String s = “364678967”; // declare a string variable long num = Long.parseLong(s); // call the parseLong method of class Long and pass the //string as argument. System.out.println(num); }}
  OUTPUT:
  364678967
  The above output is a long variable and can now be manipulated and used as a number in an expression.
  Recommended Articles
  How to Format Strings in Java
  How to Convert Characters to Strings in Java
  How to Learn Java Programming
  Learn To Write Java With Java Code Examples
  Basics of Java: Learn Java Coding
  Top courses in Java
  Java students also learn
  Empower your team. Lead the industry.
  Get a subscription to a library of online courses and digital learning tools for your organization with Udemy for Business.