Customer Reviews

Java Regular Expressions: Taming the java.util.regex Engine

5 star:		(7)
4 star:		(2)
3 star:		(4)
2 star:		(1)
1 star:		(1)

 

 

Java, with simplicity being the prime motto started off by striking off pointers, generics, multiple inheritance, regex, high-end reflection etc., from the core language. But as time progressed, folks at sun started bringing those features back into the language out of growing necessity. Java 1.2 added a proper Collections API, Java 1.3 added Dynamic Proxy model, Java 1.4 added Regex, Java 1.5 added generics and so on...

Regular Expressions (REGEX) are one of those weirdly named concepts that establishes a back-off-i-am-complex sort of impression at first sight. Admittedly, it has a strong mathematical foundation and a tidy sum of theory backing its existence. But, that doesnt mean that learning and using them in programming languages have to be difficult, in fact it is not even close to difficult as long as we are well guided by trained personnel.

In this book, the author attempts to train us on regular expressions as it applies to java.

Chapter 1 answers questions like "What is a regular expression" and "How to create regular expressions with that weird syntax".
In my opinion, this chapter is a tad quicker than one would like. So, those new to regex might find it a bit intimidating.

Chapter 2 introduces you to the java's regex object model. Specifically the Pattern and Matcher objects are addressed along with the additions to the String class.
At first, i thought that this chapter is nothing but a copy-paste of javadocs. Later, when i referred javadocs for further information i realized that the author truly took the pain to decode it before presenting it here. This chapter is a good reference for the java regex object model.

Chapter 3 explains the advanced concepts like groups, subgroups, back-references, greedy qualifiers, possessive qualifiers, reluctant qualifiers, positive look-aheads, negative look-aheads, positive look-behinds and negative look-behinds. Finally, the author enlightens us with some tips on how to create efficient regular expressions.
In my opinion, this section is too thin. It covers too many concepts in too little pages. I would have expected a more exhaustive coverage here.

Chapter 4 tries to demonstrate practical usage of regular expressions in the context of an object oriented language like java.
This chapter is too ambitious about being practical; and gets too involved with file I/O and NIO than is necessary. Reading this chapter is a waste of time because it neither explains NIO nor REGEX well.

Chapter 5 takes a few of real-life use-cases like Email validation, Phone Number validation etc. and attempts to solve it.
Again, i was hoping that this section will contain interesting information, but was very dissapointed. Many examples were a mere copy-paste from earlier chapters.

Bottomline, if you are looking for a head start in java regex; this book helps. But, if you are looking for an indepth coverage of concepts, the art of writing efficient expressions and are expecting to become a regex expert, then this book alone wont suffice. You might have to try reading this book(for java api) along with "Mastering Regular Expressions" (for regex concepts) to achieve that goal.

I am relatively new to Java. Although I have forgotten most of what I once knew about regular expressions, I remember their power quite well. So I was very excited when I saw this book. But here's my unfortunate conclusion: The editing of this book is so sloppy, the typos so frequent and often grossly misleading, that what should have been a pleasure turned out to be a chore. Having said that, I will certainly admit that I got enough information to begin playing around with RE in Java myself. But I doubt I will ever buy another book from this publisher.

This book starts very well with a practical, easy to follow, step-to-step introduction to regular expressions and their use with Java. This is to be appreciated since regexp are a complex subject that can easily be presented in an intimidating and obscure way. The problem is, this books never soars over this elementary level and in the end leaves you a bit disappointed even if you are totally new to the subject. The book is small and there are lots of white spaces, repetitions and not so useful discussions. I am under the unpleasant impression that the author and publisher realized the book lacked some meat and tried to cover up for it. It can still be a useful text if you want a really gentle intro to regexp usage in Java, but be warned that it lacks a serious and convincing treatment of regexp syntax. You will come out from this book with the ability to use regular expresisons only for really simple cases.
The subtitle should be "a light intro to java.util.regex engine" and not certainly "taming the java.util.regex engine".

The book consists of 250 pages of wide-spaced text, split into 5 chapters. The first chapter is an introduction to regular expressions, explaining basic regular expression syntax. The book's pace is relatively slow, which may suit some people but not others. It doesn't explain many of the "gotcha's" or differences between regex flavors. Clearly, this book is aimed at people who are relatively new to regular expressions, and only plan to use them with Java.

The second chapter is the most useful part of the book. It describes all the classes in the java.util.regex package, and nearly all of their methods. Most of the descriptions come with example Java source code illustrating its use. If you prefer to learn by reading Java source code rather than English, you'll appreciate these code snippets.

