Your blog preview needs the first 80 characters of a post, and half the posts are shorter than that. substring(0, 80) throws; the Groovy take() method just returns what exists. This post works through 12 tested examples of Groovy take() on strings and lists, plus takeRight() and takeWhile(), and the edge cases where index math bites.

“Good code doesn’t crash on edge cases. Great code handles them gracefully by default.”

Last Updated: July 2026 | Tested on: Groovy 5.0.6, Java 17+ | Difficulty: Beginner | Reading Time: 14 minutes

Here’s a situation every developer has faced: you need the first N characters of a string. Maybe you’re building a preview for a blog post, truncating a display name, or pulling a prefix from a product code. In Java, you’d reach for substring(0, n) – and then immediately worry about StringIndexOutOfBoundsException if the string is too short.

Groovy’s take() method fixes that problem completely. It gives you the first N characters of a string, and if there aren’t enough characters? It just returns whatever is there. No exception. No crash. No boundary check needed on your end.

In this post, we’ll explore the Groovy take() method in depth – with 12 tested examples covering strings, lists, edge cases, and real-world scenarios. If you’re coming from our Groovy substring tutorial, you’ll quickly see why take() is often the better choice for getting the groovy first n characters of a string.

The diagram below shows how take(n) decides what to return based on the value of n: zero or negative gives an empty string, a value larger than the string returns the whole thing, and anything in between returns the first n characters, so it never throws:

Tip: click the diagram to open it full screen, then use the zoom and pan controls for a closer look.

What is Groovy take()?

The take() method is a GDK (Groovy Development Kit) method added to java.lang.String, java.util.List, and other iterable types. When called on a String, it returns a new string containing the first N characters.

According to the official Groovy GDK documentation, take(int num) returns a CharSequence containing the first num elements from the CharSequence. If the CharSequence is shorter than num characters, the entire CharSequence is returned.

Key Points:

• take(n) returns the first N characters from a string
• If N is greater than the string length, it returns the whole string – no exception thrown
• If N is 0, it returns an empty string
• Works on strings, lists, arrays, sets, and any iterable
• Added by the GDK – not available in plain Java
• Pairs perfectly with drop() (its opposite – which skips the first N characters)

Why Use take() Instead of substring()?

The main reason is safety. Java’s substring() throws a StringIndexOutOfBoundsException when the index exceeds the string length. That means every time you use it, you either need a length check or a try-catch block. With take(), the boundary check is built in.

Here’s the comparison at a glance:

Bottom line: if you’re writing Groovy and you want the groovy first n characters of a string, take() is almost always the right call.

Syntax and Basic Usage

The syntax is as simple as it gets:

take() Syntax

// String.take(int num)
// Returns: String containing the first 'num' characters

def str = "Hello, Groovy!"
def result = str.take(5)
println result
println result.getClass().name

Output

Hello
java.lang.String

That’s it. One argument – the number of characters you want. The return type is a String. No start index, no end index, no confusion. Here are the practical examples.

12 Practical take() Examples

Example 1: Basic take() – Get First N Characters

The simplest use case – grab the first few characters from a string.

Basic take() Usage

def greeting = "Hello, World!"

println greeting.take(1)    // First character
println greeting.take(5)    // First 5 characters
println greeting.take(7)    // First 7 characters
println greeting.take(13)   // All 13 characters

Output

H
Hello
Hello,
Hello, World!

Notice how take(7) includes the comma and the space – it counts every character, including whitespace and punctuation.

Example 2: take() with n Greater Than String Length (Safe!)

This is where take() really shines. When you ask for more characters than the string has, it just returns the whole string. No exception, no crash, no defensive coding needed.

take() with n > length

def short_str = "Hi"

// Asking for way more characters than available
println short_str.take(5)      // No crash!
println short_str.take(100)    // Still no crash!
println short_str.take(10000)  // Totally safe!

// Compare with substring - this would crash:
try {
    println short_str.substring(0, 5)
} catch (StringIndexOutOfBoundsException e) {
    println "substring() crashed: ${e.message}"
}

Output

Hi
Hi
Hi
substring() crashed: begin 0, end 5, length 2

This is the number one reason developers prefer take() over substring(). You don’t need to write Math.min(n, str.length()) every time – take() handles it automatically.

Example 3: take() on Empty Strings

What happens when the string is empty? Exactly what you’d hope – you get an empty string back, no matter what number you pass.

take() on Empty Strings

def empty = ""

