Free jdk 5.0 software for windows

BEA JRockit JDK 5.0 R25.2 offers users a professional program that provides tools, utilities, and a complete runtime environment for developing and running Java applications.

Major Features:

1. Includes the JRockit Java Virtual Machine (JVM), the first JVM developed uniquely for large-scale enterprise applications and optimized for Intel architectures.
2. Provides out-of-the-box application performance and scalability through progressive optimization features that enable the JVM to automatically deliver the best possible application performance without requiring manual configuration or tuning.
3. Unique manageability features give developers the real-time visibility and control to ensure top application performance & health while delivering industrial-strength system stability & reliability under heavy user and transaction loads.

Enhancements: Version 5.0 R25.2 may include unspecified updates, enhancements or bug fixes.

A Java API for reading and writing XSPF ("Spiff") open XML playlists. Jpiff is a Java API for reading and writing XSPF ("Spiff") open XML playlists. Tired of Winamp M3U playlists? So are we!
Using XSPF in Java applications is very simple. JSpiff provides two different mechanisms for reading and writing XSPF playlists. A JAXP implementation which is simple and only requires JDK1.5 or higher to use. A JAXB implementation which has some Dependencies but is a newer API from Sun for binding XML to Java
System requirements:
- JDK 1.5 or higher

Very simple IDE for writing applications and appletsin Java language. Must work with JDK 1.2.x. No help

