Java 8实战指南：新特性和全面应用

Java8

5星 · 超过95%的资源需积分: 9 89 浏览量更新于2024-07-22 1 收藏 7.34MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

《Java.8.Recipes.2nd.Edition》是一本详尽的指南，涵盖了Java 8语言的关键特性与实用技术。这本书由Sun Microsystems在1995年推出，其设计初衷是改进旧语言的用户体验，特别是通过其简洁的对象模型和自动内存管理功能。Java以其面向对象、并发架构、卓越的安全性和可移植性迅速吸引了开发者，被誉为“一次编写，到处运行”的语言。书中分为多个章节，帮助读者逐步掌握Java 8的新特性和核心概念。第1章介绍了Java 8的入门知识，让初学者快速上手；第2章详细阐述了Java 8的新功能，包括lambda表达式和函数式编程的引入，这些特性极大地提高了代码的简洁性和可读性。在第3章中，读者可以学习到字符串操作的优化方法；第4章深入解析数字和日期处理的革新；第5章讲解了Java 8对面向对象编程的增强，包括接口的默认方法和静态方法等。第6章专门讲解lambda表达式，这是Java 8的一大亮点，用于简化回调和函数式编程。数据结构和集合操作在第7章被深入探讨，这对于实现高效的数据处理至关重要；第8章涉及输入输出，包括文件I/O和标准流操作；第9章介绍异常处理和日志记录，确保代码的健壮性；第10章则深入讲解并发编程，提升程序性能。对于国际化、货币编码、数据库操作等内容，第12章至第13章提供了实用的解决方案；第14章和第15章详细介绍了JavaFX，一个强大的图形用户界面库，用于创建丰富的桌面和移动应用；第16章和第17章分别讨论了JavaFX在Web应用和网络环境下的应用。第18章聚焦于Nashorn引擎和脚本编程，这使得动态脚本执行成为可能；第19章涉及电子邮件编程，方便与用户的交互；第20章讲解XML处理，以及第21章的网络编程都是现代软件开发中的关键技能。最后，第22章讨论了Java的安全性措施，确保代码在不同环境下的安全性。《Java.8.Recipes.2nd.Edition》是一本全面的参考书籍，无论是初学者还是经验丰富的Java开发者，都能从中找到提高技能、解决实际问题所需的知识点。随着Java语言的不断发展，这本书为开发者提供了丰富的实践案例和实战技巧，有助于他们紧跟Java 8的发展趋势。

资源详情

资源推荐

CHAPTER 1 N GETTING STARTED WITH JAVA 8

1-3. Compiling and Executing from the Command-line Interpreter

Problem

You aren’t able to install an IDE, or you don’t want to do so. You want to compile and execute your Java programs from

the command-line.

Solution

Compile your programs using the javac command. Then execute them via the java command.

Begin by making sure you have your JDK’s bin directory in your execution path. You might need to execute a

command such as one of the following.

Windows:

path %path%C:\Program Files\Java\jdk1.8.0\bin

OS X:

export PATH=/Library/Java/JavaVirtualMachines/jdk1.8.0.jdk/Contents/Home/bin

Then make sure your CLASSPATH environment variable includes the directory containing your Java code. The

following is an example of setting the environment variable under Windows:

set CLASSPATH=<<path-to-my-Java>>

Now change your current working directory to be the one corresponding to your project. Recipe 1-2 had you

create a project named Java8Recipes. Change to that project’s directory on a Windows system as follows:

cd <path-to-project>\Java8Recipes

Descend one level into the src subdirectory:

cd src

From here, you can issue javac commands to compile any classes in your project. Prepend the appropriate

package name as part of your path leading to each source file to be compiled. Be sure to include the .java extension

after your file name. For example, issue the following command to compile the HelloWorld class from Recipe 1-2.

Windows:

javac org\java8recipes\chapter01\recipe1_02\HelloWorld.java

OS X:

javac org/java8recipes/chapter01/recipe1_02/HelloWorld.java

You should now have a .class file in the same directory as your .java file. For example:

dir org\java8recipes\chapter01\recipe1_02 /B

HelloMessage.class

HelloWorld.class

HelloWorld.java

CHAPTER 1 N GETTING STARTED WITH JAVA 8

Compilation produces two files. One is for HelloMessage, and the other is for the class named HelloWorld

implementing the main() method.

Execute the main() method by issuing the java command to invoke the Java Virtual Machine (JVM). Pass the

fully-qualified class name as a parameter to the command. Qualify the class name by prepending the package name,

but this time use the same dot-notation as used in your source file. For example:

java org.java8recipes.chapter1.recipe1_02.HelloWorld

Do not specify .class at the end of the command. You are referencing HelloWorld now as a class name, and not

as a file name. You should see the same output as from Recipe 1-2.

Tip N One compiles source code. Source code is kept in files, so your operating-system’s file and directory-path

notation is appropriate. One executes a class. A class is an abstract concept in the language, so the language’s

dot-notation becomes appropriate. Keep this distinction in mind to help yourself remember when to use which notation.

How It Works

The first two solution steps are housekeeping steps. You must have the Java compiler and the virtual machine in your

execution path. It’s also necessary for any classes used by your program to be found somewhere along what is termed

the class path. One way to specify the class path is through the CLASSPATH environment variable.

The command java with no c at the end is for executing compiled code. Pass as a parameter the qualified

name of the class containing your main method. The JVM will interpret and execute the byte-code within that class,

beginning from the main method. The JVM will search along the class path for any additionally required classes such

as HelloMessage.

The compiler’s default behavior is to place each generated class file into the same directory as holds the

corresponding source file. You can override that behavior through the -d option. For example:

javac -d "<specify-different-location>" "<path-to-project>

\Java8Recipes\src\org\java8recipes\chapter1\recipe1_02\HelloWorld.java"

The -d option in this command specifies the same directory as NetBeans is using in our own environment as the

target for holding generated class files. The command also specifies the full path and file name of the source file. Thus,

the command can be executed with the same result regardless of the current working directory.

Tip N Configure your system so that your command-line environment has the execution path and class path set

correctly by default. The typical approach in Linux is to put appropriate commands into your .profile or .bash_profile

files. Under Windows you can specify environment variable defaults from the Control Panel applet named System, by

clicking on the Advanced system settings link, and then on the Environment Variables button.

There may be times when you need to specify a custom class path for a specific execution of the JVM. You can do

that through the -cp parameter, as follows:

java -cp ".;<path-to-project>\Java8Recipes\build\classes\org\java8recipes\chapter1\recipe1_02"

org.java8recipes.chapter1.recipe1_02.HelloWorld

CHAPTER 1 N GETTING STARTED WITH JAVA 8

This execution will search first in the current working directory (the leading dot in the class path), and then under

the specified package directory corresponding to where NetBeans would place the compiled classes.

Note N See Recipe 1-10 for more on configuring your class path.

1-4. Declaring Simple Variables

Problem

You want to create some variables and manipulate data within your program.

Solution

Java implements eight primitive data types. There is also special support for the String class type. Listing 1-2 shows

an example declaration of each. Draw from the example to declare the variables needed in your own application.

Listing 1-2. Declarations for Primitive and String Types

package org.java8recipes.chapter01.recipe1_04;

public class DeclarationsExample {

public static void main (String[] args) {

boolean BooleanVal = true; /* Default is false */

char charval = 'G'; /* Unicode UTF-16 */

charval = '\u0490'; /* Ukrainian letter Ghe(Ǳ) */

byte byteval; /* 8 bits, -127 to 127 */

short shortval; /* 16 bits, -32,768 to 32,768 */

int intval; /* 32 bits, -2147483648 to 2147483647 */

long longval; /* 64 bits, -(2^64) to 2^64 - 1 */

float floatval = 10.123456F; /* 32-bit IEEE 754 */

double doubleval = 10.12345678987654; /* 64-bit IEEE 754 */

String message = "Darken the corner where you are!";

message = message.replace("Darken", "Brighten");

}

Variables are subject to the concept of visibility. Those created in Listing 1-2 are visible from the main() method

after they have been created, and they are deallocated when the main() method ends. They have no “life” beyond the

main() method, and are not accessible from outside of main().

Variables created at the class level are a different story. Such variables can be termed as fields, as in fields of

the class. Use of a field can be restricted to objects of the class in which it is declared, to the package in which it is

declared, or it can be accessible from any class in any package. Listing 1-3 shows some of how to control visibility via

the private and public keywords.

CHAPTER 1 N GETTING STARTED WITH JAVA 8

System.out.println(sd1.oneValueForAllObjects);

System.out.println(sd2.oneValueForAllObjects);

}

Listing 1-4 produces the following output:

false

true

The field oneValueForAllObjects was set to true only for the class instance named sd1. Yet it is true for instance

sd2 also. This is because of the keyword static used in declaring that field. Static fields occur one time for all objects

of their class.

How It Works

Listing 1-2 illustrates the basic format of a variable declaration:

type variable;

It’s common to initialize variables when declaring them, so you’ll often see:

type variable = initialValue;

Field declarations can be preceded by modifiers. For example:

public static variable = initialValue;

private variable;

It’s common to put the visibility modifier — public or private — first, but you are free to list the modifiers in any

order you like. Be aware that there are additional modifiers that you will encounter and need to learn about as you get

deeper into the language.

The String type is special in Java. It’s really a class type, but syntactically you can treat it as a primitive type.

Java automatically creates a String object whenever you enclose a string of characters within double-quotes ("...").

You aren’t required to invoke a constructor, nor to specify the new keyword. Yet String is a class, and there are methods

in that class that are available to you. One such method is the replace() method shown at the end of Listing 1-2.

Strings are composed of characters. Java’s char type is a two-byte construct for storing a single character in

Unicode-s UTF-16 encoding. You can generate literals of the char type in two ways:

If a character is easy to type, then enclose it within single quotes (e.g.: u 'G').

Otherwise, specify the four-digit UTF-16 u code point value prefaced by \u (e.g.: '\u0490').

Some Unicode code points require five digits. These cannot be represented in a single char value. See Chapter 10

if you need more information on Unicode and internationalization.

Avoid using any of the primitive types for monetary values. Especially avoid either of the floating-point types for

that purpose. Refer instead to Chapter 4 and its recipe on using BigDecimal to calculate monetary amounts (Recipe 4-7).

BigDecimal is also useful anytime you need accurate, fixed-decimal arithmetic.

剩余626页未读，继续阅读

jerrylees2006

粉丝: 2
资源: 64

Java 8实战指南：新特性和全面应用

Apress.Spring.Recipes.A.Problem.Solution.Approach.2nd.Edition

Selenium.Testing.Tools.Cookbook.2nd.Edition.178439251

Apress.Spring.Recipes.A.Problem.Solution.Approach.2nd.Edition.Aug.2010

org.apache.curator.framework.recipes.cache.TreeCache:handleException| java.util.ConcurrentModificationException: null at java.util.HashMap$HashIterator.nextNode(HashMap.java:1445) at java.util.HashMap$EntryIterator.next(HashMap.java:1479) at java.util.HashMap$EntryIterator.next(HashMap.java:1477)

CentOS7.9安装gmssl时，make test后再../test/recipes/70-test_sslcbcpadding.t卡住不动

使用JAVA实现Curator注册的MySQL连接节点中存储的是实际的连接对象或连接状态，给出完整的注册过程实现代码，curator版本为curator-recipes5.0.0，Java版本为18，MySQL版本为8.0.21.给出完整实现代码以及使用示例。

使得Curator注册的MySQL连接节点中存储的是实际的连接对象或连接状态，curator版本为curator-recipes5.0.0，Java版本为18，MySQL版本为8.0.21.给出完整实现代码。

Caused by: java.lang.ClassNotFoundException: org.apache.curator.framework.CuratorFrameworkFactory

现有一些运行在特定端口上的服务器，每个服务器都连接着一个Mysql数据库，如何使用JAVA结合Curator实时监听每个服务器的实际状态，curator版本为curator-recipes5.0.0，Java版本为18，给出完整实现代码。

使用JAVA编写curator监听mysql的代码

copy_kernel() { echo "Using custom kernel '$1' ..." CUSTOM_KERNEL="$(basename $1)" cp -v "$1" "$SCRIPT_DIR/../recipes/.packages/$CUSTOM_KERNEL" CUSTOM_HEADER="linux-headers-${CUSTOM_KERNEL#linux-image-}" cp -v "$(dirname $1)/$CUSTOM_HEADER" "$SCRIPT_DIR/../recipes/.packages/$CUSTOM_HEADER" }

latex-workshop.latex.recipes

使用JAVA编写curator监听mysql的代码，curator的版本为5.0.0

springboot框架参考书

使用Apache Curator 结合 JUnit4 通过创建单元测试方法完成以下任务: 创建一个客户端, 连接到ZooKeeper服务器, 指定namespace为niit 为节点/foo/bar设置NodeCache缓存并添加监听,

能不能找出那种专著类型的参考文献至少三个外文的，跟Java，JavaEE有关的并且是2018年以后的

Bitbake still alive (no events for 600s). Active tasks: virtual:native:/home/wu/3568/yocto/build/../meta-clang/recipes-devtools/clang/clang_git.bb:do_compile /home/wu/3568/yocto/build/../meta-rockchip/recipes-kernel/linux/linux-rockchip_5.10.bb:do_compile

nr.h numerical recipes in c++

最新资源