println "'${empty.take(0)}'"   // take 0 from empty
println "'${empty.take(1)}'"   // take 1 from empty
println "'${empty.take(5)}'"   // take 5 from empty
println "'${empty.take(100)}'" // take 100 from empty

// All return empty string - safe!
println "Length: ${empty.take(50).length()}"

Output

''
''
''
''
Length: 0

This makes take() perfect for processing user input or database fields that might be empty. You never need to check if (str.length() >= n) before calling it.

Example 4: take(0) and take() with Negative Numbers

Here are the boundary conditions – what happens with zero and negative values?

take() Boundary Conditions

def text = "Groovy is awesome"

// take(0) always returns empty string
println "'${text.take(0)}'"

// Negative numbers - returns empty string
println "'${text.take(-1)}'"
println "'${text.take(-100)}'"

// Confirm the original string is unchanged
println text

Output

''
''
''
Groovy is awesome

Passing zero or a negative number returns an empty string. And importantly, take() never modifies the original string – it always returns a new one. Strings in Groovy (like Java) are immutable.

Example 5: take() with GStrings and Interpolation

Since take() works on CharSequence, it handles GStrings just as well as regular Strings.

take() with GStrings

def language = "Groovy"
def version = "5.0"

// GString interpolation then take()
def full = "Language: ${language} v${version}"
println full
println full.take(15)

// take() inside GString interpolation
println "First 3: ${language.take(3)}"
println "Preview: ${'Apache Groovy Programming'.take(14)}..."

// Dynamic take amount
def n = 8
println "Dynamic: ${full.take(n)}"

Output

Language: Groovy v5.0
Language: Groov
First 3: Gro
Preview: Apache Groovy ...
Dynamic: Language

You can chain take() with GString interpolation for clean, concise text formatting. This is especially useful in logging and UI display code.

Example 6: take() vs substring() – Side by Side

Let’s put them head to head so you can see the difference clearly.

take() vs substring() Comparison

def text = "Hello"

// Both work fine when n <= length
println "take(3):      '${text.take(3)}'"
println "substring(3): '${text.substring(0, 3)}'"

// take() is safe, substring() is not
println "\n--- When n > length ---"
println "take(20): '${text.take(20)}'"

try {
    println "substring(20): '${text.substring(0, 20)}'"
} catch (e) {
    println "substring(20): EXCEPTION - ${e.class.simpleName}"
}

// take() is cleaner for common patterns
def items = ["Hi", "Hello", "Hey there, how are you?", "", "OK"]
println "\n--- Truncate all to 5 chars ---"
items.each { item ->
    println "take: '${item.take(5).padRight(5)}' | original: '${item}'"
}

Output

take(3):      'Hel'
substring(3): 'Hel'

--- When n > length ---
take(20): 'Hello'
substring(20): EXCEPTION - StringIndexOutOfBoundsException

--- Truncate all to 5 chars ---
take: 'Hi   ' | original: 'Hi'
take: 'Hello' | original: 'Hello'
take: 'Hey t' | original: 'Hey there, how are you?'
take: '     ' | original: ''
take: 'OK   ' | original: 'OK'

The take() version is shorter, safer, and more readable. No need for Math.min() or try-catch blocks.

Example 7: take() Combined with drop()

The take() and drop() methods are natural complements. Together, they let you split a string at any position without using substring().

take() and drop() Together

def code = "GRV-2024-001"

// Split at position 3
def prefix = code.take(3)
def rest = code.drop(3)
println "Prefix: '${prefix}', Rest: '${rest}'"

// Extract parts of a product code
def year = code.drop(4).take(4)
def serial = code.drop(9)
println "Year: ${year}, Serial: ${serial}"

// take + drop = original string (always!)
def original = "Groovy"
println "${original.take(3)}${original.drop(3)} == ${original}"
println "Equals: ${original.take(3) + original.drop(3) == original}"

Output

Prefix: 'GRV', Rest: '-2024-001'
Year: 2024, Serial: 001
Groovy == Groovy
Equals: true

This pattern – take(n) + drop(n) – always reconstructs the original string. It’s a clean way to think about string slicing. For a deeper look at drop(), check out our Groovy drop() tutorial.

Example 8: take() on Lists and Collections

One of the great things about take() is that it’s not limited to strings. It works on any iterable – lists, sets, ranges, and more.

take() on Collections

// Lists
def fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
println fruits.take(3)
println fruits.take(10)  // Safe - returns all 5

