Strings | Lecture 12 | Java Placement Series

Summary

This Java tutorial video focuses on the concept of Strings, explaining that Strings are non-primitive data types used extensively in Java. The instructor covers String declaration, manipulation, and memory usage. They teach how to declare a String, input Strings from a user, and concatenate Strings. The video also discusses String methods like length(), charAt(), and comparison using compareTo(). It emphasizes the immutability of Strings and the importance of using the compareTo() method for accurate comparison, hinting at the String Builder class to be covered in the next video.

Takeaways

• 😀 Strings in Java are non-primitive data types, which means their length and content can be defined by the programmer.
• ✍️ The 'String' class in Java is used to define strings, and it is important to note the capital 'S' to avoid errors.
• 🔑 Strings can store various types of text, such as sentences, words, or characters, and are extensively used in Java.
• 🧠 The concept of strings will be further explored in future videos, specifically with the String Builder class.
• 🔍 To declare a string in Java, you specify the data type 'String', followed by the variable name and the string value to be stored.
• 🔢 Java allows you to input strings from the user and store them using the Scanner class.
• 🔗 The 'concat' function is used to join two strings together in Java.
• 📏 The 'length' method is used to calculate the length of a string in Java.
• 🔎 The 'charAt' method allows you to access and manipulate individual characters within a string.
• 🆚 The 'compareTo' function is used to compare two strings in Java, considering case sensitivity.
• 🔄 Java strings are immutable, meaning they cannot be modified after creation. Any change requires the creation of a new string.

Q & A

What is a string in Java?

A string in Java is a non-primitive data type used to store sequences of characters. It can be defined by the programmer to store any text, sentence, or characters as a single entity.

Why is it important to use capital 'S' when declaring the String class in Java?

In Java, the String class is case-sensitive, and it must be declared with a capital 'S'. Many students make the mistake of not capitalizing it, which can lead to errors in the program.

How do you declare a string variable in Java?

You declare a string variable in Java by first specifying the data type 'String', followed by the variable name, and then assigning it a value, such as 'String name = "Tony";'.

What is the significance of the 'length' method in strings?

The 'length' method in Java is used to calculate the number of characters in a string. It is a built-in method that returns the length of the string when called.

How can you take input from the user and store it as a string in a Java program?

To take input from the user and store it as a string, you need to create an object of the Scanner class and use its 'nextLine' method to read the input as a full line of text.

What is the difference between using 'next' and 'nextLine' when taking input in Java?

The 'next' method is used to take a single word input, while 'nextLine' is used to take a full line of input, including spaces.

How can you concatenate two strings in Java?

In Java, you can concatenate two strings by using the '+' operator to join them together, or by using the 'concat' method of the String class.

What is the purpose of the 'charAt' method in strings?

The 'charAt' method in Java is used to access a character at a specific index within a string. It returns the character at the given index position.

How does the 'substring' method work in Java?

The 'substring' method in Java is used to extract a part of a string. It takes a starting index and an optional ending index to define the portion of the string to return.

Why is it recommended to use the 'compareTo' method instead of 'equals' when comparing strings in Java?

The 'compareTo' method is recommended over 'equals' for comparing strings in Java because 'equals' can fail in certain cases where 'compareTo' provides a lexicographical comparison that is more reliable.

What is the concept of immutability in strings and why is it important?

In Java, strings are immutable, which means once a string is created, it cannot be changed. Any operation that appears to modify a string actually creates a new string. This concept is important because it ensures that strings behave in a predictable and safe manner, especially when used as keys in a Hashtable or a similar data structure.

Outlines

00:00

💻 Introduction to Strings in Java

The script begins with an introduction to the Java Strings topic. It mentions that strings are a non-primitive data type and can be defined by the user according to their needs. The video explains that strings are used to store various types of text, such as sentences, words, or characters, in a single data type. It also clarifies the difference between the default 'String' class in Java and the 'Strings' class created by the user, emphasizing the importance of capitalization in Java's 'String' class. The script also discusses the declaration of strings and how to store data in them, including handling spaces and sentences.

05:02

🔍 Manipulating Strings: concat and length

This paragraph focuses on how to manipulate strings in Java, specifically using the 'concat' function to join two strings. It explains the process of defining strings and then using the '+' operator to concatenate them. The video also covers how to calculate the length of a string using the 'length' method, emphasizing the importance of understanding these functions for interviews and placements.

10:04

🔢 Looping Through Characters in a String

The script explains how to access and manipulate individual characters within a string using a loop. It introduces the 'charAt' method to retrieve characters at specific indices and demonstrates using a for-loop to iterate over each character in a string. The explanation also touches on comparing two strings using the 'compareTo' method, which compares strings lexicographically and returns a negative, zero, or positive value based on the comparison.

15:06

📝 Understanding Case Sensitivity in String Comparison

This section delves into the concept of case sensitivity in string comparison. It uses examples to illustrate how characters are compared based on their ASCII values, with uppercase letters having lower values than lowercase letters. The script clarifies that string comparison in Java is case-sensitive and explains the consequences of using '==' vs '.equals()' when comparing strings.

20:06

🎯 Extracting Substrings and Immutable Strings

The script teaches how to extract substrings from a larger string using the 'substring' method, which takes a starting index and an optional ending index. It explains the concept of string immutability in Java, stating that strings cannot be modified once created. Any change to a string results in the creation of a new string. This property is crucial for understanding string manipulation and is often tested in interviews.

25:14

📓 Recap and Future Learnings

In the concluding paragraph, the script recaps the concepts covered in the video and hints at future topics, such as parsing and the use of the 'String Builder' class. It emphasizes the importance of understanding string immutability and mentions that more detailed discussions will be part of upcoming videos. The script also encourages continuous learning and practicing with the provided notes and codes.

Keywords

💡Strings

Strings are a fundamental data type in Java used to represent text. They are sequence of characters and are immutable, meaning their content cannot be changed after creation. In the script, strings are used to explain how to declare variables, take user input, and perform operations like concatenation and comparison. The concept is central to the video's theme of learning Java data types.

💡Declaration

Declaration in Java refers to the act of creating a variable, which involves specifying the data type and giving it a name. The script mentions declaring a string variable as the first step in using strings, which sets the stage for storing and manipulating text data within a program.

💡Concatenation

Concatenation is the process of joining two strings end-to-end. The script explains how to concatenate strings in Java using the '+' operator or the 'concat' method. This is crucial for creating new strings from existing ones, as illustrated by the example of combining 'Tony' and 'Stark' into 'Tony Stark'.

💡Length