The third chapter explains advanced regular expression syntax, such as lazy and possessive quantifiers (called "qualifiers" in the book), and lookaround. Unfortunately, the quality of the book starts to go downhill from here. Minor errors such as using alternation (I|i)ce instead of a far more efficient character class [Ii]ce (page 104) or stating that \d represents a digit in the replacement text (page 107; \d only works in the regex, not in the replacement) could be attributed to sloppy editing. But the example that was intended to explain positive lookahead (page 130) is simply wrong. The regex (?=^255).* does exactly what ^255.* does. The crucial aspect of lookahead (it doesn't consume the text it matches) is completely irrelevant in this example.

The fourth chapter could have easily been omitted from the book. It talks more about object-oriented programming techniques than about regular expressions. Some of the advice is questionable. The author suggests storing regular expressions in external files, so they can be edited without recompiling the application. The problem with this advice is that the regular expressions will then sit in an external file without context, making them much harder to understand. It contradicts the books key selling point: most concepts are explained with regexes used in Java code. If another programmer has to maintain the code later, a better idea is to use a tool such as RegexBuddy to insert a detailed English description as a Java comment into the Java source code (RegexBuddy generates them on the Use tab).

The fifth chapter presents you with several more elaborate examples performing a number of real-world tasks with regular expressions in Java. While the examples are relatively simple, they do bring everything together nicely.

Should you buy this book? While it's definitely not perfect, I would recommend this book to Java developers who are experienced with Java, but have little or no experience with regular expressions. The book's description of the java.util.regex package is far more detailed than documentation included with the JDK. But to learn the ins and outs of the regular expression syntax itself, you'll need to complement this book with another resource, such as the tutorial at http://www.regular-expressions.info/

Who are these people giving 5 stars??

Clearly this book is short on material. It seems like the author tried to cover up that fact by putting extra wide margins shortening the pages. Also, there were typos all over the place. Not so good especially when regexp characters are concerned.

Here's a book that seems like a major rush job lacking in annotations and illustrations, yet plenty of white spaces and margins.

Prior to reviewing this book, my only experience with regular expressions was a few Perl scripts here or there. But Perl is a language of necessity and not my first choice when it comes to solving everyday problems; for that I use Java. Mehran was able to communicate the subtleties of regular expressions through the Java idiom. Ironically the lessons imparted in this text make me a more capable perl regex programmer - not that I would ever need to use Perl again for regular expressions. It is just that I feel you are getting two books in one. One on the regular expression syntax and the other on the Java regex API. Chapter by chapter the reader is shown another piece of the java-regex puzzle.
One more thing I like about this book: it is not too long! All of the examples have been carefully selected and many build on each other. This isn't one of your McBooks with 20 authors that inundate the reader with specs and trite, meaningless examples. It is a conscientious, well-organized treatise on learning regular expressions with the Java language.

I've been using Perl for years, so regex is nothing new to me; however, Java is so I figured this would be a good book for tapping something I already know, but presenting it in a language that I'm currently learning.

Overall I think the author did an admirable job. If based on purely his style and explanations, I would give the book 4 stars.

Unfortunately, there is more to a book than just the style and explanations. It must be accurate, and contain a minimal number of typos. By the time I was just 70 pages into this book I had already counted a dozen typos, a few that could throw off someone that is new to regex. Had the editor and technical reviewer/editor caught and cleaned up more of these typos, I would have rated it 4 stars. However, given the importance of a technical book being accurate, there were just too many errors to ignore. I'm sure later printings will correct these errors, but for now I'll have to stick with my 3 star rating.

Let me end by reiterating, this is a good book, just not perfect.

An old-fashioned regular expressions education starts with a Big Scary Table listing every metacharacter. Newbies often run away screaming when faced with this explosion of punctuation, never to return.

Help has arrived in this small, accessible book. Rather than starting out with the Big Scary Table, Habibi appeals to the reader's intuition, and demonstrates several simple applications of regular expressions before even mentioning the scary punctuation marks. By the time that fragments of the Big Scary Table do arrive, the reader has already seen fully worked examples and been taught some techniques for developing a regular expression for a given problem.

Instead of the Big Scary Table, this book uses small tables that make understanding complex regular expressions easy. There are tables which break up regular expressions into pieces,each row pairing one chunk of the expression with a clear explanation. Other tables show the steps involved in developing a complex regex. The honest explanation of each step makes these tables valuable real-life case studies.

After describing regular expressions themselves, the book presents a detailed and practical overview of the java.util.regex API. There's also a separate chapter on advanced features, and a final chapter showing fully-worked practical applications.

The only flaw in this book is a slight bias toward Java on Windows systems. A reader working the examples on Linux would have minor problems the author doesn't mention.

Overall, I'd strongly recommend this book to anyone new to java.util.regex, whether or not they have previous regular expressions experience.

Here the author aims at two main goals. First, provide a full, in depth coverage of the java.util.regex engine, then, offer a basic but complete introduction to RegExp. While he achieves the first goal in a very brilliant way, I still wouldn't suggest the book to somebody totally new to RegExp. Mr Habibi's informal writing style is worth a mention, since it nicely compensates the somewhat arcane nature of the topic. Also worth a special note are the examples, there are plenty of them, well selected and build on each other.

I agree with the reviewer who said the book never soars beyond the basics. And, aside from typos, I can't stand factual errors or bad advice such as using the more expensive alternation (i|I)ce instead of the more efficient character class [iI]ce in some examples. It is good that the author suggests the nio FileChannel for working with regex matching in file content--a correct, and current, approach. Overall, the beginning chapters are too wordy, the examples too simple and nuances not explained at all or well. It is only an adequate treatment, and far removed from the classic "Mastering Regular Expressions" by Friedl.