List of 25 Plus Devices That Run On Java

Java don’t just run on your laptop and desktops. They run on a vast array of devices – more than you could possibly imagine. Today more than 3 billion devices run Java. Here are some of the common devices that run Java.

  1. Airplane Systems
  2. ATMs
  3. BlackBerry Smartphones
  4. Blu-ray Disc Players
  5. Cable Boxes
  6. Cell Phones
  7. Computers
  8. Credit Cards
  9. CT Scanners
  10. Government IDs
  11. Home Security Systems
  12. Kindle E-Readers
  13. Livescribe Smartpens
  14. Lottery Systems
  15. MRIs
  16. On-Board Computer Systems
  17. Parking Meters
  18. PlayStation Consoles
  19. Printers
  20. Public Transportation Passes
  21. Robots
  22. Routers
  23. Smart Grid Meters
  24. TVs
  25. Vehicle Diagnostic Systems
  26. VoIP Phones

Java Regular Expressions (Theory, Classes and Syntax)

In computing, regular expressions provide a concise and flexible means for identifying strings of text of interest, such as particular characters, words, or patterns of characters. A regular expression (often shortened to regex or regexp) is written in a formal language that can be interpreted by a regular expression processor, a program that either serves as a parser generator or examines text and identifies parts that match the provided specification.

Regular expressions are used by many text editors, utilities, and programming languages to search and manipulate text based on patterns. For example, Perl, Ruby and Tcl have a powerful regular expression engine built directly into their syntax. Several utilities provided by Unix distributions – including the editor ed and the filter grep – were the first to popularize the concept of regular expressions.

As an example of the syntax, the regular expression bex can be used to search for all instances of the string “ex” that occur after “word boundaries” (signified by the b). In laymen’s terms, bex will find the matching string “ex” in two possible locations,

  • At the beginning of words, and
  • Between two characters in a string, where one is a word character and the other is not a word character.

Thus, in the string “Texts for experts,” bex matches the “ex” in “experts” but not in “Texts” (because the “ex” occurs inside a word and not immediately after a word boundary).

Many modern computing systems provide wildcard characters in matching filenames from a file system. This is a core capability of many command-line shells and is also known as globbing. Wildcards differ from regular expressions in generally only expressing very limited forms of alternatives.

The java.util.regex package primarily consists of three classes: Pattern, Matcher, and PatternSyntaxException.

  • A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern, you must first invoke one of its public static compile methods, which will then return a Pattern object. These methods accept a regular expression as the first argument; the first few lessons of this trail will teach you the required syntax.
  • A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like the Pattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher method on a Pattern object.
  • A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.

x     The character x
\     The backslash character
n     The character with octal value 0n (0 <= n <= 7)
nn     The character with octal value 0nn (0 <= n <= 7)
mnn     The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7)
xhh     The character with hexadecimal value 0xhh
uhhhh     The character with hexadecimal value 0xhhhh
t     The tab character (‘u0009’)
n     The newline (line feed) character (‘u000A’)
r     The carriage-return character (‘u000D’)
f     The form-feed character (‘u000C’)
a     The alert (bell) character (‘u0007’)
e     The escape character (‘u001B’)
cx     The control character corresponding to x

Character classes
[abc]     a, b, or c (simple class)
[^abc]     Any character except a, b, or c (negation)
[a-zA-Z]     a through z or A through Z, inclusive (range)
[a-d[m-p]]     a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]]     d, e, or f (intersection)
[a-z&&[^bc]]     a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]]     a through z, and not m through p: [a-lq-z](subtraction)

Predefined character classes
.       Any character (may or may not match line terminators)
d     A digit: [0-9]
D     A non-digit: [^0-9]
s     A whitespace character: [ tnx0Bfr]
S     A non-whitespace character: [^s]
w     A word character: [a-zA-Z_0-9]
W     A non-word character: [^w]

POSIX character classes (US-ASCII only)
p{Lower}     A lower-case alphabetic character: [a-z]
p{Upper}     An upper-case alphabetic character:[A-Z]
p{ASCII}     All ASCII:[x00-x7F]
p{Alpha}     An alphabetic character:[p{Lower}p{Upper}]
p{Digit}     A decimal digit: [0-9]
p{Alnum}     An alphanumeric character:[p{Alpha}p{Digit}]
p{Punct}     Punctuation: One of !”#$%&'()*+,-./:;<=>?@[]^_`{|}~
p{Graph}     A visible character: [p{Alnum}p{Punct}]
p{Print}     A printable character: [p{Graph}]
p{Blank}     A space or a tab: [ t]
p{Cntrl}     A control character: [x00-x1Fx7F]
p{XDigit}     A hexadecimal digit: [0-9a-fA-F]
p{Space}     A whitespace character: [ tnx0Bfr]