The 'length' of a string refers to the count of characters it contains. The script teaches how to find the length of a string using the 'length()' method. This is important for processing and manipulating strings, such as when needing to know how many characters are in a sentence or word.

💡Index

Index in the context of strings refers to the position of a character within the string. The script discusses how to access characters in a string using their index values, which is essential for tasks like iterating over each character in a string or extracting a substring.

💡Substring

A substring is any sequence of characters within a string that begins and ends at certain indices. The script explains how to extract a substring using the 'substring' method, which is useful for operations like extracting a part of a sentence or word from a larger string.

💡Comparison

Comparing strings in Java involves checking if one string is equal to, less than, or greater than another. The script emphasizes the use of the 'compareTo' method for string comparison over the '==' operator to avoid errors and ensure correct lexicographical ordering.

💡Immutability

Immutability means that an object cannot be modified after it is created. The script highlights that strings in Java are immutable, which is a key concept when discussing string manipulation. Any operation that appears to change a string actually creates a new string.

💡Input

Input in programming refers to receiving data from an external source, such as a user. The script discusses how to take string input from a user using the 'Scanner' class, which is a common way to interact with users in a Java program.

💡Output

Output is the data sent from a program to an external destination, like the console. The script mentions printing strings to the console using 'System.out.print', which is a fundamental operation for displaying results or information to the user.

💡Class

In Java, a class is a blueprint for creating objects. The script mentions the 'String' class, which is a built-in class for handling string objects. Understanding classes is essential for object-oriented programming in Java.

Highlights

Introduction to Strings in Java and their extensive use in programming.

Explanation of Strings as non-primitive data types in Java.

The importance of case sensitivity with the String class in Java.

How to declare a String variable in Java.

Storing different types of text within a single String.

Concept of spaces as valid characters within Strings.

Inputting Strings from the user in Java programs.

Utilizing the Scanner class for user input.

Difference between using 'next' and 'nextLine' for inputting Strings.

Concatenating Strings using the '+' operator.

Explanation of how the '+' operator works with Strings in Java.

How to calculate the length of a String using the 'length' method.

Iterating through each character in a String using a for loop.

Accessing and printing individual characters in a String using the 'charAt' method.

Comparing two Strings using the 'compareTo' method.

Explanation of how the 'compareTo' method works and its return values.

Difference between using '==' and 'compareTo' for comparing Strings.

Creating new Strings and comparing them using 'equals' and 'compareTo'.

Explanation of why Strings are objects and how they are stored in memory.

How to extract a substring from a larger String using the 'substring' method.

Parameters and usage of the 'substring' method to extract parts of a String.

Immutability of Strings in Java and the implications for memory usage.

The concept of parsing and its application to Strings.

Importance of understanding the immutability of Strings for interviews and practical applications.

Transcripts

हाय एवरीवन एंड वेलकम टू द जावा प्लेसमेंट

कोर्स आज की वीडियो में हम सीख रहे होंगे

स्ट्रिंग्स के बारे में अब थोड़ा सा ऑफिस

की फॉर्मेलिटीज थी इसलिए टाइम थोड़ा

ज्यादा लग गया वीडियो को बनाने में पर इस

वीडियो में सीखेंगे स्ट्रिंग्स को हमने

पहले वेरिएबल वाली वीडियो में सीखा था कि

स्ट्रिंग एक नॉन प्रिमिटिव डाटा टाइप होता

है यानी इसे यूजर या हम प्रोग्रामर्स अपनी

मर्जी से इसकी लेंथ वगैरह सब डिफाइन कर

सकते हैं इसके अंदर क्या स्टोर करना है और

स्ट्रिंग्स की अगर बात करें तो मोटा मोटी

समझे तो मान लीजिए हमें अपने प्रोग्राम

में कोई टेक्स्ट डिफाइन करना है चाहे वह

सेंटेंस हो चाहे वह वर्ड हो चाहे वह कुछ

कैरेक्टर्स ही क्यों ना हो चाहे वो एक

पूरा का पूरा एसे हो तो इन सारे अलग-अलग

टाइप के टेक्स्ट को इस पूरी इंफॉर्मेशन को

हम एक स्ट्रिंग की फॉर्म में स्टोर करते

हैं तो स्ट्रिंग्स का बहुत एक्सटेंसिवली

यूज होता है जावा के अंदर और स्ट्रिंग्स

जावा की मेमोरी के साथ भी थोड़ा बहुत हम

कुछ कांसेप्ट को सीख रहे होंगे पर उनको

सीखेंगे अगली वीडियो में जब स्ट्रिंग

बिल्डर के बारे में सीखेंगे आज की वीडियो

स्पेसिफिकली स्ट्रिंग से रिलेटेड रहेगी

हमने पहले भी कुछ वीडियोस में स्ट्रिंग्स

की बात की है उन्हीं कॉन्सेप्ट्स को थोड़ा

और डिटेल में समझेंगे और थोड़े बहुत

कांसेप्ट एरे से भी रिलेट करेंगे तो आई

होप कि आप स्ट्रिंग्स की वीडियो देख रहे

हैं तो आपने अरेज की वीडियो पहले जरूर देख

लिया तो स्ट्रिंग के अंदर सबसे पहले हम

सीखने वाले हैं कि एक स्ट्रिंग को

डिक्लेयर किस तरीके से करते हैं डिक्लेयर

करना यानी अपने प्रोग्राम को बताना कि

हमने एक स्ट्रिंग बनाई है जिसमें हम कुछ

डाटा स्टोर कर रहे हैं तो सबसे पहले बात

करेंगे स्ट्रिंग डिक्लेरेशन या डेफिनेशन

की इसमें एक चीज ध्यान दें तो हम अपनी

क्लास का नाम जो रख रहे हैं वो भी

स्ट्रिंग्स है और जावा के अंदर एक और

क्लास बाय डिफॉल्ट पहले से एजिस्ट करती है

जिसको हम कहते हैं स्ट्रिंग अब ये

स्ट्रिंग कैपिटल एस से शुरू होता है तो

काफी सारे स्टूडेंट छोटी सी मिस्टेक कर

देते हैं कि वो कैपिटल नहीं रखते कुछ

चीजों को तो एरर आने लग जाते हैं तो

कैपिटल ए है स्ट्रिंग में इसे हमें कैपिटल

जरूर रखना है पर ये स्ट्रिंग जो है जावा

के अंदर पहले से है तो हम स्ट्रिंग नाम

नहीं रख सकते अपनी क्लास का इसीलिए हमने

स्ट्रिंग्स नाम रखा है क्लास का अब ध्यान

