"SomeType @ 2f92e0f4" प्राप्त किए बिना मैं अपने जावा ऑब्जेक्ट को कैसे प्रिंट करूं?
मेरे पास एक वर्ग इस प्रकार है:
public class Person {
private String name;
// constructor and getter/setter omitted
}
मैंने अपनी कक्षा का एक उदाहरण छापने की कोशिश की:
System.out.println(myPerson);
लेकिन मैं निम्नलिखित उत्पादन मिल गया: com.foo.Person@2f92e0f4
।
जब मैंने Person
वस्तुओं के एक सरणी को प्रिंट करने की कोशिश की तो एक समान बात हुई :
Person[] people = //...
System.out.println(people);
मुझे आउटपुट मिला: [Lcom.foo.Person;@28a418fc
इस आउटपुट का क्या मतलब है? मैं इस आउटपुट को कैसे बदलूं ताकि इसमें मेरे व्यक्ति का नाम शामिल हो? और मैं अपनी वस्तुओं के संग्रह को कैसे प्रिंट करूं?
नोट : यह इस विषय के बारे में एक विहित क्यू एंड ए के रूप में करना है।
जवाब
पृष्ठभूमि
सभी जावा ऑब्जेक्ट में एक toString()
विधि होती है, जिसे जब आप कोशिश करते हैं और ऑब्जेक्ट को प्रिंट करते हैं, तो इसे लागू किया जाता है।
System.out.println(myObject); // invokes myObject.toString()
इस विधि को Object
कक्षा में परिभाषित किया गया है (सभी जावा वस्तुओं का सुपरक्लास)। Object.toString()
विधि एक काफी बदसूरत देख स्ट्रिंग, वर्ग, एक का नाम से बना देता है @
प्रतीक और hashCode हेक्साडेसिमल में वस्तु की। इसके लिए कोड इस तरह दिखता है:
// Code of Object.toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
इस तरह के रूप में एक परिणाम के रूप में com.foo.MyType@2f92e0f4
समझाया जा सकता है:
com.foo.MyType
- क्लास का नाम, यानी क्लासMyType
पैकेज में हैcom.foo
।@
- एक साथ तार जुड़ता है2f92e0f4
वस्तु का हैशकोड।
सरणी वर्गों का नाम थोड़ा अलग दिखता है, जिसे जावदोस्क में अच्छी तरह से समझाया गया है Class.getName()
। उदाहरण के लिए, [Ljava.lang.String
इसका मतलब है:
[
- एक एकल आयामी सरणी (के रूप में[[
या[[[
आदि के विपरीत )L
- सरणी में एक वर्ग या इंटरफ़ेस होता हैjava.lang.String
- सरणी में वस्तुओं का प्रकार
उत्पादन को अनुकूलित करना
कुछ अलग जब आप कॉल मुद्रित करने के लिए System.out.println(myObject)
, आप चाहिए ओवरराइडtoString()
अपनी खुद की कक्षा में विधि। यहाँ एक सरल उदाहरण है:
public class Person {
private String name;
// constructors and other methods omitted
@Override
public String toString() {
return name;
}
}
अब यदि हम प्रिंट करते हैं Person
, तो हम उनका नाम देखते हैं com.foo.Person@12345678
।
ध्यान रखें कि किसी वस्तु को स्ट्रिंग में बदलने के लिए toString()
सिर्फ एक तरीका है। आमतौर पर इस आउटपुट को स्पष्ट और संक्षिप्त तरीके से अपनी वस्तु का पूरी तरह से वर्णन करना चाहिए। toString()
हमारी Person
कक्षा के लिए बेहतर हो सकता है:
@Override
public String toString() {
return getClass().getSimpleName() + "[name=" + name + "]";
}
जो प्रिंट होगा, जैसे Person[name=Henry]
,। यह डीबगिंग / परीक्षण के लिए डेटा का वास्तव में उपयोगी टुकड़ा है।
यदि आप अपनी वस्तु के सिर्फ एक पहलू पर ध्यान केंद्रित करना चाहते हैं या इसमें बहुत सारे जैज़ स्वरूपण शामिल हैं, तो आप इसके बजाय एक अलग विधि को परिभाषित करना बेहतर हो सकते हैं, जैसे String toElegantReport() {...}
।
आउटपुट को स्वतः उत्पन्न करना
कई आईडीईtoString()
कक्षा में खेतों के आधार पर ऑटो-जेनरेटिंग पद्धति के लिए समर्थन प्रदान करते हैं । उदाहरण के लिए ग्रहण और इंटेलीज के लिए डॉक्स देखें ।
कई लोकप्रिय जावा लाइब्रेरी इस सुविधा को प्रदान करते हैं। कुछ उदाहरणों में शामिल हैं:
वस्तुओं का मुद्रण समूह
तो आपने toString()
अपनी कक्षा के लिए एक अच्छा बनाया है । यदि उस वर्ग को किसी सरणी या संग्रह में रखा जाए तो क्या होगा?
Arrays
यदि आपके पास वस्तुओं की एक सरणी है, तो आप सरणी की Arrays.toString()
सामग्री का एक सरल प्रतिनिधित्व प्रस्तुत करने के लिए कॉल कर सकते हैं। उदाहरण के लिए, Person
वस्तुओं के इस सरणी पर विचार करें :
Person[] people = { new Person("Fred"), new Person("Mike") };
System.out.println(Arrays.toString(people));
// Prints: [Fred, Mike]
नोट: यह एक स्थिर विधि के लिए एक कॉल है जिसे toString()
Arrays वर्ग में कहा जाता है, जो कि हम ऊपर चर्चा कर रहे हैं, उससे भिन्न है।
यदि आपके पास एक बहुआयामी सरणी है , तो आप Arrays.deepToString()
उसी प्रकार के आउटपुट को प्राप्त करने के लिए उपयोग कर सकते हैं ।
संग्रह
अधिकांश संग्रह .toString()
प्रत्येक तत्व पर कॉल करने के आधार पर एक सुंदर आउटपुट का उत्पादन करेंगे ।
List<Person> people = new ArrayList<>();
people.add(new Person("Alice"));
people.add(new Person("Bob"));
System.out.println(people);
// Prints [Alice, Bob]
तो आपको बस यह सुनिश्चित करने की आवश्यकता है कि toString()
ऊपर सूचीबद्ध की गई सूची के अनुसार आपके तत्वों को एक अच्छा परिभाषित करें ।
मुझे लगता है कि अपाचे एक बेहतर उपयोग वर्ग प्रदान करता है जो स्ट्रिंग प्राप्त करने के लिए एक फ़ंक्शन प्रदान करता है
ReflectionToStringBuilder.toString(object)
जावा में प्रत्येक वर्ग में toString()
डिफ़ॉल्ट रूप से यह विधि होती है, जिसे यदि आप उस वर्ग के कुछ ऑब्जेक्ट को पास करते हैं तो इसे कहते हैं System.out.println()
। डिफ़ॉल्ट रूप से, यह कॉल उस ऑब्जेक्ट का className @ hashcode लौटाता है।
{
SomeClass sc = new SomeClass();
// Class @ followed by hashcode of object in Hexadecimal
System.out.println(sc);
}
आप अलग-अलग आउटपुट प्राप्त करने के लिए किसी वर्ग की आवर्ती पद्धति को ओवरराइड कर सकते हैं। इस उदाहरण को देखें
class A {
String s = "I am just a object";
@Override
public String toString()
{
return s;
}
}
class B {
public static void main(String args[])
{
A obj = new A();
System.out.println(obj);
}
}
ग्रहण में, अपनी कक्षा में जाएं, राइट क्लिक करें-> स्रोत-> उत्पन्न करें toString()
;
यह toString()
विधि को ओवरराइड करेगा और उस वर्ग के ऑब्जेक्ट को प्रिंट करेगा।
मैं एक उपयोगिता फ़ंक्शन का उपयोग करना पसंद करता हूं जो जावा ऑब्जेक्ट को JSON स्ट्रिंग में डी-सीरियल करने के लिए GSON का उपयोग करता है ।
/**
* This class provides basic/common functionalities to be applied on Java Objects.
*/
public final class ObjectUtils {
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
private ObjectUtils() {
throw new UnsupportedOperationException("Instantiation of this class is not permitted in case you are using reflection.");
}
/**
* This method is responsible for de-serializing the Java Object into Json String.
*
* @param object Object to be de-serialized.
* @return String
*/
public static String deserializeObjectToString(final Object object) {
return GSON.toJson(object);
}
}
इंटेलीज में आप ऑल्ट + इनसेट दबाकर स्ट्रोस्ट्रिंग विधि को ऑटो जनरेट कर सकते हैं और फिर स्ट्रींग () का चयन कर एक टेस्ट क्लास के लिए आउट डाल सकते हैं:
public class test {
int a;
char b;
String c;
Test2 test2;
@Override
public String toString() {
return "test{" +
"a=" + a +
", b=" + b +
", c='" + c + '\'' +
", test2=" + test2 +
'}';
}
}
जैसा कि आप देख सकते हैं, यह समवर्ती द्वारा एक स्ट्रिंग उत्पन्न करता है, वर्ग की कई विशेषताओं, आदिम के लिए यह उनके मूल्यों को मुद्रित करेगा और संदर्भ प्रकारों के लिए यह उनके वर्ग प्रकार (इस मामले में Test2 की स्ट्रिंग विधि) का उपयोग करेगा।
डिफ़ॉल्ट रूप से, जावा में प्रत्येक ऑब्जेक्ट में वह toString()
विधि होती है जो ObjectType @ HashCode को आउटपुट करती है।
यदि आप अधिक अर्थपूर्ण जानकारी चाहते हैं तो आपको toString()
अपनी कक्षा में विधि को ओवरराइड करने की आवश्यकता है ।
public class Person {
private String name;
// constructor and getter/setter omitted
// overridding toString() to print name
public String toString(){
return name;
}
}
अब जब आप उस व्यक्ति ऑब्जेक्ट System.out.prtinln(personObj);
को प्रिंट करते हैं तो वह क्लासनाम और हैशकोड के बजाय उस व्यक्ति का नाम प्रिंट करेगा।
अपने दूसरे मामले में जब आप सरणी को प्रिंट करने की कोशिश कर रहे हैं, तो यह [Lcom.foo.Person;@28a418fc
एरे टाइप टाइप करता है और यह हैशकोड है।
यदि आप व्यक्ति के नाम प्रिंट करना चाहते हैं, तो कई तरीके हैं।
आप अपने स्वयं के फ़ंक्शन को लिख सकते हैं जो प्रत्येक व्यक्ति और प्रिंट को पुनरावृत्त करता है
void printPersonArray(Person[] persons){
for(Person person: persons){
System.out.println(person);
}
}
आप इसे Arrays.toString () का उपयोग करके प्रिंट कर सकते हैं। यह मुझे सबसे सरल लगता है।
System.out.println(Arrays.toString(persons));
System.out.println(Arrays.deepToString(persons)); // for nested arrays
आप इसे 8 तरीके से प्रिंट कर सकते हैं (धाराओं और विधि संदर्भ का उपयोग करके)।
Arrays.stream(persons).forEach(System.out::println);
अन्य तरीके भी हो सकते हैं। उम्मीद है की यह मदद करेगा। :)
यदि आप सीधे व्यक्ति की किसी भी वस्तु ClassName@HashCode
को कोड के लिए प्रिंट करेंगे ।
आपके मामले com.foo.Person@2f92e0f4
में मुद्रित हो रही है। जहाँ Person
एक वर्ग किस वस्तु का है और वस्तु 2f92e0f4
का हैशकोड है।
public class Person {
private String name;
public Person(String name){
this.name = name;
}
// getter/setter omitted
@override
public String toString(){
return name;
}
}
अब यदि आप ऑब्जेक्ट का उपयोग करने की कोशिश करते हैं Person
तो यह नाम प्रिंट करेगा
Class Test
{
public static void main(String... args){
Person obj = new Person("YourName");
System.out.println(obj.toString());
}
}
यदि आप ऑब्जेक्ट क्लास (जावा में सभी वर्गों के पेरेंट क्लास) को देखते हैं, तो स्ट्रेसिंग () विधि कार्यान्वयन है
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
जब भी आप जावा में कोई भी ऑब्जेक्ट प्रिंट करेंगे तो स्ट्रींग () कॉल होगा। अब यह आप पर निर्भर है कि यदि आप toString () को ओवरराइड करते हैं तो आपकी विधि अन्य ऑब्जेक्ट क्लास विधि कॉल को कॉल करेगी।
मैं इसे Jackson
स्प्रिंग 5 में उपयोग कर पाने में कामयाब रहा । ऑब्जेक्ट के आधार पर जैक्सन सभी मामलों में काम नहीं कर सकता है।
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
ObjectMapper mapper = new ObjectMapper();
Staff staff = createStaff();
// pretty print
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(staff);
System.out.println("-------------------------------------------------------------------")
System.out.println(json);
System.out.println("-------------------------------------------------------------------")
आउटपुट कुछ इस तरह होगा
-------------------------------------------------------------------
{
"id" : 1,
"internalStaffId" : "1",
"staffCms" : 1,
"createdAt" : "1",
"updatedAt" : "1",
"staffTypeChange" : null,
"staffOccupationStatus" : null,
"staffNote" : null
}
-------------------------------------------------------------------
अधिक उदाहरण यहाँ का उपयोग करJackson
आप GSON
भी आजमा सकते हैं। कुछ इस तरह होना चाहिए:
Gson gson = new Gson();
System.out.println(gson.toJson(objectYouWantToPrint).toString());