The Java platform should provide a regular expression API
for use in text processing.

This API is being developed as part of the New I/O APIs
under JSR-051.

N/A

Must do.

  xxxxx@xxxxx   1997-11-08

We need to have an extended regular expression package that supports both Perl 5 syntax and (?basic?) Unicode characters.

  xxxxx@xxxxx   1999-08-20

IMHO http://www.oroinc.com/products/PerlTools.html
has a nice (concise and relatively feature rich) 
interface for regexps.
It'd be nice if the official Java one is as concise.

regular expressions and text-based object serialization/
deserialization in XML would beget distributed applications
with amazing interoperability. we need these in the core.

oroinc and Daniel Savarese did an excellent job with their regex package.  
There's been regex classes in the sun.misc package, so it's under works 
yet without documentation nor in the supported API.  
No real mention from Sun as to the possible inclusion of these packages in the
future, if ever.
Didn't see it in the JDK 1.2 documentation.   

I want to port a C based product to 100% Java but
it needs regex support. Speed is critical as well.
My servlet package will also require it for search
related functionality. Need this in the core.

Fast regular expressions as part of the Java language
would be most valuable. Many existing PERL
applications could migrate easily to Java - and benefit.

oroinc is no longer distributed
and breaks in 1.2.

http://www.oroinc.com/ is back up, and their web pages say it'll support 1.2
shortly.

Regular expressions in Java would be really
helpful. I just want to add my vote to that.

Check out gnu.regexp at http://www.cacas.org/java/gnu/regexp.
It supports multiple syntaxes including Perl 5, awk, emacs, etc.
It's free software, too (I'm the maintainer), and works with 1.0, 1.1 and 1.2.
I think Sun missed the boat on this one, but
that's just more incentive to use free software, right?

I *highly* recommend using gnu.regexp until Sun
catches on to this (1-2 years maybe). As Wes Biggs
said here already you can find it at
http://www.cacas.org/java/gnu/regexp. gnu.regexp
follows a good object model that allows it to mix
seamlessly with the rest of your Java code. After
using this I now believe that integrating regular
expressions into the lexical structure of Java
would be a mistake.

Best, I think, would be to have a set of
generic interfaces for regular expressions.  There
could be two separate parts -- one to compile an
expression into a standard format, and another
representing the engine that performs the search.
This way the grammar used can be separated from
the engine it gets executed on and programmers
can choose at runtime which type of engine would
be good for a particular search, or can let the 
system pick the best one.  This would be similar
to the way the Crypto API, where clients can 
request servers with as much detail as they care
to.

We need a java.regularexpr package that can
handle all the regular expression needs. That 
way we can avoid Perl and its somewhat weird
syntax.

Here's the best Java Regex package I've seen.  It 
permits full use of Perl syntax, and many other
useful classes/features:
    http://www.javaregex.com/

We absolutely need regular expressions as part of
the core JDK.  TCL, Perl, etc. support this, and
its useful for validating strings in XML as well.

As a Sun VAR to newspapers, lack of regular expression poses a great limitation
to the speed and ease of developing custom billing interfaces and general
system administration/database tools in Java.  Perl is currently far superior
for this application.

Both gnu and ORO packages are good as long as it comes to writing Perl-like
code, but in Java we could do it even better if there was something like
"OO text patern matching package". What I mean by that is something
that does not rely on Perl regexp syntax, but provides extensible framework of
pattern matching classes (TextPattern-TextPatternMatcher pairs) that can be
used "recursively". I have some preliminary ideas how this framework
should look like - you can to contact me for the details ...
Anyway, I will try to make this framework myself under LGPL, and if somebody
wants to participate/take over, he is welcome.
As for the Perl regexp syntax - there can be a couple of utility classes that
compile regexp strings into a TextPattern tree.

Sun built a good lightweight regular expression package that is bundled with
the Java Web Server. It is now also used by their NetBeans IDE (see
regexp.jar). Why don't they provide it as a standard package in JDK 1.3 (or as
an extension) ?
For more information about Java & Regular expression, have a look to an
excellent site from the Belgium User Group, at www.bejug.org.
Phil.