दें तो मेन फंक्शन के अंदर जो हम

आर्गुमेंट एरे लिया करते थे उसमें भी हम

स्ट्रिंग क्लास को यूज किया करते थे

क्योंकि वो एरे एक स्ट्रिंग्स का एरे होता

था अब स्ट्रिंग को डिक्लेयर करने के लिए

सबसे पहले लिखते हैं अपना डेटा टाइप जो है

स्ट्रिंग उसके बाद लिखेंगे नेम जो हमारे

वेरिएबल का नाम है और इसमें

हम कोई भी स्ट्रिंग जो है वो स्टोर करवा

देंगे तो इस तरीके से हमने अपने नाम को

स्ट्रिंग के अंदर स्टोर करवा दिया मान

लेते हैं अगर हमें एक और डेटा टाइप लेना

होता फुल नेम तो फुल नेम में हम स्टोर

करवाते पूरा

नाम इस तरीके से तो यहां पर बीच में अगर

स्ट्रिंग में स्पेस आ जाए तो कोई प्रॉब्लम

नहीं आती क्योंकि स्ट्रिंग के अंदर

स्पेसेस भी एक वैलिड कैरेक्टर है अब अगर

मान लीजिए हमें कोई सेंटेंस स्टोर करवाना

होता तो उसको करवाते कुछ इस तरीके

से माय नेम इज टोनी स्टार्क तो इस तरीके

से हमने पूरा का पूरा सेंटेंस एक स्ट्रिंग

के अंदर स्टोर करवा दिया है सिर्फ यही

नहीं अगर हमें कैरेक्टर उसका बड़ा सा एसए

स्टोर करवाना है तो वो भी हम इसके अंदर

स्टोर करवा सकते हैं जब तक हमारी मेमोरी

भर नहीं जाती प्रोग्राम की वजह से तो कुछ

इस तरीके से हम स्ट्रिंग्स को डिक्लेयर

करते हैं डिफाइन करते हैं जावा के अंदर अब

यहां पर तो हमने अपना स्ट्रिंग बना लिया

लेकिन मान लीजिए आपको यूजर से स्ट्रिंग को

इनपुट करना है यानी आपने एक प्रोग्राम

बनाया जिसमें यूजर से पूछता है आपका

प्रोग्राम कि आप अपना नाम बताइए तो यूजर

ने कुछ-कुछ नाम टाइप किया उसको आप यूजर से

लेकर अपनी स्ट्रिंग के अंदर कैसे स्टोर

करवाएंगे वो देखते हैं तो उसके लिए हमें

क्या करना पड़ेगा सबसे पहले इनपुट लेना

पड़ेगा इनपुट लेने के लिए बनानी पड़ेगी एक

स्कैनर क्लास की ऑब्जेक्ट तो लिखते हैं

स्कैनर

एससी तो अब हमने देख लिया है कि न्यू

कीवर्ड भी कुछ होता है तो हम समझ सकते हैं

कि स्कैनर क्लास एक क्लास है और एससी एक

ऑब्जेक्ट है और यहां पर हमने न्यू कीवर्ड

को यूज किया है इस ऑब्जेक्ट को डिफाइन

करने के लिए तो ये स्कैनर भी एक नॉन

प्रिमिटिव डाटा टाइप है जावा के अंदर अब

यहां से हम ले लेंगे स्ट्र

नेम इक्वल टू एड नेक्स्ट तो जब हमने इनपुट

आउटपुट के बारे में सीखा था तब भी हमने

बात की थी कि अगर हमें पूरी की पूरी

स्ट्रिंग पूरी की पूरी लाइन पूरा का पूरा

सेंटेंस जो इनपुट लेना है व लेंगे हम

नेक्स्ट की फॉर्म में ऊपर इसके लिए

इंपोर्ट कर देते हैं अपना पैकेज जावा ड यल

डल तो यह हमने नेम इनपुट ले लिया और अब इस

नेम को हम आउटपुट करवा देंगे यूजर को योर

नेम इज

इसको सेव करते हैं इसे रन करते हैं एंड रन

करने के बाद सबसे पहले हमें इनपुट करना

होगा अपना नाम तो हम नाम इनपुट कर देते

हैं टोनी उसके बाद स्टार्क भी ले लेते हैं

आउटपुट करके हमारे पास आया योर नेम इज

टोनी अब यहां पर स्टार्क क्यों नहीं आया

हमारे पास स्टार्क क्यों नहीं इनपुट हुआ

अब इनपुट क्यों नहीं हुआ ये चीज हमने

ऑलरेडी जब हमने इनपुट आउटपुट सीखे थे जावा

के अंदर तब हम इस सवाल का जवाब दे चुके

हैं लेकिन जो स्टूडेंट्स रिकॉल नहीं कर पा

रहे हैं अगर पूरी की पूरी लाइन इनपुट लेनी

होती है यानी स्ट्रिंग जो है वो एक सिंगल

टोकन है सिंगल एलिमेंट है उससे ज्यादा अगर

हमें कुछ लेना है मतलब एक वर्ड से ज्यादा

कुछ इनपुट लेना है तो हम नेक्स्ट नहीं

नेक्स्ट लाइन का यूज़ कर रहे होंगे तो

जैसे ही नेक्स्ट लाइन को यूज़ करेंगे इस

बार दोबारा से प्रोग्राम को रन करते हैं

दोबारा से नेम एंटर करते हैं टोनी

स्टार्क और इस बार हमारे पास पूरा का पूरा

नाम जो है प्रिंट हो गया है तो जब भी पूरी

लाइन इनपुट लेनी है यानी स्पेसेस वगैरह भी

इनपुट लेने हैं तो नेक्स्ट लाइन यूज़

करेंगे जब सिर्फ एक सिंगल वर्ड इनपुट लेना

है तो सिर्फ नेक्स्ट यूज़ करेंगे तो ये

चीज काफी ध्यान रखने की जरूरत है जब भी

स्ट्रिंग्स के बारे में हम बात करते हैं

अब धीरे-धीरे करके हम स्ट्रिंग्स पर कुछ

फंक्शंस परफॉर्म करने वाले हैं और ध्यान

रखिए कि इंपॉर्टेंट फंक्शंस हैं ये काफी

सारे क्वेश्चंस में आगे यूज होंगे

प्लेसमेंट के लिए भी यूज़ होते हैं जब भी

आप किसी कंपनी का टेस्ट देने बैठने हैं तो

कुछ भी क्वेश्चन आ सकता है आपकी तरफ और

आपको पता होना चाहिए कि जावा के अंदर