Classes for Unicode blocks and categories
p{InGreek}     A character in the Greek block (simple block)
p{Lu}     An uppercase letter (simple category)
p{Sc}     A currency symbol
P{InGreek}     Any character except one in the Greek block (negation)
[p{L}&&[^p{Lu}]]      Any letter except an uppercase letter (subtraction)

Boundary matchers
^     The beginning of a line
$     The end of a line
b     A word boundary
B     A non-word boundary
A     The beginning of the input
G     The end of the previous match
Z     The end of the input but for the final terminator, if any
z     The end of the input

Greedy quantifiers
X?     X, once or not at all
X*     X, zero or more times
X+     X, one or more times
X{n}     X, exactly n times
X{n,}     X, at least n times
X{n,m}     X, at least n but not more than m times

Reluctant quantifiers
X??     X, once or not at all
X*?     X, zero or more times
X+?     X, one or more times
X{n}?     X, exactly n times
X{n,}?     X, at least n times
X{n,m}?     X, at least n but not more than m times

Possessive quantifiers
X?+     X, once or not at all
X*+     X, zero or more times
X++     X, one or more times
X{n}+     X, exactly n times
X{n,}+     X, at least n times
X{n,m}+     X, at least n but not more than m times

Logical operators
XY     X followed by Y
X|Y     Either X or Y
(X)     X, as a capturing group

Back references
n     Whatever the nth capturing group matched

    Nothing, but quotes the following character
Q     Nothing, but quotes all characters until E
E     Nothing, but ends quoting started by Q

Special constructs (non-capturing)
(?:X)     X, as a non-capturing group
(?idmsux-idmsux)      Nothing, but turns match flags on – off
(?idmsux-idmsux:X)       X, as a non-capturing group with the given flags on – off
(?=X)     X, via zero-width positive lookahead
(?!X)     X, via zero-width negative lookahead
(?<=X)     X, via zero-width positive lookbehind
(?<!X)     X, via zero-width negative lookbehind
(?>X)     X, as an independent, non-capturing group

This article is based on Wikipedia and Java Patterns page

Twenty Differences Between SOAP and REST Webservices

Even though comparing SOAP and REST Webservices will be like comparing apples and oranges because one is a protocol the other is an Architecture, I have made an attempt to expose twenty differences aimed at helping people make a decision on using one vs another. Also if you are new to SOAP Webservices, read my article here on using SOAP UI tool to demonstrate the use of SOAP Request Response.

Acronym Simple Object Access Protocol Representational State Transfer
Efficiency SOAP Uses XML which is not very efficient and may not be a good fit for some languages. SOAP can be slow and is definitely a heavyweight choice. REST is a lightweight protocol and is fast.
Format SOAP has one common and expressive format REST response can be of multiple types.
Security Security can be implemented using WS-Security, WS-Trust and WS-SecureConversation Security is implemented in terms of HTTP andSSL
Protocols SOAP can be used over other protocols not just HTTP such as HTTPS, SMTP, TCP, UDP, JMS. SOAP itself is a protocol. REST is completely based on HTTP and URI’s. REST is not a protocol in itself
Reliability End to end communication is reliable via WS-ReliableMessaging which does retries. The client does not need to retry. REST expects the client implementation to handle communication failures by retrying
Simplicity More complex due to client creation requirements. SOAP also has several parts to it such as envelope, Header, Body, Attachments and Fault. Raw HTTP calls via GET, POST, PUT, DELETE and is simpler invoke
Data The request and response are in XML format. The response object can be on several formats such as XML, JSON, RDF etc.
Capabilities Exposes  Operation and types of data. Exposes Resources
Describing interface WSDL No particular standard
Transactions Support ACID transactions via WS-AtomicTransaction No particular standard
Caching SOAP Reads cannot be cached REST reads can be cached.
Dependency SOAP cannot use REST RESTful architecture may use HTTP or SOAP as the underlying communication protocol.
Scalability Less scalable than REST More Scalable than SOAP
Network Works pretty well in distributed enterprise environments REST assumes direct point to point communication
Extensibility SOAP is extensible in the forms of WS* standards. There are no particular standards in extending REST.
Learning Curve SOAP has a steep learning curve REST has a smaller learning curve.
Interface SOAP  interfaces are not uniform REST provides a uniform interface.
Formal Contract SOAP provides a format contract between the provider and consumer There is no formal contract between the provider and consumer in a RESTful webservice.
State SOAP provides mechanism for stateful communication REST is a totally stateless operation.