// Ranges
def range = (1..20)
println range.take(5)

// Arrays
def arr = [10, 20, 30, 40, 50] as Integer[]
println arr.take(3)

// Sets (order may vary)
def set = ['Groovy', 'Java', 'Kotlin', 'Scala'] as LinkedHashSet
println set.take(2)

// Maps (via entrySet)
def map = [name: 'Alice', age: 30, city: 'London', role: 'Dev']
println map.take(2)

Output

[apple, banana, cherry]
[apple, banana, cherry, date, elderberry]
[1, 2, 3, 4, 5]
[10, 20, 30]
[Groovy, Java]
[name:Alice, age:30]

The same safety guarantee applies to collections – if you ask for more elements than exist, you just get everything. This makes take() ideal for pagination, preview lists, and “show top N” scenarios.

Example 9: takeWhile() – Conditional Taking

While take(n) grabs a fixed number of characters, takeWhile() keeps taking characters as long as a condition is true. The moment the condition fails, it stops.

takeWhile() on Strings

// Take while character is a letter
def mixed = "Hello123World"
println mixed.takeWhile { Character.isLetter(it as char) }

// Take while character is a digit
def code = "12345ABC"
println code.takeWhile { Character.isDigit(it as char) }

// Take while character is lowercase
def camelCase = "firstName"
println camelCase.takeWhile { it ==~ /[a-z]/ }

// Take while not a space
def sentence = "Hello World"
println sentence.takeWhile { it != ' ' }

// Take while character is in a set
def vowelStart = "aeiXYZ"
println vowelStart.takeWhile { it in ['a', 'e', 'i', 'o', 'u'] }

Output

Hello
12345
first
Hello
aei

The takeWhile() method is incredibly useful for parsing structured text. You can extract prefixes, numeric portions, or any leading segment that matches a pattern – all without regex.

Example 10: takeWhile() on Lists

Just like take(), takeWhile() works on lists and collections too.

takeWhile() on Collections

// Take while numbers are positive
def numbers = [5, 3, 8, -1, 4, 2]
println numbers.takeWhile { it > 0 }

// Take while strings are short
def words = ['Hi', 'OK', 'Hey', 'Hello', 'Greetings', 'Yo']
println words.takeWhile { it.length() <= 3 }

// Take while values are even
def nums = [2, 4, 6, 7, 8, 10]
println nums.takeWhile { it % 2 == 0 }

// Useful for sorted data - take while score is above threshold
def scores = [98, 95, 92, 88, 75, 60, 45]
println "Honor roll: ${scores.takeWhile { it >= 90 }}"

Output

[5, 3, 8]
[Hi, OK, Hey]
[2, 4, 6]
Honor roll: [98, 95, 92]

An important detail: takeWhile() stops at the first element that doesn’t match the condition. It doesn’t skip non-matching elements and continue – it takes a contiguous prefix. Notice how [5, 3, 8, -1, 4, 2].takeWhile { it > 0 } returns [5, 3, 8] but not [4, 2].

Example 11: Chaining take() with Other Methods

Groovy’s method chaining lets you combine take() with other string methods for useful one-liners.

Chaining take() with Other Methods

def text = "  Hello, Groovy World!  "

// Trim then take
println text.trim().take(5)

// Take then uppercase
println "Hello, World!".take(5).toUpperCase()

// Take, reverse, take again
println "ABCDEFGHIJ".take(6).reverse().take(3)

// Collect first characters of each word
def sentence = "Groovy Domain Specific Language"
def acronym = sentence.split(' ').collect { it.take(1) }.join()
println acronym

// Chain with padRight for fixed-width output
def names = ['Al', 'Alexandra', 'Bob', 'Christopher']
names.each { name ->
    println "${name.take(8).padRight(8)} | ${name.length()} chars"
}

Output

Hello
HELLO
FED
GDSL
Al       | 2 chars
Alexandr | 9 chars
Bob      | 3 chars
Christop | 11 chars

The acronym pattern – split(' ').collect { it.take(1) }.join() – is a classic Groovy one-liner. And notice how the padded output works perfectly even when names are shorter than the take length.

Example 12: takeRight() – Taking from the End

Groovy also provides takeRight() to grab characters from the end of a string. It has the same safety guarantees as take().

takeRight() Examples

def filename = "report-2024.pdf"

// Get file extension
println filename.takeRight(4)

// Get last 3 characters
println "Groovy".takeRight(3)