स्ट्रिंग्स को मैनिपुलेट कैसे करते हैं

उसमें चेंजेज कैसे लेकर आते हैं बहुत कम

टाइम में तो सबसे पहले बात करते हैं पहले

फंक्शन की जिसका नाम है

कॉन्कैटिनेट कॉन्कैटिनेट को एक बार लिख

लेते हैं क्योंकि

स्पेलिंग कॉन कट नेशन इज द फंक्शन

कॉन्कैटिनेट मतलब दो स्ट्रिंग्स को जोड़ना

मान लीजिए हमने फर्स्ट नेम लिया और फिर

लास्ट नेम लिया अब हमारा काम है हमें फुल

नेम बनाना इन दो स्ट्रिंग्स को जोड़कर तो

उसके अंदर जावा में हम किस तरीके से

स्ट्रिंग्स को जोड़ते हैं सबसे पहले

स्ट्रिंग्स डिफाइन कर लेते हैं स्ट्रिंग

फर्स्ट नेम

टोनी एंड स्ट्रिंग लास्ट

नेम

स्टाक ठीक है अब हम एक नई स्ट्रिंग डिफाइन

करते हैं फुल

नेम फुल नेम को किस तरीके से बनाएंगे या

तो हम दोबारा इस नाम को लिखें या फिर

ऑलरेडी अगर वेरिएबल बना लिए तो उसको रीयूज

कर लेते हैं पहले हम लिखेंगे फर्स्ट नेम

फिर कर देंगे प्लस फिर लिखेंगे लास्ट

नेम और फिर हम क्या करेंगे इसको प्रिंट

करवा लेते हैं कि हमारे फुल नेम में

एक्चुअली वैल्यू क्या आई इसे सेव करते हैं

और इसे रन करते

हैं तो यहां पर फुल नेम में प्रिंट हुआ

टोनी स्टार्क तो एक तरीके से प्लस ने क्या

किया प्लस ने फर्स्ट स्ट्रिंग ली और सेकंड

स्ट्रिंग ली और उनको ऐड कर दिया अगर ध्यान

दें कि हम आउटपुट कैसे करवाते हैं जो

सिस्टम ड आड प्रिंट एन के अंदर हम जो कुछ

भी पास करते हैं तो अगर हमें दो अलग-अलग

आउटपुट्स करवाने होते हैं या फिर हमें एक

वेरिएबल प्रिंट करवाना होता है किसी

आउटपुट के साथ तो हम बीच बीच में प्लस ऐड

कर देते हैं वो क्या करता है उन दोनों को

स्ट्रिंग में कन्वर्ट करके कंकट करके फिर

प्रिंट करवाता है यूजर को अब यहां पर टोनी

और स्टार के बीच में स्पेस तो आया ही नहीं

हमें स्पेस चाहिए था तो क्या करेंगे एक और

स्ट्रिंग जोड़ देंगे और ये स्ट्रिंग यहां

पर हमने ऐसे खड़े-खड़े ही बना लिए मतलब

इसे किसी नए वेरिएबल में नहीं भेजा हमने

डायरेक्टली एज अ स्ट्रिंग इसको क्रिएट कर

दिया इस सेंटेंस के अंदर इस लाइन के अंदर

जो कि हम कर सकते हैं जावा के अंदर मतलब

एक खाली स्ट्रिंग हम हो सकता है किसी एमटी

स्ट्रिंग नाम के वेरिएबल में स्टोर करा

देते लेकिन इसको हमने नहीं स्टोर कराया

इसको डायरेक्टली यूज़ किया इसके

इंप्लीकेशंस भी देखते हैं इसे रन करके

देखते हैं एक बार तो अब हमारे लिए प्रिंट

हुआ है टोनी स्टार्क और टोनी और स्टार्क

के बीच में एक स्पेस आ गया है अगर हम यहां

पर स्ट्रिंग में सिर्फ स्पेस नहीं @ द रेट

लिख देते

तो रेट लिखने के बाद जो आउटपुट है उसके

अंदर टोनी और स्टार्क के बीच में रेट आ

गया है वो सिंबल आ गया है तो इस तरीके से

आप सिर्फ किसी नॉर्मल सेंटेंस नॉर्मल

स्टेटमेंट के बीच में भी कहीं भी कोई भी

स्ट्रिंग क्रिएट कर सकते हैं बस ये है कि

ये लाइन जैसे ही खत्म होगी ये बीच वाली जो

स्ट्रिंग है ये ऑटोमेटिक डिलीट हो जाएगी

मेमोरी से क्योंकि इसको हमने किसी वेरिएबल

में स्टोर नहीं किया अब अगला फंक्शन हम

जिसकी बात कर रहे होंगे उसका नाम है लेंथ

हम किसी भी स्ट्रिंग की लेंथ को एक फंक्शन

की फॉर्म में कैलकुलेट कर सकते हैं

स्ट्रिंग्स के अंदर ऑलरेडी एक मेथड होता

है जिससे अगर हम रिक्वेस्ट भेजें तो हमारे

पास किसी भी स्ट्रिंग की लेंथ आ जाती है

अब मान लीजिए हमें ये फुल नेम जो है इसकी

लेंथ प्रिंट करवानी है तो तो हमें कुछ

नहीं करना यहां पर लिखेंगे डॉट फिर

लिखेंगे लेंथ और फिर फंक्शन वाले पैरेंस

तो इस तरीके से कोई भी स्ट्रिंग है उसका

हम नाम लिखेंगे फिर लिखेंगे डॉट और उसके

बाद लिखेंगे लेंथ क्योंकि हम लेंथ फंक्शन

को कॉल करना चाहते हैं तो इस तरीके से डॉट

लगाकर हम लेंथ फंक्शन को कॉल कर रहे हैं

इसको सेव कर लेते हैं एंड एक बार इसे रन

करते हैं तो हमारे लिए जो प्रिंट हुआ है

वो है 10 और हमारी एक्चुअल स्ट्रिंग क्या

थी हमारी स्ट्रिंग थी टोनी @ स्टार्क अब

इसके अंदर कैरेक्टर्स गिने तो 1 2 3 4 5 6

7 8 9 10 तो 10 कैरेक्टर्स हैं इस

स्ट्रिंग के अंदर और वही 10 जो लेंथ है इस

स्ट्रिंग की वो हमारे फंक्शन ने प्रिंट कर

दिया हमारे लिए स्क्रीन पर तो कुछ इस

तरीके से हम स्ट्रिंग्स की लेंथ निकाल

सकते हैं अब मान लीजिए हमें बार-बार क्या