A useful compiler which reads a Java expression, block, or source file, and generates Java bytecode. Janino is not intended to be a development tool, but an embedded compiler for run-time compilation purposes, such as expression evaluators or "server pages" engines like JSP.
The major design goal was to keep the compiler small and simple, while partially sacrificing completeness. Nobody likes the idea of carrying around huge libraries for simple applications. See Parser for the list of implemented and missing language features.
This software is a useful compiler which reads a Java expression, block, or source file, and generates Java bytecode that is loaded and executed directly.
When do you need an efficient expression evaluator?
Say you build an e-commerce system, which computes the shipping cost for the items that the user put into his/her shopping cart. Because you dont know the merchants shipping cost model at implementation time, you could implement a set of shipping cost models that come to mind (flat charge, by weight, by number of items, ...) and select one of those at run-time.
In practice, you will most certainly find that the shipping cost models you implemented will rarely match what the merchant wants, so you must add custom models, which are merchant-specific. If the merchants model changes later, you must change your code, re-compile and re-distribute your software.
Because this is so unflexible, the shipping cost expression should be specified at run-time, not at compile-time. This implies that the expression must be scanned, parsed and evaluated at run-time, which is why you need an expression evaluator.
A simple expression evaluator would parse an expression and create a "syntax tree". The expression "a + b * c", for example, would compile into a "Sum" object whos first operand is parameter "a" and whos second operand is a "Product" object whos operands are parameters "b" and "c".
Such a syntax tree can evaluated relatively quickly. However, the run-time performance is about a factor of 100 worse than that of native Java code.
Main features:
- package declaration, import declaration
- class declaration, interface declaration
- Inheritance (extends and implements)
- Static member type declaration
- Inner classes (member classes, local classes, anonymous classes)
- Class initializer, Instance initializer
- Field declaration, Method declaration
- Local variable declaration
- Class variable initializer, Instance variable initializer
- Block statement ({ ... })
- if ... else statement
- for statement
- while statement
- do ... while statement
- try ... catch ... finally statement
- throw statement
- return statement
- break statement
- continue statement
- switch statement
- synchronized statement
- All primitive types (boolean, char, byte, short, int, long, float, double)
- Assignment operator =
- Assignment operators +=, -=, *=, /=, &=, |=, ^=, %=, =, >>>=
- Conditional operators ?...:, &&, ||
- Boolean logical operators &, ^, |
- Integer bitwise operators &, ^, |
- Numeric operators *, /, %, +, -, , >>>
- String concatenation operator +
- Operators ++ and --
- Type comparison operator instanceof
- Unary operators +, -, ~, !
- Parenthesized expression
- Field access (like System.out)
- Superclass member access (super.meth();, super.field = x;
- this (reference to current instance)
- Alternate constructor invocation (like this(a, b, c))
- Superclass constructor invocation (like super(a, b, c))
- Method invocation (like System.out.println("Hello")) (partially)
- Class instance creation (like new Foo())
- Primitive array creation(like new int[10][5][])
- Class or interface array creation(like new Foo[10][5][])
- Array access (like args[0]) (currently read-only)
- Local variable access
- Integer, floating-point, boolean, character, string literal
- null literal
- Unary numeric conversion, binary numeric conversion, widening numeric conversion, narrowing numeric conversion
- Widening reference conversion, narrowing reference conversion
- Cast
- Assignment conversion
- String conversion (for string concatenation)
- Constant expression
- Block scope, method scope, class scope, global scope
- throws clause
- Array initializer (like String[] a = { "x", "y", "z" })
- Primitive class literals, e.g. "int.class"
- Non-primitive class literals, e.g. "String.class"
- References between uncompiled compilation units
- Line number tables a la "-g:lines"
- Source file information a la "-g:source"
- Handling of @deprecated doc comment tag
- Accessibility checking (PUBLIC, PROTECTED, PRIVATE)
- Static imports for fields (single an on-demand; fields, types and methods
System requirements:
- JDK 1.3.1 or above
Version restrictions:
- Local variable information information for debugging is not yet implemented (i.e. "-g:vars" is ignored)
- assert (a JDK 1.4 language feature) is not yet implemented
- The upcoming JDK 5.0 language features are not yet implemented except for static imports
- Checking of "definite assignment" (JLS2 16) is not executed
- Methods that compile to more than 32 KB of bytecode cannot be compiled (other JavaTM compilers support up to 64 KB per method)

It is an Integrated Development Environment (IDE) for Java and other languages. It is written in Java.

Major Features:

1. Will run JavaFXTM files.
2. Runs in JDK 1.6 or higher.
3. Develop Java applets and applications in any directory.
4. Syntax highlighting with customizable styles!
5. Supports all JDK 1.6.x commands including idlj !
6. JDK tool options are easily modified.
7. Powerful wizards make repetitive tasks simple.
8. Flexible text insertion capability.
9. Trap all output from the JDK tools in a text window.
10. All java tools are available along with their options.
11. Handy File List windows make handling multiple files a simple click!
12. "Search in File" option in the edit menu allows you to perform 'search and replace' operations in 1 to 1000's of files automatically. (Did you ever try to repackage that 500 class project?).
13. "Search in File" operation performs advanced 'template' matching of replacement text with found text. Automatically put characters in the correct case for simple and correct replacement of Class names and instance names!
14. "Search in File" and then automatically open the file containing the found text and high light the line with the found text.
15. Options allow you to use the tools you want.
16. Easy configuration to allow selected use of different javac, java and other tools.
17. Choose any syntax style as the default start-up style .
18. "class" view makes for easy viewing of JDK class information.
19. "class" view allows easy insertion of method and field calls and overloads into source code.
20. jar up any of your files and load them into class view for easy browsing!
21. Projects allow easy access to multi-packaged java files.
22. Easy management of complex tool options (e.g. keytool) in the Alpha Frame - Options tab.
23. Setup Window for easy first time, new user setup!
24. User preferences are retained.
25. Batch file processor for disk operations.
26. Debug interface! Set breakpoints in your source code. Highlight source code by simply double-clicking the line with the line number in the debug window!
27. Launch multiple server sockets and and attach to server sockets.
28. Php syntax style added
29. Uses JDK 1.1.8 or later.
30. Develop Applications and Applets for JDK 1.0, 1.1.X and 2.X or for any java target.
31. Customizable tool bar.
32. Power and flexibility in a development environment!
33. Up to 100 levels of undo/redo in the Edit Window.
34. JMaker is celebrating it 4th birthday!

Requirements:

• Recommended: Windows Vista, XP, 2000, 2003 and 2008 Server
• Vista
• Windows 2000
• Windows XP
• Windows Server 2003
• Windows Server 2008
• Intel and 100% compatible processors are supported. A Pentium 166MHz or faster processor with at least 64MB of physical RAM is recommended. You will also need a minimum of 98MB of free disk space.