Rating: 
Summary: No Big Scary Tables
Review: 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.
Rating:
Summary: Excelent coverage of Java regular expressions.
Review: Before reading this book I was only aware of what regular expressions were used for. I had never used them in my own development. The syntax always looked so cryptic and intimidating that I never wanted to bother learning it. So, when I picked up this book at the store I never really expected to actually buy it. However, after flipping thru it for a short while I was convinced it was worth a try. I was not disapointed. The material is presented in such a clear and intutive manner that you find yourself learning without even trying. The examples are simple but apply to real world programming needs. After reading this book you will wonder how you ever got along without regular expressions. They are very powerful, and, now, easy to learn. Get this book!
Rating: 
Summary: Great coverage of java.util.regex
Review: 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.
Rating: 
Summary: Shame On the Editor
Review: 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.
Rating:
Summary: 3 1/2 stars
Review: I just wonder if the author remembered to communicate with his editor. Typos were present. For a topic that people are starved and craving for (Regular Expression in Java) I was shocked that the number of pages came out to only a teaspoon. Fortunately, there was some very useful regex information. Without this positive, I would have surely knocked it down to 1 star.
But Tsk..Tsk.. it had the potential of being a "must have" java book -- it just seemed like they rushed it to market. Hopefully, the next edition they can *BEEF* up the book size from its scrawny state.
Rating: 
Summary: Could have been 4 stars if not for so-so editing
Review: 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.
Rating:
Summary: This is not your father¿s procedural regex reference.
Review: I've had this book a bit over a day. Yes, I've read the entire book. It is that good. As I first approached it, I was afraid of this book. It's so easy to explain regular expressions in terribly dry and technical ways. Max, the author, doesn't do that. Don't fear your painful memories of the wordy, boring, and expensive text books read during university studies. This book won't bring them back. Max has again demonstrated his excellent, clear and concise writing skills with Java Regular Expressions. This book is not some boring reference or cookbook of regular expressions, excellent ones of which can be found for free on the internet. Instead, this book provides excellent explanations detailing techniques on how to understand and create regular expressions -object-oriented techniques at that! This is not your father's procedural regex reference. New to java.util.regex? Buy this book, not that other one.
Rating:
Summary: Practical regular expressions in Java
Review: Now I finally understand why Perl programmers are so fanatical. Mehran has excellent coverage of regular expressions in Java from basic to advanced topics such as Groups and Subgroups. As a consultant I have seen many clients attempt to validate and parse complex data to only create confusing and difficult to maintain applications. Mehran clearly shows practical techniques for solving this problem. In addition, I appreciate his appendix on common regular expressions. These examples will save me valuable time trying to develop regular expressions for myself.
Rating:
Summary: An extremely illuminating read
Review: 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.
Rating:
Summary: Not perfect, but useful for Java developers new to reg. expr
Review: 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/
| 