करना है इस स्ट्रिंग के सारे कैरेक्टर्स

को प्रिंट करना है यानी टोनी @ स्टारक के

अंदर जितने भी कैरेक्टर्स हैं उनको एक-एक

करके प्रिंट करना है पहले टी प्रिंट हो

जाए फिर ओ प्रिंट हो जाए तो उसके लिए भी

जावा के अंदर एक मेथड है इस मेथड को नाम

देते हैं कैर एट ये ऑलरेडी

एजिस्टिफाई

थे ये मेथड्स ये फंक्शंस पहले से बने हुए

हैं जावा के अंदर इन्हें बस हम रीयूज कर

रहे हैं तो इसको कैसे यूज़ करेंगे सबसे

पहले क्या करते हैं लूप लगा लेते हैं

क्योंकि जब भी हमें कोई भी काम बार-बार

करना है यहां पर कैरेक्टर प्रिंट करवाने

वाला काम बार-बार करना है तो हम लूप लगा

लेते हैं फॉर इंट i = 0 i इज लेस देन फुल

नेम डॉट

लेंथ फुल नेम डॉट लेंथ करने से यहां पर

क्या हुआ हमने स्ट्रिंग की लेंथ जो है वो

हमें खुद से कैलकुलेट नहीं करनी पड़ी हमने

सिंपली एक फंक्शन कॉल कर लिया वो स्ट्रिंग

की लेंथ कैलकुलेट करके हमें दे देगा और हम

अपना जो लूप है वो उतनी ही बार रन करेंगे

उसके बाद कर लेते हैं i+ प् एंड अब प्रिंट

क्या करवाते हैं

प्रिंट करवाते हैं फुल नेम डॉट क

ट आ अब ये फुल नेम डॉट कट आय का क्या मतलब

हुआ कि फुल नेम जो हमारी स्ट्रिंग है उसके

अंदर हर एक कैरेक्टर पर हम जा रहे हैं और

कैर एट फंक्शन उस कैरेक्टर को लेकर आता है

जो इंडेक्स हमने पास किया जैसे अरेस के

अंदर हमने बात की थी कि फर्स्ट पोजीशन

यानी जीरो एथ इंडेक्स सेकंड पोजीशन यानी

फर्स्ट इंडेक्स थर्ड पोजीशन यानी सेकंड

इंडेक्स तो इसी तरीके से स्ट्रिंग के अंदर

भी जो एक-एक एक-एक कैरेक्टर आ रहा होता है

उन सबको भी एक इंडेक्स असाइन होता है तो

सबसे पहली पोजीशन पर जो भी है उसको

इंडेक्स ज़ीरो है दूसरी पोजीशन को इंडेक्स

वन है तीसरी पोजीशन को इंडेक्स टू है इसी

तरीके से हम जो इंडेक्स है वह है हमारे

लिए यहां पर आ उस आ को इस फंक्शन कैर ट के

अंदर हम पास कर रहे हैं और यह कैर एट

फंक्शन क्या करेगा उस इंडेक्स पर जो भी

होगा स्ट्रिंग के अंदर कैरेक्टर उसको

रिटर्न करके देगा उसको रिटर्न करने के बाद

हम उसको प्रिंट करवा रहे होंगे तो इसको

सेव करते हैं और प्रिंट करवाते हैं अपने

कैरेक्टर्स

को तो यहां पर सबसे पहले प्रिंट हुआ 10 जो

कि फुल लेंथ थी इस स्टेटमेंट की वजह से

फिर हम अपने एरे के अंदर आए एरे के अंदर

सबसे पहले प्रिंट हुआ पहला कैरेक्टर t फिर

o फिर n फिर y और इसी तरीके से बाकी के

सारे कैरेक्टर्स प्रिंट हो गए और यह लूप

कब तक चला यह लूप चला हमारे स्ट्रिंग की

लेंथ तक तो कुछ इस तरीके से हम स्ट्रिंग

के अंदर जाकर एक-एक कैरेक्टर को भी एक्सेस

कर सकते सते हैं कि वो कैरेक्टर क्या है

उसे प्रिंट करवा सकते हैं उस कैरेक्टर के

साथ कोई मैनिपुलेशन करनी है उसे चेंज करना

है डिलीट करना है तो वो सब भी हम

स्ट्रिंग्स के अंदर कर सकते हैं अब मान

लीजिए कि हमें दो स्ट्रिंग्स को कंपेयर

करना है तो उनको कैसे कंपेयर करेंगे सबसे

पहले अपनी दो स्ट्रिंग्स हम बना लेते

हैं यहां पर हम सीखेंगे स्ट्रिंग्स को

कंपेयर करना तो स्ट्रिंग नेम वन है हमारे

पास

टोनी स्ट्रिंग नेम टू है हमारे पास दोबारा

से टोनी अब हमें इन दोनों स्ट्रिंग्स को

कंपेयर करना है कंपेयर करना मतलब क्या नेम

वन नेम टू के इक्वल है उसको कंपेयर करने

के लिए हम एक फंक्शन का यूज करते हैं

जिसको नाम देते हैं डॉट कंपेयर टू इसको

यूज करने के लिए हम सबसे पहले लिखेंगे

अपनी पहली स्ट्रिंग यानी नेम वन और

लिखेंगे डॉट कंपेयर टू और इस डॉट कंपेयर

टू के अंदर अपनी दूसरी स्ट्रिंग पास

करेंगे यानी हम फंक्शन को बता रहे हैं कि

पहली स्ट्रिंग और दूसरी स्ट्रिंग को आप

कंपेयर करिए तो दूसरी स्ट्रिंग पास करेंगे

तो नेम टू हमने पास किया अब ये जो कंपेयर

टू फंक्शन है ये तीन केसेस चेक करता है

पहला केस जिसमें हमारी जो स्ट्रिंग वन है

दैट इज ग्रेटर दन स्ट्रिंग टू दूसरा केस

जिसमें हमारी स्ट्रिंग वन जो है दैट इज

इक्वल टू स्ट्रिंग टू एंड तीसरा केस

जिसमें हमारी स्ट्रिंग वन जो है दैट इज

लेस दन स्ट्रिंग पहले केस में जिसमें

स्ट्रिंग वन ग्रेटर दन स्ट्रिंग टू है

कंपेयर टू फंक्शन क्या रिटर्न करेगा एक

पॉजिटिव वैल्यू अब ये पॉजिटिव वैल्यू कुछ

भी हो सकता है ये + 9 हो सकता है + 15 हो

सकता है कुछ भी हो सकता है जिसमें दोनों