// Safe with n > length
println "Hi".takeRight(100)

// Combine take() and takeRight()
def text = "ABCDEFGHIJ"
println "First 3: ${text.take(3)}, Last 3: ${text.takeRight(3)}"

// Extract parts from a formatted string
def timestamp = "2026-03-08T14:30:00"
def date = timestamp.take(10)
def time = timestamp.takeRight(8)
println "Date: ${date}, Time: ${time}"

Output

.pdf
ovy
Hi
First 3: ABC, Last 3: HIJ
Date: 2026-03-08, Time: 14:30:00

The takeRight() method is perfect for extracting file extensions, trailing codes, and suffixes. Combined with take(), you can pull from both ends of a string without any index calculations.

take() vs substring() Comparison

Let’s settle the take() vs substring() debate with a practical comparison. When should you use which?

When to Use take() vs substring()

def text = "Hello, Groovy!"

// USE take() - when you want the first N characters
println text.take(5)                  // "Hello"

// USE substring() - when you need a range from the middle
println text.substring(7, 13)         // "Groovy"

// USE take() + drop() - as an alternative to substring(start, end)
println text.drop(7).take(6)          // "Groovy" - same result!

// USE take() - when the string might be shorter than expected
def userInput = "Hi"
println userInput.take(50)            // Safe: "Hi"
// println userInput.substring(0, 50) // CRASH!

// USE substring() - when you need guaranteed exact length
// and want an exception if the data is wrong
def fixedFormat = "AAABBBCCC"
assert fixedFormat.substring(3, 6) == "BBB"
println "Fixed format extraction: ${fixedFormat.substring(3, 6)}"

Output

Hello
Groovy
Groovy
Hi
Fixed format extraction: BBB

The rule of thumb: use take() when you want safety and simplicity. Use substring() when you need to extract from the middle of a string and want the exception to alert you if data is in an unexpected format. For more substring techniques, see our Groovy substring tutorial.

takeWhile() – Conditional Taking

We saw takeWhile() in the examples above, but it deserves a closer look. While take(n) uses a fixed count, takeWhile() uses a closure that evaluates each element. It keeps taking as long as the closure returns true.

takeWhile() Advanced Patterns

// Extract numeric prefix from mixed strings
def parseNumericPrefix(String s) {
    s.takeWhile { Character.isDigit(it as char) || it == '.' }
}

println parseNumericPrefix("123.45abc")
println parseNumericPrefix("99bottles")
println parseNumericPrefix("noNumbers")

// Extract domain from URL-like strings
def url = "example.com/path/to/page"
def domain = url.takeWhile { it != '/' }
println "Domain: ${domain}"

// Get the leading whitespace (indentation)
def indented = "    def x = 10"
def indent = indented.takeWhile { it == ' ' }
println "Indent level: ${indent.length()} spaces"

// Parse CSV-like first field
def csvLine = 'John,Doe,35,London'
def firstName = csvLine.takeWhile { it != ',' }
println "First name: ${firstName}"

Output

123.45
99

Domain: example.com
Indent level: 4 spaces
First name: John

The takeWhile() method is essentially a “take until” pattern. It’s great for lightweight parsing where you don’t need the full power of regular expressions.

take() on Lists and Collections

We touched on this in Example 8, but here are some more practical patterns with collections.

take() Collection Patterns

// Pagination - show page of results
def allUsers = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve',
                'Frank', 'Grace', 'Hank', 'Ivy', 'Jack']

def pageSize = 3
def page1 = allUsers.take(pageSize)
def page2 = allUsers.drop(pageSize).take(pageSize)
def page3 = allUsers.drop(pageSize * 2).take(pageSize)

println "Page 1: ${page1}"
println "Page 2: ${page2}"
println "Page 3: ${page3}"

// Top N from a sorted list
def scores = [95, 88, 92, 77, 85, 99, 63, 91]
def top3 = scores.sort { -it }.take(3)
println "\nTop 3 scores: ${top3}"

// Preview of a long list
def longList = (1..100).toList()
println "Preview: ${longList.take(5)}... (${longList.size()} total)"

Output

Page 1: [Alice, Bob, Charlie]
Page 2: [Diana, Eve, Frank]
Page 3: [Grace, Hank, Ivy]

Top 3 scores: [99, 95, 92]
Preview: [1, 2, 3, 4, 5]... (100 total)

The pagination pattern using drop(offset).take(pageSize) is clean and expressive. No index math, no subList bounds checking.

