Java Runtime Environment | Unggah.web.id V2

Java software allows you to run applications called ?applets? that are written in the Java programming language. These applets allow you to play online games, chat with people around the world, calculate your mortgage interest, and view images in 3D. Corporations also use applets for intranet applications and e-business solutions.

Java technology was created as a computer programming tool in a small, secret effort called ?the Green Project? at Sun Microsystems in 1991.

As it turns out, the Internet was ready for Java technology, and just in time for its initial public introduction in 1995, the team was able to announce that the Netscape Navigator Internet browser would incorporate Java technology.

Now, nearing its twelfth year, the Java platform has attracted over 5 million software developers, worldwide use in every major industry segment, and a presence in a wide range of devices, computers, and networks of any programming technology.

Today, you can find Java technology in networks and devices that range from the Internet and scientific supercomputers to laptops and cell phones, from Wall Street market simulators to home game players and credit cards ? just about everywhere.

The J2SE Java Runtime Environment (JRE) allows end-users to run Java applications.

Here are some key features:

• Write software on one platform and run it on practically any other platform
• Create programs to run within a web browser and web services
• Develop server-side applications for online forums, stores, polls, HTML forms processing, and more
• Combine Java technology-based applications or services to create highly customized applications or services
• Write powerful and efficient applications for mobile phones, remote processors, low-cost consumer products, and practically any device with a digital heartbeat

What?s New In This Release:

Swing Enhancements:

• JLayer Class.?The JLayer class is a flexible and powerful decorator for Swing components. It enables you to draw on components and respond to component events without modifying the underlying component directly. For more information, read How to Decorate Components with JLayer in the Java Tutorial.
• Nimbus Look & Feel.?The Nimbus Look & Feel (L&F) has moved from com.sun.java.swing to a standard API namespace, javax.swing; see the javax.swing.plaf.nimbus package for more information. Although it is not the default L&F, you can easily use it. Consult the Nimbus Look and Feel section in the Java Tutorial for more information and examples of three simple methods for using Nimbus in your applications.
• Heavyweight and Lightweight Components.?Historically, mixing heavyweight (AWT) and lightweight (Swing) components in the same container has been problematic. However, mixing heavyweight and lightweight components is easy to accomplish in Java SE 7. The Mixing Heavyweight and Lightweight Components article shows you how.
• Shaped and Translucent Windows.?The Java SE 7 release supports windows with transparency and non-rectangular shapes. See How to Create Translucent and Shaped Windows, part of the Java Tutorial.
• Hue-Saturation-Luminance (HSL) Color Selection in JColorChooser Class.?An HSV tab has been added to the JColorChooser class, which allows users to select colors using the Hue-Saturation-Luminance (HSL) color model.

Enhancements in Java I/O:

• The java.nio.file package and its related package, java.nio.file.attribute, provide comprehensive support for file I/O and for accessing the file system. A zip file system provider is also available in JDK 7. The following resources provide more information.
  - File I/O (featuring NIO 2.0) in the Java Tutorials; NIO stands for non-blocking I/O
  - Developing a Custom File System Provider
  - Zip File System Provider
  - The directory /sample/nio/chatserver/ contains samples that demonstrate the new APIs contained
  in the java.nio.file package
  - The directory /demo/nio/zipfs/ contains samples that demonstrate the NIO.2 NFS (Network File
  System) file system

Networking Enhancements:

• The URLClassLoader.close method has been added. This method effectively eliminates the problem of how to support updated implementations of the classes and resources loaded from a particular codebase, and in particular from JAR files.
• The Sockets Direct Protocol (SDP) provides access to high performance network connections

Security Enhancements:

• Elliptic Curve Cryptography (ECC).?A new native provider has been added to the Java SE 7 release that provides several ECC-based algorithms (ECDSA/ECDH).
• CertPath Algorithm Disabling.?Weak cryptographic algorithms can now be disabled. For example, the MD2 digest algorithm is no longer considered secure. The Java SE 7 release provides a mechanism for denying the use of specific algorithms in certification path processing and TLS handshaking.

JSSE (SSL/TLS):