स्ट्रिंग्स इक्वल हैं उस केस में ये

रिटर्न करेगा हमारे पास रो और जिस केस में

स्ट्रिंग वन स्ट्रिंग टू से छोटी है उस

केस में ये फंक्शन हमारे पास रिटर्न करेगा

एक नेगेटिव वैल्यू को तो कुछ इस तरीके से

हम एनालाइज करते हैं दो स्ट्रिंग्स को

कंपेयर करते हैं इसमें जो पहली स्ट्रिंग

यानी जो डॉट से पहले आएगी यानी नेम वन

हमारी स्ट्रिंग वन है और नेम टू हमारी

स्ट्रिंग टू है स्ट्रिंग टू वो जिसको

कंपेयर टू फंक्शन में हमने पास किया एज अ

पैरामीटर तो अगर स्ट्रिंग वन स्ट्रिंग टू

से बड़ी है तो पॉजिटिव वैल्यू नहीं तो

जीरो और छोटी है तो नेगेटिव वैल्यू अब

यहां पर अगर कंपेयर्स टू हमें जरो रिटर्न

करता है तो इस केस में हमें क्या प्रिंट

करवाना है हमें प्रिंट करवाना है

स्ट्रिंग्स आर

इक्वल अगर ऐसा नहीं है तो हम इस केस में

प्रिंट करवा देंगे स्ट्रिंग्स आर नॉट

इक्वल राइट अब इसमें भी हम आगे कंडीशन लगा

सकते थे कि अगर पॉजिटिव वैल्यू रिटर्न हुई

है यानी स्ट्रिंग वन इज ग्रेटर दन

स्ट्रिंग टू नेगेटिव वैल्यू रिटर्न हुई है

यानी स्ट्रिंग टू इज ग्रेटर दन स्ट्रिंग

वन अब स्ट्रिंग्स के अंदर आप सोच रहे

होंगे दीदी नंबर्स के अंदर तो हमें पता है

कि कोई बड़ा नंबर होता है कोई छोटा नंबर

होता है स्ट्रिंग्स में आप कैसे कंपेयर कर

लेंगे कि हेलो और हेलो टू के अंदर कौन

बड़ा है या फिर हेलो और वर्ल्ड के अंदर

कौन बड़ा है तो स्ट्रिंग्स के अंदर जैसे

हम कैरेक्टर्स की बात करें तो जो कैरेक्टर

a है उसकी वैल्यू कम मानी जाती है और

कैरेक्टर बी की वैल्यू ज्यादा मानी जाती

है तो जिस भी स्ट्रिंग के अंदर जो पहला

कैरेक्टर आएगा जिसकी वैल्यू ज्यादा होगी

कंपैरिजन में वो स्ट्रिंग बड़ी होगी जैसे

एग्जांपल लेकर अगर समझे तो हेलो और

वेलो का अगर हम एग्जांपल लें तो इसके अंदर

वेलो वाली स्ट्रिंग बड़ी है और हेलो वाली

स्ट्रिंग छोटी है क्योंकि इसमें पहला

पॉइंट ऑफ डिफरेंस आया ए और ड का और ए और

डब् की जब लड़ाई हुई तो डब् जीत गया और ए

हार गया तो डब् जो है वो बड़ी स्ट्रिंग है

और हेलो छोटी स्ट्रिंग है यहीं पर अगर

हेलो की जगह हमारे पास

होता

चलो तो यहां पर क्या होता h जो है वो बड़ी

स्ट्रिंग है और सी छोटी स्ट्रिंग है तो h

जीत जाता सी से तो यहां पर हेलो बड़ी

स्ट्रिंग होता एंड सीई एल एल ओ जिसके अंदर

सी छोटा कैरेक्टर पहले आता है वो छोटी

स्ट्रिंग होता मान लीजिए यहां पर होता ए ए

हेलो

और ए

ए बेलो इस केस में शुरू का ए ए और ये ए ए

तो सेम है लेकिन उसके बाद जो h है और जो

बी है उनमें लड़ाई होती उनकी लड़ाई होती

तो एच जीत जाता क्योंकि एच बड़ा है और बी

हार जाता तो ये वाली स्ट्रिंग जो है वो

बड़ी हो जाती तो इस तरीके से जावा के अंदर

स्ट्रिंग्स कंपेयर होती है पहला कैरेक्टर

जो डिस सिमिलर होता है जो अलग होता है

उनकी लड़ाई होती है उसमें से जो बड़ा होता

है वो जीत जाता है एंड इसी तरीके से हमारे

पास लार्ज स्ट्रिंग आती है तो कुछ इस

तरीके से स्ट्रिंग्स को कंपेयर करेंगे

इसको एक बार रन करके हम चेक कर लेते हैं

कि आउटपुट में क्या आने वाला

है तो स्ट्रिंग्स आर इक्वल जो हमें पता था

लेकिन यहां पर अगर 22 कर दें तो क्या

प्रिंट

होगा तो हमारे पास प्रिंट होकर आएगा कि

स्ट्रिंग्स आर नॉट इक्वल अब आप इसमें एक

चीज पूछ सकते हैं कि हमने एफ एल्स पढ़ा था

एफ एल्स के अंदर हमने देखा था कि जब भी दो

चीजों को कंपेयर करना होता है तो हम तो

सिंपली दो इक्वल टू लगा सकते हैं तो एक

बार देख लेते हैं कि तो इक्वल टू लगाने से

क्या होगा इसी सेम चीज को हम कॉपी कर देते

हैं और यहां पर क्या लिखते हैं सिर्फ यहां

सिर्फ लिखते हैं नेम वन इ इक्वल टू नेम टू

और इस पार्ट को हम कर देते हैं कॉमेंट आउट

नेम 1 = टू नेम टू लिखने से क्या

हुआ शुरुआत में टोनी एंड टोनी टू हमने पास

किया तो हमारे लिए प्रिंट हुआ स्ट्रिंग्स

आर नॉट इक्वल लेकिन सिर्फ टोनी एंड टोनी

पास करते एंड उसके बाद इस कोड को रन करते

तो फिर प्रिंट होता स्ट्रिंग्स आर इक्वल

ये तो बिल्कुल सही चल रहा है तो इज इक्वल

टू इज इक्वल टू अगर था पहले से तो हमने

कंपेयर टू फंक्शन क्यों यूज किया कंपेयर

टू फंक्शन को इसलिए यूज किया क्योंकि ये

इज इक्वल टू इज इक्वल टू बहुत सारे केसेस

में फेल हो जाता है और वो केसेस हम

