Strings | Lecture 12 | Java Placement Series

Main ideas / lessons

• Strings in Java (what they are):

  • A string is a non-primitive data type.
  • A string is used to store text such as a word, sentence, characters, etc.
  • Strings are used very extensively in Java and are connected to how Java handles memory.

• String declaration / definition:

  • The keyword/data type to declare a string is String (capital S).
  • Avoid naming your own class String because String is already a built-in Java class (capitalization matters).
  • You can assign values like Name, Full Name, or a whole sentence—including spaces (spaces are just characters).

• User input for strings (token vs full line):

  • To take user input, create a Scanner object (non-primitive).
  • Use next() when the user input is one word (a single token).
  • Use nextLine() when you need the entire line / sentence, including spaces.
  • Demonstrated behavior:
    • If the name is entered as “Tony Stark” and you use next(), only “Tony” is read.
    • If you use nextLine(), you get “Tony Stark”.

• Core string operations / functions covered:

  • Concatenation (joining strings)
  • length() (string length)
  • charAt(index) (accessing a character by position)
  • Comparison using compareTo() (lexicographic comparison)
  • Substring extraction using substring(beginIndex, endIndex)

• Important conceptual warning:

  • Strings are immutable: you cannot directly modify/delete/insert into an existing string.
  • Any “modification” results in creating a new string.
  • The video hints this is why StringBuilder exists and is used later for efficient modifications.

---

Methodology / step-by-step instructions (as presented)

1) Declare a string

• Use: java String variableName = "value";

• Notes:

  • Use capital S: String, not string.
  • Spaces inside quotes are allowed.
  • You can store single words or whole sentences.

2) Input a string from the user

• Steps:

  • Create a Scanner object (conceptually described): java Scanner sc = new Scanner(System.in);

  • Read input into a string variable using one of the following:

    • Use next() if input is a single word: java String name = sc.next();

    • Use nextLine() if you need a full line / sentence: java String name = sc.nextLine();

• Key rule:

  • next() stops at whitespace.
  • nextLine() includes spaces until the end of the line.

3) Concatenate (join) two strings

• Steps:

  • Create two strings (e.g., first name and last name).
  • Combine them using +: java String fullName = firstName + " " + lastName;

• Notes:

  • To include a space in output, insert " " between them.
  • Inline string literals can be used directly without storing them in separate variables.

4) Get string length

• Steps: java int len = someString.length();

• What it returns:

  • The number of characters in the string.

5) Print all characters in a string

• Steps:

  • Loop using the string’s length: java for (int i = 0; i < fullName.length(); i++)

  • Inside the loop, access each character: java fullName.charAt(i)

  • Print the returned character one by one.

6) Compare two strings

• Steps:

  • Prepare two strings (e.g., nameOne, nameTwo).
  • Use compareTo(): java nameOne.compareTo(nameTwo)

• Meaning of the returned value:

  • Positive → nameOne is greater
  • Zero → strings are equal
  • Negative → nameOne is less
• Lexicographic idea described:
  • The comparison is based on the first differing character.
  • When characters differ, the “greater” character determines which string is greater.

7) Extract substring(s) from a string

• Steps: java String part = sentence.substring(beginIndex, endIndex);

• Parameters:

  • beginIndex = start position (inclusive)
  • endIndex = end position (exclusive)
• Notes highlighted:
  • If endIndex is omitted, Java returns until the end of the string.
  • Example emphasis: substring from index 1 to 4 includes indices 1, 2, 3 (endIndex excluded).
  • endIndex can be sentence.length() to avoid manually calculating it.

8) When NOT to use == for string equality (as shown)

• The video demonstrates incorrect behavior when comparing strings with ==.
• Correct approach emphasized:
  • Use compareTo() (or equality methods, conceptually) for reliable string content comparison.
• Why == fails (briefly explained):
  • Strings are objects, and == compares reference/object identity rather than content.

---

Speakers / sources featured

• Speaker: The course instructor/host (“Hi everyone… welcome…”).
• Source libraries mentioned: Java String, Java Scanner (including System.in conceptually).