You could always adapt the code from Tcl8.2 which supports
both Unicode and extended syntax.  And it isn't encumbered
by an awkward license, unlike other languages I could mention...

The ORO, Inc. package mentioned earlier is an excellent implementation of
regular expressions. It is up-to-date and conforms to Java 1.2.2. If it wasn't
there, a lot of projects might not have been completed. It would be a real
bonus if Java had a standard regular expressions package so developers didn't
have to go rooting around to find a third-party implementation of such a basic
and necessary function.

Sun said, this is a "must do".
That was 08.11.1997!

I could do it... make a regexp package that is.

When the world moves to XML, the need for regular 
expression packages will dissipate.  They're actually being 
very forward thinking in their decision (up to this date) 
not to include one.

Think of it as a way to weak programmers from backwards 
thinking ways (regexp) to new, better methods (xml).

I disagree with the xml comment. I find that regular 
expressions are very useful when working with legacy 
systems. While newer technologies certainly can be 
implemented from scratch, sometimes this isn't practical. 
Regular expressions are arguably the best tool a programmer 
has when parsing text, and until I see something better, I 
won't be switching. That being said, I'd like to have a RE 
package included with the standard Java API.

I disagree with the XML comment, too.
XML is good for handling structured data - but think of
working with texts written in a spoken language (english,
german, japanese...). Example: XML gives you nothing if you 
want to search for particular data, especially if you want 
to do more than searching for an exact string match. In 
other words, XML has simply nothing to do which such jobs.

There are already java solutions for working with regexp, 
but I think they should be implemented in the JDK's.

Those who advocate the use of XML instead of regexps miss
the point.  All too often, you need to handle data that
already exists, and mapping it all to XML won't work too
well if the data is messy (as is all too common!)  XML won't
save the world or wash whiter.  All it does is provide a way
of passing structures across a text-based heterogeneous
communication link.  REs provide for complex searching
capabilities - like searching a text for all occurences of a
set of words - that XML simply doesn't address.

Also, how are you supposed to convert that data /to/ XML in
the first place?  REs would make doing this sort of thing
far easier, and it makes little sense to exclude Java from
this application area!  :^)

Absolutely agree with this RFE.  I regularly write scads of 
PERL using the OO extensions (See Conway, Damien, "Object 
Oriented Perl" http://www.manning.com/Conway/index.html) 
and would love to replace it with Java (where appropriate), 
but the showstopper is Java's poor text-handling 
capabilities -- especially regexes.  The ORO packaages are 
nice but I agree with the poster who pointed out that it 
doesn't really have the nice OO flavor of the Java core.

Oh yeah, I forgot to mention -- Perl 5.6 (due RSN) adds 
support for Unicode.

http://jakarta.apache.org/regexp/

hey all, the Apache Jakarta Project recently released a 
100% Java regexp package done by Jonathan Locke under a 
BSD/Apache license. So, forget all those issues you had 
with GPL and/or commercial licenses and come and get it! If 
you don't like it, help us improve it! :-)

http://jakarta.apache.org/regexp/

-jon stevens

Something like http://jakarta.apache.org/regexp would do very nicely. Check it out. Use it. All it needs is 
the official imprint of Sun (or Javasoft, or whatever standards committee is officially in charge these days) 
and distribution with the standard JDK. DO THIS ONE!!

The Python implementation of regular expressions, is a 
better match than PERL's.

Python is more clear and verbose, just like Java.

Even C++ standard lib has regex support. I'm quite 
surprised this was missed in the core Java API's.

Interestinly, people within Sun have build a regexp package
-- sunlabs.brazil.util.regexp.*

So why was this bug closed? Was there an annoucement I missed? A new 
Regular Expressions package? If anyone knows, please send me an email.

So the bug is closed with a "non-public release".
How about telling us when the public release will be available?

I agree that this should go into the core libraries asap. 
Why not release it to the general public??

Apache also now run the oroinc regexp product.

Let's hope Sun talk to Apache and don't 
get into a "Not Invented Here" thing.