कभी-कभी रियलाइफ नहीं करते इसीलिए इ इक्वल

टू इ इक्वल टू लिखेंगे तो किसी

कॉन्टेक्स्ट में अगर बैठे होंगे तो वहां

पर कुछ टेस्ट केसेस हमारे लिए फेल हो

जाएंगे कुछ क्वेश्चंस के आंसर्स हमारे लिए

निकलेंगे ही नहीं जिसका एक एग्जांपल लेते

हैं मान लीजिए हम एक नई स्ट्रिंग बनाते

हैं न्यू स्ट्रिंग करके हम नई स्ट्रिंग

बना सकते हैं जावा के अंदर ये जो स्ट्रिंग

बनाने का तरीका है ये नॉन प्रिमिटिव

टाइप्स को डिक्लेयर करने का भी तरीका है

न्यू स्ट्रिंग के अंदर हम क्या करेंगे पास

करेंगे टोनी और इसको इ इक्वल टू इ इक्वल

टू से कंपेयर करते हैं न्यू

स्ट्रिंग टोनी तो हमने दो स्ट्रिंग्स बनाई

है जिन दोनों के अंदर हमने सेम चीज स्टोर

करवाई है व्हिच इज टोनी अब यहां पर अगर ये

इक्वल होता है तो हम सेम चीज प्रिंट

करवाएंगे लेकिन अगर इक्वल टू नहीं होता तो

उस केस में प्रिंट करवाएंगे स्ट्रिंग्स आर

नॉट इक्वल और इस पार्ट को हम कर देते हैं

कॉमेंट आउट इस कोड को सेव करते हैं और इसे

रन करते

हैं रन किया तो हमारे लिए प्रिंट हुआ

स्ट्रिंग्स आर नॉट इक्वल ऐसा क्यों हुआ जब

हमने नई स्ट्रिंग बनाई थी तो पहली

स्ट्रिंग में भी टोनी पास किया दूसरी में

भी टोनी पास किया और इन्हीं को तो पहले

कंपेयर करके हमारा सही आंसर आया था अब गलत

आंसर क्यों आ रहा है क्योंकि जावा के अंदर

स्ट्रिंग्स ऑब्जेक्ट्स होती हैं और नॉर्मल

जो प्रिमिटिव टाइप्स जो वेरिएबल हम अभी तक

पढ़ते आए हैं वो मेमोरी में किस तरीके से

काम करते हैं उनकी अलग फंक्शनिंग है

ऑब्जेक्ट्स मेमोरी में किस तरीके से स्टोर

होती हैं उनकी अलग फंक्शनिंग है और यहां

पर गलत आंसर क्यों आया इसका एक्सप्लेनेशन

हम स्ट्रिंग बिल्डर पढ़ते टाइम यानी

नेक्स्ट वीडियो के शुरुआत में सीख रहे

होंगे जहां पर हम बात करेंगे कि

स्ट्रिंग्स जावा के अंदर एक्चुअली मेमोरी

में स्टोर कैसे होती हैं और स्ट्रिंग

बिल्डर नाम की क्लास की हमें जरूरत क्यों

पड़ी जब हमारे पास ऑलरेडी स्ट्रिंग्स थी

तो तो अभी के लिए हम मान लेते हैं कि इज

इक्वल टू इज इक्वल टू यूज नहीं करना डॉट

कंपेयर्स टू फंक्शन का यूज करना है जब भी

स्ट्रिंग्स को कंपेयर करना है अब बात करते

हैं जावा के अंदर सब स्ट्रिंग्स की सब

स्ट्रिंग क्या होता है मान लीजिए हमारे

पास एक कोई बड़ी सी स्ट्रिंग है उसका हमें

छोटा सा पार्ट निकालना है वो हम निकालते

हैं सब स्ट्रिंग्स की फॉर्म से सब मतलब

किसी भी बड़े पार्ट का छोटा पार्ट तो

स्ट्रिंग का छोटा पार्ट यानी सब स्ट्रिंग

अब अब हमें

अपना कोई स्ट्रिंग जो है वोह डिफाइन करना

पड़ेगा तो मान लीजिए हमारी स्ट्रिंग में

लिखा

है स्ट्रिंग का नाम ले लेते

हैं सेंटेंस हमारे पास एक सेंटेंस गिवन है

जिसमें लिखा हुआ है माय नेम इज टोनी अब इस

स्ट्रिंग के अंदर हमें सिर्फ टोनी जो नाम

है वो इससे निकालना है यानी इसका एक

सबस्ट्रिंग निकालना है उसको कैसे

निकालेंगे हम यूज करेंगे डॉट सबस्ट्रिंग

नाम के फंक्शन का तो यहां पर लिखेंगे नेम

इज इक्वल टू तो हम सेंटेंस डॉट सबस्ट्रिंग

और इसके अंदर पास करेंगे बिगिनिंग इंडेक्स

और एक एंडिंग इंडेक्स हम बिगिनिंग इंडेक्स

देंगे 1 2 3 4 5 6 7 8 9 10

11 और एंडिंग इंडेक्स जो है वो बाय

डिफॉल्ट जा रहा होगा तो सबसे पहले समझते

हैं कि सबस्ट्रिंग फंक्शन करता क्या है सब

फंक्शन एक बिगिनिंग इंडेक्स लेता है एक

एंडिंग इंडेक्स लेता है मतलब अपनी

स्ट्रिंग के अंदर आपको जो भी पार्ट

निकालना है सबसे पहले वो पार्ट कहां से

शुरू हो रहा है उसका आप हमें बिगिनिंग

इंडेक्स दे दीजिए स्टार्टिंग इंडेक्स और

वो पार्ट कहां पर खत्म हो रहा है उसका आप

हमें एंडिंग इंडेक्स दे दीजिए और ये दोनों

आप दे देंगे तो जो बीच का स्ट्रिंग का

पार्ट होगा वो हम आपको रिटर्न करके दे

देंगे आप उसको कहीं पे स्टोर करवा लीजिए

तो उसे हमने यहां पर नेम में स्टोर करवा

दिया और यहां पर एंडिंग इंडेक्स जो है

उसको ले लेते हैं हमें इस पूरे की लेंथ

कैलकुलेट नहीं करनी तो सिंपली लिख देंगे

सेंटेंस

डॉट लेंथ है हमारा एंडिंग इंडेक्स अब यहां

पर जो भी हम एंडिंग इंडेक्स पास करते हैं

सब स्ट्रिंग के अंदर वो नॉन इंक्लूसिव

होता है मतलब वो एक्सक्लूसिव होता है यानी