• TLS 1.1.?The SunJSSE provider now supports TLS 1.1 as described in RFC 4346. The most important update is protection against cipher block chaining (CBC) attacks.
• TLS 1.2.?The SunJSSE provider now supports TLS 1.2 as described in RFC 5246. Among other things, it specifies different internal hashing algorithms, adds new cipher suites, and contains improved flexibility, particularly for negotiation of cryptographic algorithms.
• Weak cipher suites deprecated.?Per RFC 4346, RFC 5246, and RFC 5469, some cipher suites have been made obsolete and should not be used. These obsolete suites are all disabled by default in SunJSSE. For details, consult the cipher suite lists in the documentation about the SunJSSE provider.
• Connection-sensitive trust management.?Both trust managers and key managers now have the ability to examine parameters of the TLS connection, specifically the SSLSession under construction, during the handshake. For example, a trust manager might restrict the types of certificates used based on the list of valid signature algorithms.
• Endpoint verification.?An endpoint identification algorithm can be specified to verify that a remote computer?s host address matches its supplied certificate. Although this type of verification was previously performed for the HTTPS protocol (see HttpsURLConnection and HostnameVerifier), such verification can now be optionally performed at the TLS level.
• TLS renegotiation.?Java SE supports RFC 5746, which fixes a renegotiation issue in the TLS protocol.
• SSLv2Hello disabled by default.?In Java SE 7, SSLv2Hello is removed from the default enabled protocol list.
• Algorithm disabling.?Weak cryptographic algorithms can now be disabled, as previously described.
• Server Name Indication (SNI) for JSSE client.?The Java SE 7 release supports the Server Name Indication (SNI) extension in the JSSE client. SNI is described in RFC 4366. This enables TLS clients to connect to virtual servers.
• Tighter checking of EncryptedPreMasterSecret version numbers.?Java SE 7 tightens version number checking during TLS 1.1 and TLS 1.2 handshaking

Concurrency Utilities Enhancements:

• The fork/join framework, which is based on the ForkJoinPool class, is an implementation of the Executor interface. It is designed to efficiently run a large number of tasks using a pool of worker threads. A work-stealing technique is used to keep all the worker threads busy, to take full advantage of multiple processors. See Fork/Join in The Java Tutorials. The directory /sample/forkjoin/ contains samples that demonstrate the fork/join framework.
• The ThreadLocalRandom class eliminates contention among threads using pseudo-random numbers;
• The Phaser class is a new synchronization barrier, similar to CyclicBarrier.

Client JRE Capabilities:

• The window of a dragged applet can be decorated with a default or custom title; see Requesting and Customizing Applet Decoration in Draggable Applets.

The following enhancements have been made to the syntax of JNLP files:

• The os attribute in the information and resources elements can now contain specific versions of Windows, such as Windows Vista or Windows 7.
• Applications can use the install attribute in the shortcut element to specify their their desire to be installed. Installed applications are not removed when the Java Web Start cache is cleared, but can be explicitly removed using the Java Control Panel.
• Java Web Start applications can be deployed without specifying the codebase attribute; see Deploying Without Codebase
• A JNLP file can be embedded into an HTML page; see Embedding JNLP File in Applet Tag.
• You can check the status variable of the applet while it is loading to determine if the applet is ready to handle requests from JavaScript code;
• You now have control of the window decoration style and title of an applet launched from a shortcut or dragged out of the browser;

Java 2D Enhancements:

• XRender-Based Rendering Pipeline.?A new XRender-based Java 2D rendering pipeline is supported for modern X11-based desktops, offering improved graphics performance. The pipeline is disabled by default, but may be enabled by setting the command line property -Dsun.java2d.xrender=true. Older X11 configurations may not be able to support XRender. The verbose form, -Dsun.java2d.xrender=True, can be used to enable a message to stdout indicating whether the pipeline was actually enabled.
• This flag is listed in the System Properties for Java 2D Technology page.
• Support for OpenType/CFF Fonts.?The JDK now enumerates and displays installed OpenType/CFF fonts through methods such as GraphicsEnvironment.getAvailableFontFamilyNames; these fonts are also recognized by the Font.createFont method. See Selecting a Font in The Java Tutorials.
• TextLayout Support for Tibetan Script.?The TextLayout class supports Tibetan script.

Java Programming Language:

• Binary Literals ? In Java SE 7, the integral types (byte, short, int, and long) can also be expressed using the binary number system. To specify a binary literal, add the prefix 0b or 0B to the number.
• Underscores in Numeric Literals ? Any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This feature enables you, for example, to separate groups of digits in numeric literals, which can improve the readability of your code.
• Strings in switch Statements ? You can use the String class in the expression of a switch statement.
• Type Inference for Generic Instance Creation ? You can replace the type arguments required to invoke the constructor of a generic class with an empty set of type parameters () as long as the compiler can infer the type arguments from the context. This pair of angle brackets is informally called the diamond.
• Improved Compiler Warnings and Errors When Using Non-Reifiable Formal Parameters with Varargs Methods ? The Java SE 7 complier generates a warning at the declaration site of a varargs method or constructor with a non-reifiable varargs formal parameter. Java SE 7 introduces the compiler option -Xlint:varargs and the annotations @SafeVarargs and @SuppressWarnings({?unchecked?, ?varargs?}) to supress these warnings.
• The try-with-resources Statement ? The try-with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements the new java.lang.AutoCloseable interface or the java.io.Closeable interface can be used as a resource. The classes java.io.InputStream, OutputStream, Reader, Writer, java.sql.Connection, Statement, and ResultSet have been retrofitted to implement the AutoCloseable interface and can all be used as resources in a try-with-resources statement.
• Catching Multiple Exception Types and Rethrowing Exceptions with Improved Type Checking ? A single catch block can handle more than one type of exception. In addition, the compiler performs more precise analysis of rethrown exceptions than earlier releases of Java SE. This enables you to specify more specific exception types in the throws clause of a method declaration.

Java Virtual Machine Technology:

The JDK provides one or more implementations of the Java virtual machine (VM):

• On platforms typically used for client applications, the JDK comes with a VM implementation called the Java HotSpot Client VM (client VM). The client VM is tuned for reducing start-up time and memory footprint. It can be invoked by using the -client command-line option when launching an application.
• On all platforms, the JDK comes with an implementation of the Java virtual machine called the Java HotSpot Server VM (server VM). The server VM is designed for maximum program execution speed. It can be invoked by using the -server command-line option when launching an application.

Some features of Java HotSpot technology, common to both VM implementations, are the following:

• Adaptive compiler ? Applications are launched using a standard interpreter, but the code is then analyzed as it runs to detect performance bottlenecks, or ?hot spots?. The Java HotSpot VMs compile those performance-critical portions of the code for a boost in performance, while avoiding unnecessary compilation of seldom-used code (most of the program). The Java HotSpot VMs also use the adaptive compiler to decide, on the fly, how best to optimize compiled code with techniques such as in-lining. The runtime analysis performed by the compiler allows it to eliminate guesswork in determining which optimizations will yield the largest performance benefit.
• Rapid memory allocation and garbage collection ? Java HotSpot technology provides for rapid memory allocation for objects, and it offers a choice of fast, efficient, state-of-the-art garbage collectors.
• Thread synchronization ? The Java programming language allows for use of multiple, concurrent paths of program execution (called ?threads?). Java HotSpot technology provides a thread-handling capability that is designed to scale readily for use in large, shared-memory multiprocessor servers.

Tools:

• Standard HotSpot VM Options ? The command-line options supported by the Java HotSpot VMs are described on the reference pages for the Java application launcher.
• Non-standard Java HotSpot VM Options ? Non-standard options recognized by the current implementations of the VMs, but not necessarily by future or non-Sun implementations, are described on this web page.

Enhancements:

• Java Virtual Machine Support for Non-Java Languages: Java SE 7 introduces a new JVM instruction that simplifies the implementation of dynamically typed programming languages on the JVM.
• Garbage-First Collector is a server-style garbage collector that replaces the Concurrent Mark-Sweep Collector (CMS).
• Java HotSpot Virtual Machine Performance Enhancements

JDBC:

• The Java Database Connectivity (JDBC) API provides universal data access from the Java programming language. Using the JDBC API, you can access virtually any data source, from relational databases to spreadsheets and flat files. JDBC technology also provides a common base on which tools and alternate interfaces can be built.

The JDBC API is comprised of two packages:

• java.sql
• javax.sql
• You automatically get both packages when you download the Java Platform Standard Edition (Java SE) 7.
• To use the JDBC API with a particular database management system, you need a JDBC technology-based driver to mediate between JDBC technology and the database. Depending on various factors, a driver might be written purely in the Java programming language or in a mixture of the Java programming language and Java Native Interface (JNI) native methods. To obtain a JDBC driver for a particular database management system, see JDBC Data Access API.

JDBC 4.1 introduces the following features:

• The ability to use a try-with-resources statement to automatically close resources of type Connection, ResultSet, and Statement
• RowSet 1.1: The introduction of the RowSetFactory interface and the RowSetProvider class, which enable you to create all types of row sets supported by your JDBC driver.

Source: http://www.unggah.web.id/299/utility/java-runtime-environment.html

study study sf giants elton john clint eastwood modern warfare 3 hawthorne