Study guide

7.2 Strings and String Operations

Praxis Computer Science 5652

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode

1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy

2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects

2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations

3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security

3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage

4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation

4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing

5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization

5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range

6 Chapter 6: Algorithms: Searching, Sorting, and Recursion

6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents

7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions

7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra

8 Chapter 8: Programming: Selection, Iteration, and Writing Code

8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code

9 Chapter 9: Programming: Procedures, Arrays, and Data Structures

9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)

10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality

10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback

11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs

11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs

12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design

12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding

13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption

13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs

14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection

14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing

15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments

15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored

16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity

16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs

7.2 Strings and String Operations

Key Takeaways Explain This Topic AI

In ETS pseudocode, strings are concatenated with + and characters are usually numbered from position 0.

When a method table says substring ( begin, end ) returns positions begin through end − 1, "computer".substring ( 3, 6 ) is "put".

String methods such as toUpperCase ( ) return a new string; unless the result is assigned or printed, the original value is unchanged.

Comparisons of strings use character codes, so uppercase letters (65–90 in ASCII) sort before lowercase letters (97–122).

In Java, compare string contents with equals, not ==, which compares object references.

Last updated: September 2026

What this competency asks

Within data types, ETS lists: identify the correct sequence of string operations to produce a given output . The discussion questions add: evaluate an expression that uses string operations . ETS's sample question on strings provides a table of methods ( toLowerCase , toUpperCase , substring , and length ) and asks which code segment turns "Applesauce" into "aPPLESAUCE". The skill is reading a method specification precisely and composing calls in the right order.

String basics

A string is a sequence of characters. Assume the positions are numbered starting at 0 , as ETS's sample table states:

  • Position 0 1 2 3 4 5 6 7
  • "computer" c o m p u t e r

Length: 8. The last position is length − 1 = 7.

Concatenation: "com" + "puter" is "computer" . "Score: " + 95 is "Score: 95" .

Empty string: "" has length 0.

A typical method table

Questions define the methods they use. A representative table looks like this:

  • Method Behavior
  • int length ( ) Returns the number of characters

String substring ( int begin, int end ) Returns the characters from position begin through end − 1 . ETS's sample table also returns "" for invalid positions

  • String toUpperCase ( ) Returns the string with letters converted to uppercase
  • String toLowerCase ( ) Returns the string with letters converted to lowercase
  • int indexOf ( String s ) Returns the position of the first occurrence of s , or −1 if it does not occur

Always use the table given in the question. Some languages define substring as (start, length) instead of (start, end). On the test, the stem's definition wins.

Reading substring correctly

With an exclusive end position:

  • Call on "computer" Result Why
  • substring ( 0, 1 ) "c" Position 0 only
  • substring ( 3, 6 ) "put" Positions 3, 4, 5
  • substring ( 1, length ( ) ) "omputer" Position 1 to the end
  • substring ( 4, 4 ) "" begin = end gives no characters

A useful identity: substring ( a, b ) has length b − a .

Composing operations to produce an output

Goal: turn "hELLO" into "Hello" .

The first character must become uppercase: value.substring ( 0, 1 ).toUpperCase ( ) gives "H" .

The rest must become lowercase: value.substring ( 1, value.length ( ) ).toLowerCase ( ) gives "ello" .

  • Concatenate: "H" + "ello" gives "Hello" . String value ← "hELLO"
  • value ← value.substring ( 0, 1 ).toUpperCase ( ) + value.substring ( 1, value.length ( ) ).toLowerCase ( )
  • print value

Traps in the answer choices usually include:

Converting the whole string in two steps, such as toUpperCase followed by toLowerCase . The second call undoes the first.

A substring that overlaps or skips a character, such as substring ( 0, 2 ) followed by substring ( 1, … ) , which repeats position 1.

Calling a method without assigning or using the result. Methods like toUpperCase ( ) return a new string; in most languages strings are immutable , so the original is unchanged.

  • Building and processing strings with loops
  • Reversing a string String word ← "code"
  • String result ← ""
  • for ( int i ← word.length ( ) - 1; i ≥ 0; i ← i - 1 )
  • result ← result + word.substring ( i, i + 1 )
  • end for
  • print result
  • i Character added result
  • 3 e "e"
  • 2 d "ed"
  • 1 o "edo"
  • 0 c "edoc"

Output: edoc . The loop starts at length ( ) - 1 , not length ( ) , which would be past the end.

  • Counting a character int count ← 0
  • for ( int i ← 0; i < text.length ( ); i ← i + 1 )
  • if ( text.substring ( i, i + 1 ) == "a" )
  • count ← count + 1
  • end if
  • end for

Other common patterns follow the same shape: checking for a palindrome (compare position i with position length − 1 − i), removing spaces (append only non-space characters), and finding the first vowel (stop when found).

Comparing strings

Equality: in ETS pseudocode == compares values. In Java , == compares object references . Use a.equals ( b ) to compare contents, or a.equalsIgnoreCase ( b ) to ignore case.

Ordering: strings are ordered lexicographically by character codes, like dictionary order but by code value. In ASCII, 'A' is 65 and 'a' is 97, so "Zebra" comes before "apple" . Digits (48–57) come before uppercase letters. Converting both strings to the same case gives a case-insensitive ordering.

Comparison stops at the first differing character . "cat" comes before "cattle" because it runs out of characters first.

Converting between strings and numbers

Input from a keyboard or a text file arrives as a String . "42" + 1 concatenates to "421" , while converting first, as with Integer.parseInt ( "42" ) + 1 in Java, gives 43. Going the other way, concatenating a number with a string converts the number to text. Programs that ask users for numbers should validate the text before converting it (Section 11.2).