अगर हमने रो और फोर पास किया तो रो से

लेकर सिर्फ थ्री तक के जो सब स्ट्रिंग है

वो हमारे पास रिटर्न होकर आईगी 0 और फाइव

पास किया तो रो और फोर तक की सब स्ट्रिंग

रिटर्न होकर आएगी फाइव इंक्लूडेड नहीं

होगा तो यहां पर हमने 11 और पूरे सेंटेंस

की लेंथ जो पास की है उसमें हमारे पास

सिर्फ वो वाला पार्ट रिटर्न होकर आएगा

जिसमें सेंटेंस डॉट लेंथ नहीं होगा आखरी

इंडेक्स सेंटेंस डॉट लेंथ -1 एक से

इंडेक्स कम होकर कंसीडर होगा इस फंक्शन के

अंदर तो यहां से हम इसे हटा देते हैं एंड

हमारी स्ट्रिंग के अंदर हमने नेम जो है वह

स्टोर करवा लिया है इसे अगर प्रिंट

करें तो कुछ इस तरीके से माय नेम इज टोनी

हमने एक सेंटेंस लिया था उसके अंदर 11वां

इंडेक्स यानी जहां से टी शुरू हो रहा है

दिस इज एट 11थ इंडेक्स वहां से लेकर आखिरी

इंडेक्स जो भी होगा वो सेंटेंस डॉट लेंथ

से निकल आएगा वहां तक की हमने सबस्ट्रिंग

निकाल ली इस सेंटेंस से हमने जो नेम

निकाला वो आ गया है पूरा का पूरा टोनी अब

मान लेते हैं कि हमारे पास एक और सेंटेंस

होता जिसमें होता टोनी स्टार्क अब यहां पर

क्या करते सबस्ट्रिंग ले लेते रो से शुरू

होने वाली और 0 1 2 3 थर्ड इंडेक्स तक

हमें उस स्ट्रिंग का एंड चाहिए पर थ्री

नहीं पास करेंगे यहां पर पास करेंगे हम

फोर अब इसे सेव करते हैं और इसको रन करते

हैं तो देखते हैं क्या प्रिंट होगा हमारे

लिए हमारे लिए प्रिंट होगा टोनी अब मान

लीजिए हमें सिर्फ स्टार्क चाहिए तो सिर्फ

स्टार्क चाहिए तो हमें पता है कि स्टार्क

फिफ्थ इंडेक्स से शुरू हो रहा है तो फाइव

पास करेंगे और यहां पर हम एंडिंग इंडेक्स

पास नहीं करेंगे जब हमने एंडिंग इंडेक्स

पास नहीं किया तो बाय डिफॉल्ट उसने जो

लास्ट इंडेक्स है इस स्ट्रिंग का उसको

एंडिंग इंडेक्स ले लिया या तो जब हमारा

लास्ट इंडेक्स ही एंडिंग इंडेक्स हो इस

फंक्शन के लिए तो हमें कुछ पास करने की

जरूरत नहीं है अब इसको भी रन करके देख

लेते हैं तो हमारे लिए स्टारक का s प्रिंट

नहीं हुआ बिकॉज़ इट इज एट इंडेक्स फोर इसे

एक बार और रन करते हैं तो अब हमारे लिए

पूरा का पूरा स्टार्क प्रिंट होकर आ गया

है तो कुछ इस तरीके से स्ट्रिंग्स के लिए

हम उनकी सब स्ट्रिंग्स को कैलकुलेट करते

हैं अब ये हमने थोड़े बहुत कॉन्सेप्ट्स

पढ़ लिए हैं स्ट्रिंग्स के इसके साथ भी

बहुत सारे कॉन्सेप्ट्स हैं जैसे किसी

स्ट्रिंग के अंदर अगर हमें सिर्फ 1 2 3

कोई नंबर दिया है तो उसको हम इंटी जर में

कैसे कन्वर्ट करें या अगर हमें कोई इंटी

जर दिया है तो उसको स्ट्रिंग में कैसे

कन्वर्ट करें तो एक तरीके से बोनस

क्वेश्चन है जो नीचे नोट्स आपको दिए हुए

हैं इस लेक्चर के उसके अंदर आपको ये टॉपिक

मिला होगा बाकी इस टॉपिक को आगे जब हम

क्वेश्चंस कर रहे होंगे स्ट्रिंग्स के तो

उसमें कंसीडर करेंगे वहां पर हम इस

कांसेप्ट के बारे में सीखेंगे जिन लोगों

को पहले से स्ट्रिंग के बारे में थोड़ा

बहुत पता था वो इस कांसेप्ट को इस

कांसेप्ट को पार्सिंग कहते हैं पार्सिंग

के कांसेप्ट को आप जाकर एक्सप्लोर कर सकते

हैं इसके अलावा एक लास्ट कांसेप्ट जो हम

इस वीडियो के अंदर सीख रहे होंगे वो यह है

कि स्ट्रिंग्स आर इम

म्यूटेशन को चेंज नहीं कर सकते उसके अंदर

कुछ डिलीट नहीं कर सकते उसके अंदर कुछ ऐड

नहीं कर सकते उसको मॉडिफाई नहीं कर सकते

अगर उसको मॉडिफाई करना है उसमें कुछ भी

चेंजेज लाने हैं तो आपको एक नई स्ट्रिंग

बनानी पड़ेगी ये कांसेप्ट बहुत इंपॉर्टेंट

है जावा के अंदर और इसको हमें याद रखना है

कि स्ट्रिंग्स आर इ म्यूटेशन सेप्ट का हम

नेक्स्ट स्ट्रिंग बिल्डर की क्लास में यूज

कर रहे होंगे एंड इसको काफी अच्छे से हमें

अपने दिमाग में बिठा लेना है क्योंकि काफी

जगह इंटरव्यूज में पूछ लिया जाता है

स्ट्रिंग्स के बारे में तो हमें पता हो ये

छोटा सा थोरेट्स है इसके बारे में डिटेल

में हम आगे पढ़ रहे होंगे आई होप नीचे जो

नोट्स दिए हैं लेक्चर के उनको आप रेफर कर

रहे होंगे सिमिलर जो हमने क्वेश्चंस किए

हैं वैसे से ही आपको कोड्स मिल जाएंगे

वहां पर कुछ क्वेश्चन मिल जाएंगे

स्ट्रिंग्स के ऊपर प्रैक्टिस करने के लिए

आज के लिए इतना ही मिलते हैं नेक्स्ट

वीडियो में टिल देन कीप लर्निंग एंड कीप

प्रैक्टिसिंग