Real-World Use Cases

Here are some practical scenarios where take() is the perfect tool.

Truncating Display Names

Truncating Display Names

def truncateName(String name, int maxLen) {
    if (name.length() <= maxLen) return name
    return name.take(maxLen - 3) + '...'
}

println truncateName("Alexander Hamilton", 15)
println truncateName("Bob", 15)
println truncateName("Christopher Jonathan Wren", 20)
println truncateName("Al", 5)

// Initials from full name
def getInitials(String fullName) {
    fullName.split(/\s+/).collect { it.take(1).toUpperCase() }.join()
}

println "\nInitials: ${getInitials('John Michael Doe')}"
println "Initials: ${getInitials('Alice')}"
println "Initials: ${getInitials('mary jane watson')}"

Output

Alexander Ha...
Bob
Christopher Jonat...
Al

Initials: JMD
Initials: A
Initials: MJW

Building Text Previews

Building Text Previews

def createPreview(String text, int maxLen = 50) {
    def cleaned = text.replaceAll(/\s+/, ' ').trim()
    if (cleaned.length() <= maxLen) return cleaned

    // Take up to maxLen, then find the last space to avoid cutting words
    def truncated = cleaned.take(maxLen)
    def lastSpace = truncated.lastIndexOf(' ')
    if (lastSpace > maxLen * 0.6) {
        return truncated.take(lastSpace) + '...'
    }
    return truncated + '...'
}

def article = """Groovy is a powerful, optionally typed and dynamic language
    for the Java platform. It integrates smoothly with any Java program and
    immediately delivers powerful features including scripting capabilities."""

println createPreview(article)
println createPreview(article, 30)
println createPreview("Short text")

Output

Groovy is a powerful, optionally typed and...
Groovy is a powerful,...
Short text

Log Message Formatting

Log Message Formatting

def formatLog(String level, String module, String message) {
    def ts = new Date().format('HH:mm:ss')
    def lvl = level.take(5).toUpperCase().padRight(5)
    def mod = module.take(12).padRight(12)
    def msg = message.take(60)
    return "[${ts}] ${lvl} | ${mod} | ${msg}"
}

println formatLog("info", "UserService", "User login successful")
println formatLog("warning", "PaymentGateway", "Timeout on external API call to payment processor")
println formatLog("error", "DatabaseConnectionPool", "Connection refused after 3 retries - host unreachable")
println formatLog("debug", "Auth", "Token validation passed")

Output

[14:30:00] INFO  | UserService  | User login successful
[14:30:00] WARNI | PaymentGatew | Timeout on external API call to payment processor
[14:30:00] ERROR | DatabaseConn | Connection refused after 3 retries - host unreachable
[14:30:00] DEBUG | Auth         | Token validation passed

Using take() with padRight() creates perfectly aligned, fixed-width log output. The module names and log levels are automatically truncated to fit the format, and short values get padded. The timestamps come from new Date(), so when you run this you will see your current time instead of 14:30:00.

Edge Cases and Best Practices

Best Practices Summary

DO:

• Use take() instead of substring(0, n) when you just want the first N characters
• Pair take() with drop() to cleanly split strings without index math
• Use takeWhile() for condition-based extraction instead of regex for simple patterns
• Use takeRight() when you need characters from the end
• Combine take() with padRight() for fixed-width formatting

DON’T:

• Call take() on a null string – it will throw a NullPointerException (use safe navigation: str?.take(5))
• Assume take() is available in plain Java – it’s a Groovy GDK method
• Use take() when you specifically want an exception on unexpected input – use substring() for that

Null Safety with take()

// Null safety using Groovy's safe navigation operator
String nullStr = null

// This would crash: nullStr.take(5)
// Use safe navigation instead:
println nullStr?.take(5)          // null
println nullStr?.take(5) ?: ''    // empty string fallback

// Safe take helper
def safeTake(String s, int n) {
    s?.take(n) ?: ''
}

println "'${safeTake(null, 5)}'"
println "'${safeTake('', 5)}'"
println "'${safeTake('Hello', 3)}'"

Output

null

''
''
'Hel'

The ?. safe navigation operator is your friend when dealing with potentially null strings. Combine it with the Elvis operator (?:) for a complete null-safe take pattern.

Performance Considerations

For everyday use, take() and substring() perform about the same. Both create a new String object from the original. Here are a few things to keep in mind:

• Time complexity: O(n) where n is the number of characters taken – same as substring
• Memory: Creates a new String object each time – don’t call it in a tight inner loop on the same string repeatedly
• GDK overhead: take() has a tiny bit more overhead than substring() due to the GDK dispatch, but the difference is negligible in practice
• takeWhile(): Iterates character by character, so it’s O(k) where k is the number of characters before the condition fails
• For batch processing millions of strings, benchmark both approaches – the safety of take() usually outweighs any micro-performance difference

In short: don’t optimize prematurely. Use take() for its clarity and safety. Switch to substring() only if profiling shows it as a bottleneck – which it almost never will.

Conclusion

The Groovy take() method is one of those GDK additions that, once you start using, you can’t imagine coding without. It’s the safe, clean, readable way to get the first N characters from a string – and it works on lists, maps, and collections too.

We covered 12 practical examples, from basic usage to real-world patterns like truncating display names, building text previews, and formatting log messages. We also explored takeWhile() for conditional taking, takeRight() for taking from the end, and how take() pairs with drop() for clean string slicing.

Next up in the series, we’ll look at reversing strings in Groovy – another handy GDK method that Java doesn’t give you out of the box.

Summary

• take(n) safely returns the first N characters – no exception if n > string length
• takeRight(n) does the same from the end of the string
• takeWhile { condition } takes characters as long as a condition is true
• take(n) + drop(n) always equals the original string
• Works on strings, lists, arrays, sets, maps, and any iterable
• Use str?.take(n) for null safety

If you also work with build tools, CI/CD pipelines, or cloud CLIs, check out Command Playground to practice 105+ CLI tools directly in your browser — no install needed.

Up next: Groovy String reverse() – Reverse Strings Easily

Frequently Asked Questions

Interview Questions on Groovy take()

“Interviewers rarely ask for definitions. They ask what happens in situations like these.”

Q: A teammate needs the first ten records from an iterator over a huge database export and hesitates to call take(10), fearing it will pull the whole dataset first. Are they right?

No. The GDK overloads matter here: take(n) on an Iterator returns another Iterator that is lazy, so elements are only consumed from the source as you read them, and the export is never fully traversed. Call it on a List and you get an eager copy of up to n elements instead, which is also cheap. The thing to say out loud in an interview: check which receiver type you are holding, because the same method name has lazy and eager flavors depending on it.

Q: A dashboard shows “top 3 settings” using configMap.take(3) and the result is stable in tests but people ask whether that is guaranteed. What is your answer?

It depends on the map’s iteration order. Groovy map literals create LinkedHashMap, which preserves insertion order, so take(3) on a literal-built map is deterministic: you get the first three entries as written. But if that map ever arrives as a plain HashMap, say from a Java API or a JSON library configured differently, iteration order is unspecified and take(3) becomes a lottery. So the guarantee lives in the map implementation, not in take itself. If order matters, sort the entries explicitly before taking.

Q: Someone implements pagination over an in-memory list of a million rows with rows.drop(offset).take(pageSize) and later pages get slower and slower. Why?

Because on a List, drop(offset) materializes a new list containing everything after the offset. For page one that is nearly the whole million rows copied, and the copying cost grows with each deeper page, so latency climbs. Java’s subList(from, to) is a view, no copying, which makes it the right tool for slicing big in-memory lists. Even better is not holding a million rows at all: push pagination into the query. take and drop are lovely for small collections; they are not free on big ones.

Q: Your UI truncates titles with title.take(50) + "..." and QA complains that a 48-character title now displays with a pointless ellipsis. What is the correct pattern?

take() cannot tell you whether it actually shortened anything, so appending the ellipsis unconditionally is the bug. Guard on the original length: title.length() > 50 ? title.take(50) + "..." : title, ideally hidden in one truncate utility instead of repeated at every call site. Then mention the refinement that separates senior answers: counting UTF-16 units is not the same as counting visible characters, so for user-facing text with emoji you may need code-point-aware truncation, and trimming trailing whitespace before adding the ellipsis keeps the output tidy.

Related Posts

Previous in Series: Groovy Substring – Extract Parts of a String

Next in Series: Groovy String reverse() – Reverse Strings Easily

Related Topics You Might Like:

• Groovy String drop() – Skip First N Characters
• Groovy String Tutorial – The Complete Guide
• Groovy String To Integer – All Conversion Methods

This post is part of the Groovy & Grails Cookbook series on TechnoScripts.com