- ?
Java多线程:由浅入深看synchronized的底层实现原理
天晴
展开
前言
前两篇文章,我们聊了聊线程/进程的概念,接着简单串了一下同步的方式方法。今天我们就单拎出来synchronized,好好捋一捋它的前世今生。
正文
小A:咱们前几天铺垫了这么多内容,今天是不是要好好的深挖一下原理的内容了?
MDove:没错,接下来。我会从常见的synchronized加锁方式入手;引出Java对象在内存的布局,以及锁的存放位置;然后看一看锁在C++中的简单实现思路;最后咱们从字节码中,看一下JVM如果识别synchronized。内容不是很难,不会涉及到特别多深奥的内容,大部分是平铺直叙的介绍,很适合阅读呦~
小A:快点开始吧,我等不及啦。
浅聊synchronized的使用
MDove:说起synchronized的底层实现原来,咱们先看看synchronized的俩种加锁方式:
1、某个对象实例内
此作用域内的synchronized锁 ,可以防止多个线程同时访问这个对象的synchronized方法
并且一个对象有多个synchronized方法,只要一个线程访问了其中的一个synchronized方法,其它线程不能同时访问这个对象中任何一个synchronized方法。
此外,不同对象实例的synchronized方法是不相干预的。也就是说,其它线程可以同时访问此类下的另一个对象实例中的synchronized方法;
2、某个类
此作用域下,可以防止多个线程同时访问这个类中的synchronized方法。也就是说此种修饰,可以对此类的所有对象实例起作用。
MDove:注意一点,synchronized关键字是不能继承的,也就是说,基类的方法synchronized fun(){} 在继承类中并不自动是synchronized fun(){},而是变成了fun(){}。继承时,需要显式的指定它的某个方法为synchronized方法。有机会你可以自己写个demo试一下。
常见错误
MDove:你来看一看下面这个demo,有没有什么问题?
小A:没觉得有问题呐?这不就是第一种加锁的方式,锁实例对象么?
MDove:既然你都知道是锁实例对象,那你没看出来问题么?虽然我们使用synchronized修饰了add()。但是却new了两个不同的实例对象,这也就意味着存在着两个不同的实例对象锁,因此t1和t2都会进入各自的对象锁,也就是说t1和t2线程使用的是不同的锁,因此线程安全是无法保证的。
小A:对对对,没错。那解决这种问题,是不是需要用第二种加锁的方式,锁住这个类?
MDove:没错,解决这种困境的的方式是将synchronized作用于静态的add方法,这样的话,对象锁就当前类,因为类对象只有一个,因此无论new多少个实例对象都是安全的:
小A:那是不是这样改写就可以了?
MDove:没错就是这样,很简单。接下来让我们看一些深入的内容,锁的实现。
synchronized锁的底层实现
MDove:我们都知道,对象被创建在堆中。并且对象在内存中的存储布局方式可以分为3块区域:对象头、实例数据、对齐填充。其中对象头,便是我们今天的主角。
关于实例数据、对齐填充的作用,各位小伙伴可以参考《深入理解Java虚拟机》。
MDove:对于对象头来说,主要是包括俩部分信息:
1、自身运行时的数据,比如:锁状态标志、线程持有的锁…等等。(此部分内容被称之为Mark Word)
今天我们只聊:指向重量级锁的指针
2、另一部分是类型指针:JVM通过这个指针来确定这个对象是哪个类的实例。
MDove:今天我们主要聊的是对象头,第一部分中重量级锁的内容。
MDove:先让我们从宏观的角度看一看synchronized锁的实现原理。
synchronized锁的宏观实现
MDove:synchronized的对象锁,其指针指向的是一个monitor对象(由C++实现)的起始地址。每个对象实例都会有一个 monitor。其中monitor可以与对象一起创建、销毁;亦或者当线程试图获取对象锁时自动生成。
monitor是由ObjectMonitor实现(ObjectMonitor.hpp文件,C++实现的),对于我们来说主要关注的是如下代码:
MDove:我们可以看到这里定义了_WaitSet 和 _EntryList俩个队列,其中_WaitSet 用来保存每个等待锁的线程对象。
小A:那_EntryList呢?
MDove:别着急,让我们先看一下_owner,它指向持有ObjectMonitor对象的线程。当多个线程同时访问一段同步代码时,会先存放到 _EntryList 集合中,接下来当线程获取到对象的monitor时,就会把_owner变量设置为当前线程。同时count变量+1。如果线程调用wait() 方法,就会释放当前持有的monitor,那么_owner变量就会被置为null,同时_count减1,并且该线程进入 WaitSet集合中,等待下一次被唤醒。
MDove:当然,若当前线程顺利执行完方法,也将释放monitor,重走一遍刚才的内容,也就是_owner变量就会被置为null,同时_count减1,并且该线程进入 WaitSet集合中,等待下一次被唤醒。
因为这个锁对象存放在对象本身,也就是为什么Java中任意对象可以作为锁的原因。
synchronized代码块的底层实现
MDove:咱们先写一个简单的demo,然后看一下它们的字节码:
MDove:根据虚拟机规范要求,在执行monitorenter指令时,首先要尝试获取对象锁,也就是上文我们提到了monitor对象。如果这个对象没有被锁定,或者当前线程已经拥有了这个对象的锁,那么就把锁的计数器(_count)加1。当然与之对应执行monitorexit指令时,锁的计数器(_count)也会减1。
MDove:如果当前线程获取锁失败,那么就会被阻塞住,进入_WaitSet 中,等待锁被释放为止。
小A:等等,我看到字节码中,有俩个monitorexit指令,这是为什么呢?
MDove:是这样的,编译器需要确保方法中调用过的每条monitorenter指令都要执行对应的monitorexit 指令。为了保证在方法异常时,monitorenter和monitorexit指令也能正常配对执行,编译器会自动产生一个异常处理器,它的目的就是用来执行 异常的monitorexit指令。而字节码中多出的monitorexit指令,就是异常结束时,被执行用来释放monitor的。
小A:我们刚才看的是同步代码块的原理,那么直接修饰在方法上呢?也是通过这个俩个指令吗?
MDove:你别说,还真不是:
MDove:可以看到:字节码中并没有monitorenter指令和monitorexit指令,取得代之的是ACC_SYNCHRONIZED标识,JVM通过ACC_SYNCHRONIZED标识,就可以知道这是一个需要同步的方法,进而执行上述同步的过程,也就是_count加1,这些过程。
小A:哦,原来是这样。一个是用了指令,一个是用的标识呀~对了,我听说synchronized的性能特别低是这样么?
MDove:这句话不全对,JDK1.5后对synchronized进行了大刀阔斧的优化,这其中涉及到偏向锁、轻量级锁、自旋锁、锁消除等手段。时候也不早了,这些内容今天就不展开了。有机会我们下次再学习吧~
剧终
- ?
Java开发技术SOA架构面向服务及微服务解析
伊人
展开
引言
面向服务的体系结构,是一个组件模型,它将应用程序的不同功能单元(称为服务)通过这些服务之间定义良好的接口和契约联系起来。接口是采用中立的方式进行定义的,它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种这样的系统中的服务可以以一种统一和通用的方式进行交互。
一丶SOA定义
它是一个组件模型,它将应用程序的不同功能单元(称为服务)通过这些服务之间定义良好的接口和契约联系起来。接口是采用中立的方式进行定义的,它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种这样的系统中的服务可以以一种统一和通用的方式进行交互。
这种具有中立的接口定义(没有强制绑定到特定的实现上)的特征称为服务之间的松耦合。松耦合系统的好处有两点,一点是它的灵活性,另一点是,当组成整个应用程序的每个服务的内部结构和实现逐渐地发生改变时,它能够继续存在。而另一方面,紧耦合意味着应用程序的不同组件之间的接口与其功能和结构是紧密相连的,因而当需要对部分或整个应用程序进行某种形式的更改时,它们就显得非常脆弱。
对松耦合的系统的需要来源于业务应用程序需要根据业务的需要变得更加灵活,以适应不断变化的环境,比如经常改变的政策、业务级别、业务重点、合作伙伴关系、行业地位以及其他与业务有关的因素,这些因素甚至会影响业务的性质。我们称能够灵活地适应环境变化的业务为按需(On demand)业务,在按需业务中,一旦需要,就可以对完成或执行任务的方式进行必要的更改。
SOA是传统的面向对象架构模型的替代模型,面向对象的模型是紧耦合的,已经存在二十多年了。虽然基于 SOA 的系统并不排除使用面向对象的设计来构建单个服务,但是其整体设计却是面向服务的。由于它考虑到了系统内的对象,所以虽然 SOA 是基于对象的,但是作为一个整体,它却不是面向对象的。不同之处在于接口本身。SOA 系统原型的一个典型例子是通用对象请求代理体系结构(Common Object Request Broker Architecture,CORBA),它已经出现很长时间了,其定义的概念与 SOA 相似。
然而,现在的 SOA 已经有所不同了,因为它依赖于一些更新的进展,这些进展是以可扩展标记语言(eXtensible Markup Language,XML)为基础的。通过使用基于 XML 的语言(称为 Web 服务描述语言(Web Services Definition Language,WSDL))来描述接口,服务已经转到更动态且更灵活的接口系统中,非以前 CORBA 中的接口描述语言(Interface Definition Language,IDL)可比了。
Web 服务并不是实现 SOA 的惟一方式。前面刚讲的 CORBA 是另一种方式,这样就有了面向消息的中间件(Message-Oriented Middleware)系统。但是为了建立体系结构模型,您所需要的并不只是服务描述。您需要定义整个应用程序如何在服务之间执行其工作流。您尤其需要找到业务的操作和业务中所使用的软件的操作之间的转换点。因此,SOA 应该能够将业务的商业流程与它们的技术流程联系起来,并且映射这两者之间的关系。例如,给供应商付款的操作是商业流程,而更新您的零件数据库,以包括进新供应的货物却是技术流程。因而,工作流还可以在 SOA 的设计中扮演重要的角色。
此外,动态业务的工作流不仅可以包括部门之间的操作,甚至还可以包括与不为您控制的外部合作伙伴进行的操作。因此,为了提高效率,您需要定义应该如何得知服务之间的关系的策略,这种策略常常采用服务级协定和操作策略的形式。
最后,所有这些都必须处于一个信任和可靠的环境之中,以同预期的一样根据约定的条款来执行流程。因此,安全、信任和可靠的消息传递应该在任何 SOA 中都起着重要的作用。
二丶SOA用途
对 SOA 的需要来源于需要使业务 IT 系统变得更加灵活,以适应业务中的改变。通过允许强定义的关系和依然灵活的特定实现,IT 系统既可以利用现有系统的功能,又可以准备在以后做一些改变来满足它们之间交互的需要。
改变和 SOA 系统适应改变的能力是最重要的部分。对于开发人员来说,这样的改变无论是在他们工作的范围之内还是在他们工作的范围之外都有可能发生,这取决于是否有改变需要知道接口是如何定义的以及它们相互之间如何进行交互。与开发人员不同的是,架构师的作用就是引起对 SOA 模型大的改变。这种分工,就是让开发人员集中精力于创建作为服务定义的功能单元,而让架构师和建模人员集中精力于如何将这些单元适当地组织在一起。
三丶SOA技术
SOA 本身是应该如何将软件组织在一起的抽象概念。它依赖于用 XML 和 Web 服务实现并以软件的形式存在的更加具体的观念和技术。此外,它还需要安全性、策略管理、可靠消息传递以及会计系统的支持,从而有效地工作。您还可以通过分布式事务处理和分布式软件状态管理来进一步地改善它。
SOA 服务和 Web 服务之间的区别在于设计。SOA 概念并没有确切地定义服务具体如何交互,而仅仅定义了服务如何相互理解以及如何交互。其中的区别也就是定义如何执行流程的战略与如何执行流程的战术之间的区别。而另一方面,Web 服务在需要交互的服务之间如何传递消息有具体的指导原则;从战术上实现 SOA 模型是通过 HTTP 传递的 SOAP 消息中最常见的 SOA 模型。因而,从本质上讲,Web 服务是实现 SOA 的具体方式之一。
尽管我们觉得 Web 服务是实现 SOA 的最好方式,但是 SOA 并不局限于 Web 服务。其他使用 WSDL 直接实现服务接口并且通过 XML 消息进行通信的协议也可以包括在 SOA 之中。正如在别处指出的,CORBA 和 IBM 的 MQ 系统通过使用能够处理 WSDL 的新特征也可以参与到 SOA 中来。如果两个服务需要交换数据,那么它们还会需要使用相同的消息传递协议,但是数据接口允许相同的信息交换。
既为了建立所有这些信息的适当控制,又为了应用安全性、策略、可靠性以及会计方面的要求,在 SOA 体系结构的框架中加入了一个新的软件对象。这个对象就是企业服务总线(Enterprise Service Bus,ESB),它使用许多可能的消息传递协议来负责适当的控制、流甚至还可能是服务之间所有消息的传输。虽然 ESB 并不是绝对必需的,但它却是在 SOA 中正确管理您的业务流程至关重要的组件。ESB 本身可以是单个引擎,甚至还可以是由许多同级和下级 ESB 组成的分布式系统,这些 ESB 一起工作,以保持 SOA 系统的运行。在概念上,它是从早期比如消息队列和分布式事务计算这些计算机科学概念所建立的存储转发机制发展而来的。
SOA 可以与许多其他技术结合在一起使用,然而,组件的封装和聚合在其中扮演着重要的角色。如前所述,SOA 可以是一个简单对象、复杂对象、对象的集合、包含许多对象的流程、包含其他流程的流程,甚至还可以是输出单一结果的应用程序的整体集合。在服务之外,它可以看作是单个实体,但是在其自身中,它可以具有任何级别的复杂性(如果必要的话)。出于性能方面的考虑,大多数 SOA 服务并没有下降到单一对象的粒度,并且更适合于大中型组件。
除了可能离不开 XML 和 WSDL 之外,SOA 并不是特定于语言的。可以用任何编程语言来实现服务,只要这种编程语言可以生成服务并且可以与 WSDL 结合在一起使用就可以了。SOAP 本身并不是绝对需要的,但它是通用的消息传递系统。因此,可以使用几乎任何一种编程语言和支持 WSDL 的平台来实现 SOA 中的成员服务。
SOA 和 Web 服务是独立于编程语言的,但 Java 是主要的开发语言之一。可以使用定义良好的 Java 接口以及各种协议丰富的 Java 实现为正在构建这个模型的开发人员提供了优势。Java 在此担当了开发每个服务的功能、管理数据对象和与其他在逻辑上封装在服务内的对象进行交互的角色。
SOA 与 Web 的另一个重要的关系是自主计算和网格计算的概念。自主计算的概念应用于管理分布式服务体系结构的范围,具体来说,就是帮助维护策略和服务级协议以及 SOA 系统的总稳定性。
另外,网格计算可以以两个级别与 SOA 系统一起使用。网格是分布式计算的一种形式,它利用分布式特性和服务之间的交互来为 SOA 应用程序提供计算支持。在这种情况下,网格起到了框架的作用,其中实现了一些或所有单独的服务。因此,SOA 应用程序可以是网格服务的消费者。
在另一方面,网格本身也可以构建在 SOA 之上。在这种情况下,每个操作系统服务都是构成整个 SOA 应用程序的成员,而 SOA 应用程序就是网格本身。因此,单独的网格组件既可以使用 Web 服务进行通信,又可以以 SOA 的方式进行交互。总而言之,网格系统可以是 SOA 本身,也可以提供服务来在其上构建应用程序级 SOA 模型。
四丶SOA最佳实践
SOA需要通过松耦合 碎片化系统使得SOA实现能够更快速更简单更可扩展。
一些领域的客户和业界正经历SOA扩展性的困难:
1丶生成一个系统规范所需的时间和资源
2丶导致错误高频率发生的系统规格定义含糊
3丶全面实施导致对系统复杂性的可见都降低。
4丶无法保证在执行过程中对最初规定保持一致性
5丶需求评估的变更先于代码
大部分系统规范的生成是有问题的。目前,业务分析员使用MS-Word文档和 标准的图形包进行业务解释性说明, 随着业务流程变得更加复杂,使用这些工具实现信息交换变得更加困难。
随着复杂性的增加,说明书开始变得模糊,从而导致执行错误。
收集业务需求
第一阶段是文档要求。为了确保需求有效地可以验证实现, 需要以一种机器可处理的方式进行描述。为了实现这一目标,需求被分离两大类:
1.说明系统之间交互的业务消息
2.有关消息处理可选路径的细节场景。
举例来说,一个场景可能代表一个客户交易完成后,一个成功的信用 检查:而可选替代路径失败的交易导致信用检查失败。这些 可选路径的选择,或“方案”的记录需要使用的序列图描述。
过程设计
下一步是创建或重用消息的类型定义来建立过程设计,以及定义在场景中的上下文。如果说消息是基于XML的,消息的类型可以是使用XML架构定义。 为了描述的动态行为的定义,类型可以表示使用编排描述语言,例如CDL。
“choreography”从一个中立的或“全球”的视角描述了在一组服务之间的相互作用 。这不能与业务流程的概念混淆,它提供了一个只有从服务角度描述特定的行为。
一旦类型定义已经被定义,信息是用来验证方案。这确保了 类型定义正确表示源的要求。这是一个重要的步骤,因为类型定义 随后将被用来实现系统。这提供了描述的场景和代表业务需求的需求之间的连接验证
信息采用XML,验证解析器可以用来确保消息实例符合XML schema。使用场景中的消息通过模拟执行路径可以验证编排描述。
五丶微服务(Microservice)架构快速指南
1. 什么是软件架构?
软件架构是一个包含各种组织的系统组织,这些组件包括 Web服务器, 应用服务器, 数据库,存储, 通讯层), 它们彼此或和环境存在关系。
2.什么是微服务架构?
微服务是指开发一个单个 小型的但有业务功能的服务,每个服务都有自己的处理和轻量通讯机制,可以部署在单个或多个服务器上。
微服务也指一种种松耦合的、有一定的有界上下文的面向服务架构。也就是说,如果每个服务都要同时修改,那么它们就不是微服务,因为它们紧耦合在一起;如果你需要掌握一个服务太多的上下文场景使用条件,那么它就是一个有上下文边界的服务,这个定义来自DDD领域驱动设计。
3. 微服务优点是什么?
每个微服务都很小,这样能聚焦一个指定的业务功能或业务需求。
微服务能够被小团队单独开发,这个小团队是2到5人的开发人员组成。
微服务是松耦合的,是有功能意义的服务,无论是在开发阶段或部署阶段都是独立的。
微服务能使用不同的语言开发。
微服务允许容易且灵活的方式集成自动部署,通过持续集成工具,如Jenkins, Hudson, bamboo 。
一个团队的新成员能够更快投入生产。
微服务易于被一个开发人员理解,修改和维护,这样小团队能够更关注自己的工作成果。
无需通过合作才能体现价值。
微服务允许你利用融合最新技术。
微服务只是业务逻辑的代码,不会和HTML,CSS 或其他界面组件混合。微服务能够即时被要求扩展。
微服务能部署中低端配置的服务器上。
易于和第三方集成。
每个微服务都有自己的存储能力,可以有自己的数据库。也可以有统一数据库。
4. 微服务架构的缺点是什么?
微服务架构可能带来过多的操作。
需要DevOps技巧 (http://en.wikipedia.org/wiki/DevOps).
可能双倍的努力。
分布式系统可能复杂难以管理。
因为分布部署跟踪问题难。
当服务数量增加,管理复杂性增加。
5. 微服务适合哪种情况?
当你需要支持桌面 web 移动 智能电视 可穿戴时都是可以的,甚至将来你可能不知道但需要支持的某种环境。
6. 哪个公司或产品使用微服务架构?
大部分大型网ç...
- ?
Win10+Java1.7环境配置
冰箱
展开
原创2017-11-16那山的狐狸在路上的知更鸟在路上的知更鸟
安装包:
jdk-7u79-windows-x64-20151024
打开安装目录
双击运行程序,出现安装程序
点击下一步,更改安装路径(目的是为了保证安装目录的规范,尽量不要出现汉字和空格)
更改为E盘(安装程序尽量不要安装在C盘,因为D盘不能使用,所以安装在E盘,但习惯将程序安装在D盘比较好管理)
其中jdk1.7.0_79不要改动,因为之后可能会用到其它java版本,这样方便记录。
点击下一步
出现如下提示:
参考上一步,安装到相同目录下
安装成功
安装完成后,Java还不能使用,需要配置环境变量。
变量名:JAVA_HOME
变量值:E:\Java\jdk1.7.0_79
变量名:CLASSPATH
变量值:.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
变量名:Path
变量值:;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
点击“此电脑”图标,鼠标右键,弹出快捷菜单,选择“属性”菜单项,弹出“系统”管理器界面。
点击“高级属性”,选择“环境变量”按钮。
出现“环境变量”对话框
点击下面“系统变量”的新建,弹出“新建环境变量”对话框
分别将之前环境变量的内容添加如下:
其中Path环境变量已经存在,不需要新建,双击编辑
在“编辑环境变量”中点击新建,加入PATH值。
完成配置。
检验配置:
执行快捷键:Win+R,弹出DOS命令窗口,输入cmd,点击确认。
进入DOS界面。
执行语句,出现如下效果即可:
1、安装过程中为什么有两个安装,一个是jdk,一个是jre?
jdk是开发环境(Java Development Kit),jre是运行环境(Java Runtime Environment),如果我们只写java程序就可以只安装jdk,但是我不运行就不知道自己写的程序是否正确,所以需要jre运行环境。我们开发人员要同时安装jdk和jre,程序的使用者也就是客户可以只安装jre。
2、安装完成后,为什么会有两个jre?
Jdk是java的开发工具包,里面包含了各种类库和工具。也包括了另外一个Jre.那么为什么要包括另外一个Jre呢?
因为两个JRE负责的范围不同。
当用户只需要执行java 的程序时,那么E:\Java\jdk1.7.079\jre下的jre就满足。当用户是java开发人员时,需要java开发环境,那么在开发时,系统就会优先去找“ java 、javac ”这些命令本身的目录或者他们的父目录的 jre; 这样开发时一般运行的是 jdk 下的 jre;
运行外部程序时,一般运行的是E:\Java\jre ,实现了分工,不同的 jre 负责各自范围的内容;
jdk下的lib包括java开发使用的jar包,jre下的lib是运行java程序的jar包;
3、为什么JRE不需要配置环境变量?
jdk的bin下有各种java程序需要用到的命令,与jre的bin目录最明显的区别就是jdk下才有javac,这一点很好理解,因为 jre只是一个运行环境,与开发无关。
那么有人会问了?我明明没有设置jre/bin目录到环境变量中啊?
试想一下如果java为了提供给大多数人使用,他们是不需要jdk做开发的,只需要jre能让java程序跑起来就可以了,那么每个客户还需要手动去设置环境变量多麻烦啊?所以安装jre的时候安装程序自动帮你把jre的java.exe添加到了系统变量中,验证的方法很简单,大家看到了系统环境变量的PATH中包括“%SystemRoot%\system32;%SystemRoot%;”这样的配置,那么再去Windows/system32下面去看看,发现了什么?有一个java.exe。
4、为什么要设置三个环境变量JAVA_HOME、PATH、CLASSPATH?。
想在命令行当中编译或者运行Java程序,就必须使用到JDK所提供的java和javac这两个命令,所以我们要把java.exe和javac.exe所在的目录加入到path这个环境变量当中,这样操作系统就可以顺利的执行这两个命令了.
只配置JAVA_HOME环境变量,不配置PATH和CLASSPATH,直接执行Javac,系统找不到。
执行“java Test”这样的命令时,java虚拟机会寻找一个名为Test.class的文件,然后由类装载器装载这个类,那么问题就是类装载器究竟要到哪个目录里去寻找Test.class这个文件呢?这个时候classpath就起作用了,classpath值的设置方式和path类似,都是一系列的目录, java虚拟机就是到这些目录当中去寻找所需要的class文件, 比如说在我的E:\src目录当中有一个Test.java文件,编译过后生成了Test.calss文件。这个时候我们想执行这个文件,就要执行“java Test”命令,类装载器会从classpath所指定的目录当中去寻找Test.class这个文件,如果在classpath所指定的第一个目录当中没有找到,就到第二个目录去找,直到找到为止,如果在所有的目录当中都没有找到,就会报出一个错误。在一般的教科书上,都会让学生把classpath的值设置为“.”,这是因为“.”代表的是当前目录,什么叫当前目录呢?
当打开命令行时,在“>”之前的目录就是当前目录,也就是说在这个目录下执行“java Test”命令,java虚拟机的类装载器就会在E:\src下寻找Test.class文件。
- ?
猿学-JavaSE语法基础完整版,学java必看!
可若
展开
1 、Java开发前奏 1.1 Java语言发展简史 Sun Microsystems于1995年推出 1991 年Sun公司的James Gosling等人开始开发名称为Oak 的语言。希望用于控制嵌入在有线电视交换盒、PDA等的微处理器 Internet使Java成为网上最流行的编程语言,Java对Internet的影响也意义深远 1994年将Oak语言更名为Java Java 既安全、可移植,又可跨平台,而且人们发现它能够解决Internet 上的大型应用问题 1996年获得$100000000的投资 1998年提出JDK1.2,更名为Java2 之后推出JDK1.3,JDK1.4 2005年更名为JDK 5.0,是对以前版本最大改进 2007年JDK6.0 2009年4月Oracle以74亿美元收购SUN 计划于2011年夏天发布Java7正式版 1.2 Java体系 Java SE:Java Platform,Standard Edition 标准版:各应用平台的基础,桌面开发和低端商务应用的解决方案。
Java EE:Java Platform,Enterprise Edition 企业版:以企业为环境而开发应用程序的解决方案
JavaME:JavaPlatform,MicroEdition
微型版:致力于消费产品和嵌入式设备的最佳解决方案
Java可以做什么?
开发桌面应用程序 银行软件、商场结算软件 开发面向Internet的web应用程序 门户网站(工商银行)、网上商城、阿里巴巴、电子商务网站 提供各行业的解决方案 金融、电信、电力… 嵌入式开发 移动电话、可视电话、数字机顶盒和汽车导航系统 1.3 Java的特性 一种纯面向对象的编程语言。 一种与平台无关(跨平台)的语言。(它提供了在不同平台下运行的解释环境) 一种健壮的语言,吸收了C/C++语言的优点。 有较高的安全性。(自动回收垃圾,强制类型检查,取消指针) 1.4 Java跨平台原理
1.4.1 Java技术的两种核心机制 Java虚拟机(Java Virtual Machine) JVM 垃圾回收器(Garbage Collection) GC
1.4.2Java虚拟机(JVM)
JVM可以理解成一个可运行Java字节码的虚拟计算机系统 它有一个解释器组件,可以实现Java字节码和计算机操作系统之间的通信 对于不同的运行平台,有不同 的JVM。
JVM屏蔽了底层运行平台的差别,实现了“一次编译,随处运行”。 1.4.3 垃圾回收器(GC) 不再使用的内存空间应当进行回收-垃圾回收。 在C/C++等语言中,由程序员负责回收无用内存。 Java语言消除了程序员回收无用内存空间的责任: JVM提供了一种系统线程跟踪存储空间的分配情况。并在JVM的空闲时,检查并释放那些可以被释放的存储空间。 垃圾回收器在Java程序运行过程中自动启用,程序员无法精确控制和干预。
1.4.4 JavaSE的组成概念图
1.4.5JDK
JDK(JavaDevelopmentKits)–Java开发工具集
JRE(JavaRunTimeEnvironment)Java运行时环境
JVM
JavaAPI(应用程序编程接口)
Java编译器(javac.exe)、Java运行时解释器(java.exe)、Java文档化化工具(javadoc.exe)及其它工具及资源
JRE的三项主要功能:
加载代码:由类加载器(classloader)完成;
校验代码:由字节码校验器(bytecodeverifier)完成;
执行代码:由运行时解释器(runtimeinterpreter)完成。
1.5 搭建Java开发环境 下载和安装最新版本的JDK 下载地址: http://java.sun/javase/downloads/index.jsp
JDK安装目录介绍: bin目录:存放java的编译器,解释器等工具(可执行文件); demo目录:存放演示程序 include目录:存放用于本地方法的文件 jre目录:存放Java运行环境文件 lib目录:存放Java的类库文件 sample目录:一些范例程序 src.zip文件:JDK提供的类的源代码
Sun目录下有个JavaDB 目录: JDK6附带的一个轻量级的数据库,名字叫做Derby
Java的垃圾回收机制(GC) 不再使用的内存空间应回收—-垃圾收集。 在C/C++ 等语言中,由程序员负责回收无用内存。 Java语言解除了程序员回收无用内存空间的责任。它提供一种系统级线程跟踪存储空间的分配情况。并在JVM的空闲时,检查并释放那些可被释放的存储器空间。 垃圾收集在Java程序运行过程中自动进行,程序员无法精确控制和干预。 Java开发工具集JDK—-Java Development Kits Java编译器 Java运行时解释器 Java应用程序编程接口 Java文档化化工具 其它工具及资源 环境变量 Path —- 用于指定操作系统的可执行指令的路径 CLASSPATH —-用于指定Java的类文件存放路径。
1.5.1设置环境变量
path:用于指定操作系统的可执行指令的路径
classpath:Java虚拟机在运行某个类时会按classpath指定的目录顺序去查找这个类
注:JDK5.0默认就会到当前工作目录以及JDK的lib目录中查找
验证
javac:Java源文件的编译工具。
java:Java字节码解释程序。
1.5.2 什么是程序 程序一词来自生活,通常指完成某些事务的一种既定方式和过程 在日常生活中,可以将程序看成对一系列动作的执行过程的描述
例如: 去银行办理业务 去商品购物 等等..
计算机中的程序 为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令(即命令)的集合
Java程序的类型 命今行程序 GUI程序 Applet程序 J2EE web 应用程序
1.5.3 Java程序开发的三个步骤
1.6第一个Java程序
示例
注释:java程序有三种注释方式
编码规范
常见错误
API文档
java代码的位置 java是严格区分大小写的 java是一种自由格式的语言 代码分为结构定义语句和功能执行语句 功能执行语句的最后必须用分号结束
开发Java应用的基本步骤: – 编写源代码,生成 .java文件。编辑Java文件,用文本编辑工具即可; – 编译源代码,生成 .class文件; javac HelloWorld.java或java *.java – 运行该程序 java HelloWorld
publicclassHelloWorld
{
//Java应用程序入口方法
publicstaticvoidmain(Stringargs[])
{
//向控制台打印一条信息
System.out.println(“HelloWorld!”);
}
}
将上述程序内容保存为一个扩展名为.java的文件,文件命名为HelloWorld.java。
进入到java源文件保存的目录,通过下列指令来编译这个java文件:
–javacHelloWorld.java
在.java文件编译生成的.class文件所在的路径下,执行如下命令:
–javaHelloWorld,然后回车
常见错误
编译时:HelloWorld.java:1:classhelloworldispublic,shouldbedeclaredinafilenamedhelloworld.java
–publicclasshelloworld
–^
–1error
运行时:Exceptioninthread“main”java.lang.NoSuchMethodError:main
运行时:Exceptioninthread“main”java.lang.NoClassDefFoundError:helloWorld(wrongname:HelloWorld)
注意 一个源文件中至多只能有一个public的class声明 源文件名必须和它中定义的public的类名相同 main方法是Java应用程序的入口方法
1.7 常见Java开发工具 编辑器 记事本 EditPlus UltraEdit (UE) 集成开发环境 JBuilder Eclipse (http://eclipse.org/) NetBeans (http://netbeans.org/) IDEA 反编译工具 Cavaj.Java.Decompiler 1.8 软件开发活动 可行性分析 需求分析-对待开发的软件提出的需求进行分析并给出详细的定义并对其加以确切的描述,然后编写出软件需求说明书。 系统设计-设计人员把已确定的各项需求转换成相应的体系结构。 系统实现-把软件设计转换成计算机可以接受的程序代码,并在实际环境中得以实现。 软机测试-保证软件质量的重要手段,贯穿于软件生命周期的各个阶段。 运行和维护-软件在运行的过程中由于多方面的原因对其进行的修改。 1.9 面向对象的程序设计 程序设计简史 – 过程式程序设计 – 结构化程序设计 – 面向对象程序设计 对象 Everything is Object:万事万物皆对象。 面向对象的编程(OOP)思想力图使对计算机语言中对事物的的描述与现实世界中该事物的本来面目尽可能的一致。 Class/Object:类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述,是抽象的、概念上的定义;对象是实际存在的该类事物的每个个体,因而也称实例(instance)。 编程语言发展简史 机器语言-直接由计算机的指令组成,指令、数据、地址都以“0”和“1”的符合串组成;可以被计算机直接执行. 汇编语言-用容易理解和记忆的符合表示指令、数据以及寄存器等,抽象层次很低,程序圆需要考虑大量的机器细节。 高级语言-屏蔽了机器细节,提高了语言的抽象层次接近于人的自然语言,60年代出现的结构化编程语言提出了结构化数据和语句,数据和过程抽象等概念。 面向对象的语言-与已往的各种语言的根本不同是,它的设计出发点就是为了更能直接的描述问题域中客观存在的事物。
类 类(Class)是用来描述一个对象(Object): – 类描述了每个对象应包括的数据 – 类描述了每个对象的行为特征 – 类是用于描述同一类形的对象的一个抽象的概念,类中定义了这一类对象所因具有的静态和动态属性。 – 类可以看成一类对象的模板,对象可以看成该类的一个具体实例。
类包括两方面的内容: – 属性:用来描述对象的数据元素称为对象的属性(也称为数据/状态) – 方法:对对象的属性进行的操作称为对象的方法(也称为行为/操作)
类和对象的关系 对象的创建和使用 在Java中,使用new 关键字来创建一个对象(实例化一个类),new后面跟上一个构造器 – 每个类都至少有一个构造器,如果没有定义构造器,则系统将自动提供一个默认的不带任何参数的构造器,如果类没有定义构造器,可以用这个默认的构造起来生成一个对象 使用“.”操作符来访问对象的成员,包括对象方法和对象属性 – .
1.10 练习 1. 完成HelloWorld示例 2. 将自己的个人信息打印到控制台上输出。 3. 编写一个去银行取钱的多个命令组成一个程序到控制台上输出。 4. 结合\n换行,\t制表位空几格,println()也是回车换行,打印出自己的名字和心!如图!
2 、Java编程基础 2.1 变量 2.1.1 变量 变量是什么?为什么为用变量?
变量就是系统为程序分配的一块内存单元,用来存储各种类型的数据。根据所存储的数据类型的不同,有各种不同类型的变量。变量名代表这块内存中的数据 。
变量分类: 按所属的数据类型划分: 基本数据类型变量 引用数据类型变量 按被声明的位置划分: 局部变量:方法或语句块内部定义的变量 成员变量:方法外部、类的内部定义的变量
特别注意:类的外面不能有变量的声明
2.1.2 数据类型
布尔型—-boolean1字节true/false
字符型—-char2字节
2.1.3 二进制 计算机中的数据都以二进制数字保存。 二进制:逢二进一。即只有0、1两个值。 如:十进制的10在计算机内保存为二进制的1010
计算机中信息的存储单位 位(Bit):表示一个二进制数码0或1,是计算机存储处理信息的最基本的单位。 字节(Byte):一个字节由8个位组成。它表示作为一个完整处理单位的8个二进制数码。
补码: 事实上,计算机内的二进制数值是以补码形式表示的。 补码: 一个正数的补码和其原码的形式是相同的。 负数的补码是:将该数的绝对值的二进制形式,按位取反再加1。 由此可知,二进制补码数值的最高位(最左位)是符号位:该位为0,表示数值为正数;该位为1,表示数值为负数。 10 = 00000000 00000000 00000000 00001010 -10 = 11111111 11111111 11111111 11110110
主要原因:使用补码,可以将符号位和其它位统一处理;同时,减法也可按加法来处理。另外,两个用补码表示的数相加时,如果最高位(符号位)有进位,则进位被舍弃。
二进制和十进制之间的互换 二进制数转换成十进制数 按权相加:把二进制数首先写成加权系数展开式,然后按十进制加法规则求和。 例:原码1011.01 = 1×23+0×22+1×21+1×20+0×2-1+1×2-2 = 8+0+2+1+0+0.25 =11.25 十进制转换成二进制 整数部分:”除2取余,逆序排列”法 小数部分:”乘2取整,顺序排列”法 2 89 2 44 … 1 2 22 … 0 2 11 … 0 2 5 … 1 2 2 … 1 2 1 … 0 0 … 1
891011001 0.625 X 2 1.25 X 2 0.5 X 2 1.0
0.6250.101
十六进制 二进制表示法太冗长,所以在程序中一般喜欢用十六进制。 十六进制:基数为十六,逢十六进一。它用abcdef表示从0-9之上的值。 Java中十六进制数据要以0x或0X开头。如:0x23D 十六进制转换成二进制只需将每个十六进制数字替换为相对应的四个二进制位即可。 二进制 十六进制 0000 0 0001 1 0010 2 0011 3 0100 4 0101 5 0110 6 0111 7 1000 8 1001 9 1010 A 1011 B 1100 C 1101 D 1110 E 1111 F
八进制 八进制:基数为八。 Java中八进制数据要以0开头。如:0123 八进制转换成二进制:只需将每个八进制数字替换为相对应的三个二进制位即可。 现在的计算机系统很少用八进制的了。 二进制 八进制 000 0 001 1 010 2 011 3 100 4 101 5 110 6 111 7
2.1.4 标识符 Java对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。
Java标识符命名规则: 由字母、数字、下划线(_)和美元符号($)组成。 不能以数字开头。 区分大小。 长度无限制。 不能是Java中的保留关键字。
标识符命名习惯:见名知意。
示例: 合法标识符:HelloWord、username2、user_name、_userName、$abc_123 非法标识符:2UserName、user#Name、Hello World、class
2.1.5 类型转换 boolean 类型不能转换成任何其它数据类型。 自动类型转换:容量小的类型自动转换成容量大的数据类型 byte,short,int -> long ->float ->double byte,short,int不会互相转换,它们三者在计算时会转换成int类型
强制类型转换:容量大的类型转换成容量小的数据类型时,要加上强制转换符 long l = 100L; int i = (int)l; 有可能...
- ?
Java开发人员必知必会的20种常用类库和API
粉碎
展开
一个有经验的Java开发人员特征之一就是善于使用已有的轮子来造车。《Effective Java》的作者Joshua Bloch曾经说过:“建议使用现有的API来开发,而不是重复造轮子”。在本文中,我将分享一些Java开发人员应该熟悉的最有用的和必要的库和API。顺便说一句,这里不包括框架,如Spring和Hibernate因为他们非常有名,都有特定的功能。
本文总结了日志、JSON解析、单测、XML解析、字节码处理、数据库连接池、集合类、邮件、加密、嵌入式SQL数据库、JDBC故障诊断以及序列化等20个方面的常用类库。都是你日常开发经常可能要用到的,现在不用不要紧,但是你要知道有这么一篇文章可以供你参考。
不知道不可怕,可怕的是你不知道你不知道。
一、日志相关类库
日志库是很常见的,因为你在每一个项目中都需要他们。打印日志是服务器端应用中最重要的事情,因为日志是你了解你的程序发生了什么的唯一途径。尽管JDK附带自己的日志库,但是还是有很多更好的选择可用,例如Log4j、SLF4j和LogBack。
Java开发人员应该熟悉日志记录的利弊,并且了解为什么SLF4J要比Log4J要好。
二、JSON解析库
在当今世界的web服务和物联网中(IoT),JSON已经取代了XML,成为从客户端到服务器传送信息的首选协议。有一个好消息和一个坏消息。坏消息是JDK没有提供JSON库。好消息是有许多优秀的第三方库可以用来解析和创建JSON消息,如Jackson 和 Gson
一个Java web开发人员应该熟悉Jackson 和 Gson这两种中的至少一种库。
三、单元测试库
单元测试技术的使用,是区分一个一般的开发者和好的开发者的重要指标。程序员经常有各种借口不写单元测试,但最常见的借口就是缺乏经验和知识。常见的单测框架有JUnit,Mockito和PowerMock。
四、通用类库
有几个很好的第三方通用库可供Java开发人员使用,例如Apache Commons和Google Guava。我会经常在我的代码中使用这些通用类库,因为这些类库都是经过无数开发者实践过的,无论是实用性还是在性能等方面都是最佳的。
五、Http 库
我不是很喜欢JDK的一个重要原因就包括他们缺乏对HTTP的支持。虽然可以使用java包类,但是这和直接使用像Apache HttpClient和HttpCore等开源类库比起来麻烦太多了。
尽管JDK 9将开始HTTP 2.0,也对HTTP的支持做了优化,但是我还是强烈建议所有的Java开发人员熟悉流行的HTTP处理类库,例如HttpClient和HttpCore HTTP等库。
六、XML解析库
市面上有很多XML解析的类库,如Xerces, JAXB, JAXP, Dom4j, Xstream等。Xerces2是下一代高性能,完全兼容的XML解析工具。Xerces2定义了 Xerces Native Interface (XNI)规范,并提供了一个完整、兼容标准的 XNI 规范实现。该解析器是完全重新设计和实现的,更简单以及模块化。
七、Excel读写库
许多应用程序需要提供把数据导出到Excel的功能,如果你要做相同的Java应用程序,那么你需要Apache POI API。
这是一个非常丰富的类库,你可以从Java程序读写XLS文件。
八、字节码库
如果你正在编写一个框架或者类库。有一些受欢迎的字节码库如javassist和Cglib Nodep可以供你选择,他们可以让你阅读和修改应用程序生成的字节码。
Javassist使得JAVA字节码操作非常简单。它是一个为编辑Java字节码而生的类库。ASM是另一个有用的字节码编辑库。
九、数据库连接池库
如果你的Java应用程序与数据库交互不是使用数据库连接池库的话,那么你就大错特错了。因为在运行时创建数据库连接非常耗时并且会拖慢你的程序。所以墙裂建议使用,有些好用的连接池可供选择,如Commons Pool 和 DBCP。
在web应用程序中,web服务器通常提供了这些功能。但是在java项目中需要把数据库连接池的类库导入到应用中。
十、消息传递库
像日志和数据库连接池一样,消息传递也是很多实际的Java项目中必备的。Java提供了JMS Java消息服务,但这不是JDK的一部分,你需要单独的引入jms.jar。类似地,如果您准备使用第三方消息传递协议,Tibco RV是个不错的选择。
十一、PDF处理库
除了Excel和Word,PDF也是一种常用的文件格式。如果你的应用程序要支持PDF格式的文件处理,你可以使用iText和Apache FOP类库。两者都提供了非常有用的PDF处理功能。
十二、日期和时间库
在Java之前,JDK的日期和时间库一直被人们所诟病,比如其非线程安全的、不可变的、容易出错等。很多开发人员会选择更好用的JodaTime类库。
但是在Java8推出之后,我们就可以彻底放弃JodaTime了,因为Java 8提供了其所有功能。但是,如果你的代码运行在一个低版本的JDK中,那么JodaTime还是值得使用的。
十三、集合类库
虽然JDK有丰富的集合类,但还是有很多第三方类库可以提供更多更好的功能。如Apache Commons Collections、 Goldman Sachs collections、 Google Collections和Trove。Trove尤其有用,因为它提供所有标准Collections 类的更快的版本以及能够直接在原语(primitive)(例如包含int 键或值的Map 等)上操作的Collections 类的功能。
FastUtil是另一个类似的API,它继承了Java Collection Framework,提供了数种特定类型的容器,包括映射map、集合set、列表list、优先级队列(prority queue),实现了java.util包的标准接口(还提供了标准类所没有的双向迭代器),还提供了很大的(64位)的array、set、list,以及快速、实用的二进制或文本文件的I/O操作类。
十四、邮件API
javax.mail 和 Apache Commons Email 提供了发送邮件的api。它们建立在JavaMail API的基础上,提供简化的用法。
十五、HTML解析库
和XML与JSON类似,HTML是另外一种我们可能要打交道的传输格式。值得庆幸的是,我们有jsoup可以大大简化Java应用程序使用HTML。你不仅可以使用JSoup解析HTML还可以创建HTML文档。
十六、加密库
Apache Commons家族中的Commons Codec就提供了一些公共的编解码实现,比如Base64, Hex, MD5,Phonetic and URLs等等。
十七、嵌入式SQL数据库库
我真的是非常喜欢像H2这种内存数据库,他可以嵌入到你的Java应用中。在你跑单测的时候如果你需要一个数据库,用来验证你的SQL的话,他是个很好的选择。顺便说一句,H2不是唯一嵌入式DB,你还有Apache Derby和HSQL可供选择。
十八、JDBC故障诊断库
有不错的JDBC扩展库的存在使得调试变得很容易,例如P6spy,这是一个针对数据库访问操作的动态监测框架,它使得数据库数据可无缝截取和操纵,而不必对现有应用程序的代码作任何修改。P6Spy 分发包包括P6Log,它是一个可记录任何 Java 应用程序的所有JDBC事务的应用程序。其配置完成使用时,可以进行数据访问性能的监测。
十九、序列化库
Google Protocol Buffer 是一种轻便高效的结构化数据存储格式,可以用于结构化数据串行化,或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。
二十、网络库
一些有用的网络库主要有Netty的和Apache MINA。如果您正在编写一个应用程序,你需要做的底层网络任务,可以考虑使用这些库。
这都是每位Java开发人员应该熟悉的,并且十分有用的库。Java生态系统非常庞大的,你会发现有很多不同的类库可以做不同的事情。每个你想到的东西,都可能有一个库可以做到。
要相信,你遇到的问题,肯定不止你一个遇到过。
要相信,也许有很多人比你更勤奋。
要相信,你用或不用,轮子就在那里。
要相信,使用这些类库,你和你的代码都会变得更好。
作者:Hollis
- ?
中国式复杂报表生成器—SpotView报表模块C位出道
洪邪欢
展开
我相信,当你看到中国式复杂报表,你的内心:一定是拒绝的!
表格关系非常复杂,无任何规律可循,简直是你加班的恶梦
但在这个以上帝需求即真理的时代,具有“中国特色”的复杂报表即中国式报表一直是国内报表市场的一个重点。
更有豪言称:但凡能搞定中国式复杂报表,那也就没什么搞不定的报表了!
今天,运营魔方PK中国式复杂报表
SpotView报表模块
运营魔方隆重推出专门处理中国复杂报表-SpotView报表模块,它能把一些复杂处理的过程,通过一些函数的封装,让以往难以实现的报表,可以轻松实现,同时避免了大量的复杂SQL编写与前期数据准备,提升了报表设计的效率一个数量级。
四大核心优势
1采用类Excel的操作模式
2多数据源关联
可以进行多源数据关联,关系型数据库、文本文件(excel/txt)、JAVA对象、自定义数据集等等。
3行列对称
任意复杂报表都可以横向和纵向两种方式实现;
4数据分片
上下格式不同的报表在其他软件中只能用子表拼接 ,在SpotView报表模块中非常容易实现。
如果您的企业原来已经有很多正在用的excel报表模板,那就更好,您只需要导入相应excel模板,配置相应数据源 ,再写一些函数,原来的报表直接就能用啦!是不是很方便!
同时,所有的报表可直接导出到Excel、Word、PDF等文件格式,不失真!
中国式复杂报表复杂?
有了运营魔方SpotView报表模块 不存在的!
编辑运营:朱利文
- ?
Java 11 中 11 个不为人知的瑰宝
Tanya
展开
作者 | Nicolai Parlog
译者 | 罗昭成
出品 | CSDN(ID:CSDNnews)
我们已经迎来了 Java 11,尽管它的升级介绍里没有什么跨时代的特性,但却有一些不为人知的瑰宝,像沙砾中的钻石一般。当然,你肯定了解到了一些特性,比如说响应式的 HTTP/2 的 API ,不需要编译就可以直接运行源代码等。但是,你是否有去尝试过 String 、Optional、Collection 等常用类的扩展,如果还没有,那么恭喜你,你将从本文中了解到 Java 11 不为人知的 11 个像钻石般宝贵的知识点。
Lambda 表达式的参数类型推断
当我们在写 Lambda 表达式时,你可以指定具体类型,或者直接省略它:
ction
append = string -> string + " ";Function append = (String s) -> s + " "; 在 Java 10 中添加了一个 var 关键字,但是你并不能在 Lambda 表达示中使用:
// compile error in Java 10Function
append = (var string) -> string + " "; 然而,我们在 Java 11 中却可以。来思考一下,为什么可以如此使用?它不仅仅是在省略类型的变量前面加一个 var ,在这种写法中,有以下两个新的特性:
通过去除特殊情况,使 var 变得更加统一;允许在 Lambda 的参数上添加注解,而不需要写上完整的变量类型名称。举个例子,来看一下这两点:
List
> types = ;types.stream()// this is fine, but we need @Nonnull on the type .filter(type -> check(type))// in Java 10, we need to do this ~> ugh! .filter((@Nonnull EnterpriseGradeType type) -> check(type))// in Java 11, we can do this ~> better .filter((@Nonnull var type) ->check(type)) 我们可以在 Lambda 表达式中同时使用清晰的、不明确的 、var 声明的变量,像如下代码:
(var type, String option, index) ->...
虽然也可以这样实现,但是它会让代码看起来很复杂。因此,笔者建议选取其中一种方式并坚持使用下去。只是为了其中一个参数可添加注解,让所有的参数都加上 var ,这样做的确有点烦人,但笔者认为这是可以忍受的。
"String::lines" 获取数据行数
你有一个多行的字符串,想要对每一行进行单独操作,你可以使用 String::lines 来实现:
var multiline = "This\r\nis a\r\nmultiline\r\nstring";multiline.lines()// we now have a `Stream
` .map(line -> "// " + line) .forEach(System.out::println);// OUTPUT:// This// is a// multiline// string 上面例子中的字符串中的换行使用的是 Windows 中的 \r\n 。尽管我是在 Linux 中使用, lines() 依然可以拆分他们。在不同的操作系统中,lines() 这个方法都会把 \r ,\n , \r\n 作为终止符。即使我们在 string 中混合使用他们。
数据行里面不包含终止符自己,但是可以为空("like\n\nin this\n\ncase" ,它有五行),如果终止符在字符串末尾,lines() 方法会忽略掉它(like\nhere\n ; 只有两行)
与 split("\R") 不同, lines() 是惰性的。
使用更快的搜索方式来搜索新的终止符以提高性能。
如果有人使用 JMH 来验证这一点,请告诉我结果。
不仅如此,它可以更好的传达意思并返回更方便的数据结构(不是数组,而是流)。
使用"String::strip"来移除空格
一直以来,String 使用 trim 来移除空白字符,此方法认为所有的内容都是使用了大于 U+0020 的 Unicode 值。BACKSPACE (U+0008) 是空白,BELL (U+0007) 也是,但是换行符(U+2028) 不是空白字符。
Java 11 引入了 strip ,它与 trim 有一些细微的差别,它使用 Java 5 中的 "Character::isWhitespace" 来识别要移除的内容。它的文档如下:
SPACESEPARATOR, LINESEPARATOR, PARAGRAPH_SEPARATOR, but not non-breaking spaceHORIZONTAL TABULATION (U+0009), LINE FEED (U+000A), VERTICAL TABULATION (U+000B), FORM FEED (U+000C), CARRIAGE RETURN (U+000D)FILE SEPARATOR (U+001C), GROUP SEPARATOR (U+001D), RECORD SEPARATOR(U+001E), UNIT SEPARATOR (U+001F)
基于此逻辑,这儿还有两个移除方法: stripLeading 、stripTailing ,你按照你自己想要的结果来选择对应的方法。
最后,如果你需要知到去掉空白字符后,是否为空,你不需要执行 strip 操作,只需要使用 isBlank 来判断:
" ".isBlank()); // space ~> true" abc ".isBlank()); // non-breaking space ~>false
使用“String::repeat” 来复制字符串
生活大妙招:
第一步:深入了解 JDK 的发展与变更
JDK 文档
第二步:在 StackOverflow 搜索相关问题的答案
StackOverflow 结果
第三步:根据即将到来的变更去回复对应的答案
回答答案
第四步:\_(ツ)_/
第五步:
如你所见, String 现在有一个 repeat(int) 的方法。毋庸置疑,它的行为和我们理解的一模一样,完全没有可以争议的地方。
使用"Path::of"来创建路径
我非常喜欢 Path 这个 API,它解决了我们在路径 、URI 、URL 、FILE 来回切换的麻烦问题。在 Java 11 中,我们可以使用 Paths::get 和 Path::of 来让它们变得很统一:
Path tmp = Path.of("/home/nipa", "tmp");Path codefx = Path.of(URI.create("http://codefx.org"));
这两个方法,被作为标准方法来使用。
使用‘Files::readString’和‘Files::writeString’来进行文件读写
如果你需要从一个非常大的文件里面读取内容,我一般使用 Files::lines ,他返回一个惰性数据流。同样,如果要将不可能同时出来在内容存储在文件里,我一般通过传递一个 Interable 来使用 Files::write 写到文件中。
但是我要如何很方便的处理一个简单的字符串呢?使用 Files::readAllBytes 和 Files::write 并不是特别方便, 因为这两个方法都只能处理 byte 数组。
在 Java 11 中给 Files 添加了 readString 、writeString 两个方法:
String haiku = Files.readString(Path.of("haiku.txt"));String modified = modify(haiku);Files.writeString(Path.of("haiku-mod.txt"), modified);
简单易用,当然,如果你有需要,你也可以将字符数组传底给 readString 方法,你也可以给 writeString 指定文件打开方式。
使用"Reader::nullReader"来处理空的 I/O 操作
你需要一个不处理输入数据的 OutputStream 时,你要怎么处理?那一个空的 InputStream 呢?Reader、Writer 呢?
在 Java 11 中,你可以做如下转换:
InputStream input = InputStream.nullInputStream();OutputStream output = OutputStream.nullOutputStream();Reader reader = Reader.nullReader();Writer writer = Writer.nullWriter();
但我并不认为 null 是一个好的前缀, 我不喜欢这种意图不明确的定义。或许使用 NOOP 更好。
使用"Collection::toArray"将集合转成数组
你是如何将集合转成数组的?
// 在 Java 11 之前的版本List
list = ;Object[] objects = list.toArray();String[] strings_0 = list.toArray(new String[0]);String[] strings_size = list.toArray(new String[list.size()]) 第一行中,转换成了数组,但是变成了 Object,丢失了所有类型信息。那其他两个呢?它们两个使用起来非常地笨重,第一个就显得简洁得多。后者根据需要的大小创建一个数组,因此会有更好的性能(表现得更高效,详情参见 truthy),但事实上,真的会更高效吗?相反,它更慢。
我们为什么如此关心这个问题?是否有更好的办法处理它? 在 Java 11 中,你可以这么做:
String[] strings_fun = list.toArray(String[]::new);
这是集合类使用接收 IntFunction 的一个新的重载方法。也就是说,这个方法根据输入数据的长度返回一个对应长度的数组。在这里可以简洁的表示为 T[]::new。
有意思的是,toArray(IntFunction) 的默认实现总是将 0 传递给数组生成器,最开始,我应为这么做是为了更好的性能,现在我觉得,有可能是因为在某些集合的实现里面要去获取它的大小,代价是非常高的,所以没有在 Collection 中做默认实现。虽然可以覆盖像 ArrayList 这样的具体集合,但是在 Java 11 中,并没有去做,我猜是觉得不划算。
除非你已经有一个数据了,否则请使用新的方法来替换 toArray(T[]) 。当然,旧方法现在依然可以使用。
使用 'Optional::isEmpty' 而不是 'Present'
当你经常使用 Optional 的时候,特别是在与大型的没有做空检查的代码,你需要经常去检查值是不是存在。 你会经常使用 Optional::isPresent ,但是你经常会想知道哪一个 Optional 是空的。没有问题,使用 !opt.isPresent() 就可以了,但是这样对吗?
当然,那样写是没有问题的,但是那样写无法很好地理解其意思。如果你在一个很长的调用链中,想要知道它是不是空的,你就得在最前面加一个“!”。
publicbooleanneedsToCompleteAddress(User user){return !getAddressRepository() .findAddressFor(user) .map(this::canonicalize) .filter(Address::isComplete) .isPresent();}
这个“!”极易被遗忘掉。从 Java 11 开始,我们有了更好的解决方案:
publicbooleanneedsToCompleteAddress(User user){return getAddressRepository() .findAddressFor(user) .map(this::canonicalize) .filter(Address::isComplete) .isEmpty();}
使用 "Predicate::not" 来做取反
在说关于 "not" 的之前,我要说一下 Predicate 接口的 negate 方法,他返回了一个新的 Predicate —— 执行相同的测试代码,但是结果取反。不幸的是,我很少使用它:
// 打印非空字符Stream.of("a", "b", "", "c")// 非常丑陋 ,使用 lamba 表达式, 结果取反 .filter(string -> !string.isBlank())// 编译错误 .filter((String::isBlank).negate())// 强制转型,这个比lamba表达式还要丑陋 .filter(((Predicate
) String::isBlank).negate()) .forEach(System.out::println); 问题是我们很少能拿到 Predicate 的引用,更常见的情况是,我想反转一个方法,但是编译器需要知道目标,如果没有目标,编译器不知道要把引用转换成什么 。所以当你使用 (String::isBlank):negate() 的时候,String::isBlank 就没有目标,编译器就会报错,虽然我们可以想办法解决它,但是成本有多大呢?
这里有一个简单的解决方案,不需要你使用实例方法 negate ,而使用 Java 11 中新的静态方法。
Predicate.not(Predicate) :
Stream.of("a", "b", "", "c")// statically import `Predicate.not` .filter(not(String::isBlank)) .forEach(System.out::println);
完美!
使用 "Pattern:asMatchPredicate" 处理正则表达式
你有一个正则表达式,想要基于它做一些过滤,你要怎么做?
Pattern nonWordCharacter = Patternpile("\\W");Stream.of("Metallica", "Motrhead") .filter(nonWordCharacter.asPredicate()) .forEach(System.out::println);
我非常开心,我能找到这种写法,这是 Java 8 的写法,很不幸,我错过了。
在 Java 11 中,有另外一个方法:Pattern::asMatchPredicate
它们有什么不同呢?
asPredicate 会检查字符串或者其字串是否符合这个正则(他的行为像 s -> this.matcher(s).find() )asMatchPredicate 只会检查整个字符串是否符合这个正则(他的行为像 s -> this.matcher(s).matchs())举个例子:你现在有一个验证手机号的正则表达式,但是这个正则表达式并不包含开始符 ^ 和结束符 $。下面代码的执行逻辑并不符合你的预期:
prospectivePhoneNumbers.stream() .filter(phoneNumberPatter.asPredicate()) .forEach(this::robocall);
发现了它的错误了吗?"y u want numberz? +1-202-456-1414"会通过过滤检测,因为它包含了一个合法的手机号。但是使用 asMatchPredicate 就不能通过,因为整个字符串并不符合正则。
结语
上面就是 11 个不为人知的瑰宝,如果你看到这儿,那么恭喜你,通过了本次学习
1. 字符串
Stream lines()String strip()String stripLeading()String stripTrailing()boolean isBlank()String repeat(int)2. 路径
static Path of(String, String...)static Path of(URI)3. 文件
String readString(Path) throws IOExceptionPath writeString(Path, CharSequence, OpenOption...) throwsIOExceptionPath writeString(Path, CharSequence, Charset, OpenOption...)throws IOException4. I/O 流
static InputStream nullInputStream()static OutputStream nullOutputStream()static Reader nullReader()static Writer nullWriter()5. 集合:T[] toArray(IntFunction)
6. 可选项:boolean isEmpty()
7. 断言:static Predicate not(Predicate)
8. 正则表达式:Predicate asMatchPredicate()
原文:https://blog.codefx.org/java/java-11-gems/作者:Nicolai Parlog,《The Java Module System》作者。译者:罗昭成
- ?
朋友,你可能对Java有误会
魏绣连
展开
小编今天列出了一些关于Java的常见误解,今天给大家讲解一下:
1.Java是HTML的扩展
Java是一种程序设计语言,HTML是一种描述网页结构的方式。除了用在网页上放置Java applet(在网页上运行Java程序)的HTML扩展之外,两者没有任何共同之处。
2.使用XML,所以不需要Java
Java是一种程序设计语言,XML是一种描述数据的方式。我们可以使用任何一种语言处理XML数据,而Java的API对XML处理提供了很好的支持,其中还有许多重要的第三方XML工具都是采用Java写的。
3.Java是一种非常容易学习的程序设计语言
像Java这种强大的语言大都不太容易学习。首先,我们必须将编写玩具式程序的轻松和开发实际项目的艰难区分开来。在Java类库中包含了数千种类和接口以及数万个函数。幸运的是,我们并不需要知道他们中的每一个,然而,要想Java解决实际问题的话,还需要了解不少内容,后续我会发布博客讲解(如何使用Java类库将Java语言应用到实际开发中去)。
4.Java将成为适用于所有平台的通用性编程语言
我们从理论上讲,这一点是完全有可能的。但是在实际中,某些领域其他语言有更出色的表现,比如:浏览器的处理完全用JavaScript掌控。Windows程序通常用C++或C#编写的。而Java在服务器编程和跨平台客户端应用领域则很优势。
5.Java只不过是另外一种程序设计语言
Java是一种很好的程序设计语言,很多开发者比起C、C++、C#更喜欢Java。其实程序设计语言的成功是取决于其能支撑系统的能力,而不是强大的语言。我们更应该关注:&是否提供了易于实现某些功能的易用、便捷和标准的库?&是否有开发工具提供商建立了强大的编程和调试环境? &语言和工具集是否能够与其他计算机基础构架整合在一起。
其实,Java的成功源于其类库能够让人们轻松地完成原本有一定难度的事情。比如说:联网Web应用和并发。Java减少了指针错误,这是一个额外的好处。因此使用Java编程的效率会更高,不过这些并不是它成功的全部原因哦。
6.Java是专用的,应该避免使用
Java虚拟机和类库的源代码是可以免费获得的,不过仅仅限于查看,不能修改。
Java是闭源的,不过也可以很好的使用。Java是闭源的,不过也可以很好的使用。
7.Java是解释型,因此对于关键的应用程序速度太慢了
早期的Java是解释型的。现在的Java虚拟机使用了即使编译器,因此采用Java编写的“热点”(更加关注)代码其运行的速度与C++相差无几,在有些情况下甚至会更快。
8.所有的Java程序都是在网页中运行的
大多数Java程序是运行在Web浏览器之外的独立应用程序。实际上,很多Java程序都在Web服务器上运行并生成用于网页的代码。
9.Java程序是主要的安全风险
随着Java的不断发展,发现了很严重的bug,因此导致了某些管理员甚至在公司浏览器中禁用了Java,而同时却允许用户下载可执行文件和Word文档,实际上,这些带来的风险远远超过使用Java时候的风险,直到现在与其他平台相比,Java还是安全得多。
10.使用Java可以用Cheap的Internet设备取代桌面计算机
现在,大多数用户,常用的平台不是手机就是平板电脑。这些设备大多使用安卓平台,这是Java的衍生产物。
11.Java是解释型语言,因此对于关键的应用程序速度太慢了。
早起的Java是解释型的,现在除了像手机这样的微型平台之外。Java虚拟机使用了即时编译器,因此采用Java编写的热点代码其运行速度与c++相差无几。
现在今天的计算机速度远比人们发出抱怨的时候快了很多。一个较慢的Java程序与几年前相当快的C++程序还要快一些。现在的人们已经不抱怨Java程序慢了,而去抱怨Java的界面太丑了。
12.JavaScript是Java的简易版。
JavaScript是一种在网页中使用的脚本语言。它是由Netscape发明的,原来的名字叫做LiveScript.JavaScript的语法类似于Java,除此之外。两者无任何关系。当然名字有些想象。
学习Java编程也对Android编程有很大的帮助,建议大家可以去学习一下。
- ?
快速开发:Java开发者常用工具插件集锦
法则28
展开
现在项目进度进入到前中期,基本框架都稳定了,目前主要在做业务方面的完善。最近的开发效率不如一开始高,这两天总结思考了以下几点:,希望在日后的工作当中有所帮助。
IDEA集成篇章
1.iBATIS/MyBatis mini-plugin:可以直接从sql接口类点入配置mapper.xml文件。
2.Alibaba Java Coding Guidelines : 阿里巴巴代码规范插件,规范提示,好用!!(之前一直再用,领导的化可以推荐其他组员使用)
3.Jrebel : Jrebel + tomcat 热部署,节省时间。(有些需要破解)
4.IntelliJ Lombok plugin:代码简洁,效率高(需要团队统一规范)
5.Launches VisualVM from within IDEA:性能调优,避免oom。
说明:许多公司现在向微服务转型,很多项目进行改造,而成为首选的是SpringCloud,它也成为了微服务开发的利器。热部署插件用pom引入jar即可,很方便
org.springframework.bootspring-boot-devtoolsDB
操作数据库用Navicat比较方便(自然mysql)
接口管理工具(前后端分离可以使用)
1. Swagger
Swagger 是一款RESTFUL接口的文档在线自动生成+功能测试功能软件。本文简单介绍了在项目中集成swagger的方法和一些常见问题。
Swagger 是一个规范和完整的框架,用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。总体目标是使客户端和文件系统作为服务器以同样的速度来更新。文件的方法,参数和模型紧密集成到服务器端的代码,允许API来始终保持同步。Swagger 让部署管理和使用功能强大的API从未如此简单。
2. PostMan
用户在开发或者调试网络程序或者是网页B/S模式的程序的时候是需要一些方法来跟踪网页请求的,用户可以使用一些网络的监视工具比如著名的Firebug等网页调试工具。今天给大家介绍的这款网页调试工具不仅可以调试简单的css、html、脚本等简单的网页基本信息,它还可以发送几乎所有类型的HTTP请求!Postman在发送网络HTTP请求方面可以说是Chrome插件类产品中的代表产品之一。(项目推荐使用)
3. DOClever
DOClever是一款国内接口管理平台旨在解决接口管理,数据生成,自动化测试的一体化接口平台。在我们平时的开发中,经常会面临前后端接口交互的问题,以往的解决方案多是通过 word 文档来记录下接口的变更,然后发送给团队成员,这种方式不仅效率地下,而且很容易出错,因此,DOClever 就是为了解决这个痛点的一款工具,他不仅集成了接口编辑的分组和管理,在接口测试上也是独居特色,采用的是后端 proxy 代理,无需任何插件,接口数据实时展示!
抓包工具
Charles抓包工具,好用。(系统调试的时候我们也在找个好用的抓包工具,有专业人士比较的了解的可以留言推荐下,谢谢啦)
Notepad++
编辑文档,方便好看
Visio
时序图,流程图,数据库实体关系图,就靠它了
End
开发有什么好用的插件可以在下方留言。帮助别人也是帮助自己。
- ?
Java 语法清单-快速回顾
毕志泽
展开
Java 语法清单翻译自 egek92 的 JavaCheatSheet,从属于笔者的 Java 入门与实践系列。时间仓促,笔者只是简单翻译了些标题与内容整理,支持原作者请前往原文点赞。需要注意的是,此文在 Reddit 上也引起了广泛的讨论,此文讲解的语法要点还是以 Java 7 为主,未涉及 Java 8 中内容,略显陈旧,读者可以带着批判的视角去看。
Java CheatSheet
01
基础
hello, world! :
if-else:
loops:
do-while:
do { System.out.println("Count is: " + count);count++;} while (count < 11);switch-case:
数组:
二维数组:
对象:
类:
方法:
Java IDE 比较:
图片来自 Wikipedia
个人推荐 IntelliJ IDEA 并且对于 学生免费.
02
字符串操作
字符串比较:
boolean result = str1.equals(str2);boolean result = str1.equalsIgnoreCase(str2);
搜索与检索:
int result = str1.indexOf(str2);int result = str1.indexOf(str2,5);String index = str1.substring(14);
字符串反转:
public classMain { public staticvoid main(String[] args) {String str1 = "whatever string something";StringBuffer str1buff = newStringBuffer(str1);String str1rev = str1buff.reverse().toString(); System.out.println(str1rev); }}
按单词的字符串反转:
publicclass Main {publicstaticvoidmain(String[] args) { String str1 = "reverse this string"; Stack stack = new Stack<>(); StringTokenizer strTok = new StringTokenizer(str1); while(strTok.hasMoreTokens()){stack.push(strTok.nextElement()); } StringBuffer str1rev = new StringBuffer();while(!stack.empty()){ str1rev.append(stack.pop()); str1rev.append(" "); } System.out.println(str1rev);}
大小写转化:
String strUpper = str1.toUpperCase();String strLower = str1.toLowerCase();
首尾空格移除:
String str1 = " asdfsdf ";str1.trim(); //asdfsdf
空格移除:
str1.replace(" ","");
字符串转化为数组:
String str = "tim,kerry,timmy,camden";String[] results = str.split(",");
03
数据结构
重置数组大小:
int[] myArray = newint[10];int[] tmp = newint[myArray.length + 10];System.arraycopy(myArray, , tmp, , myArray.length);myArray = tmp;
集合遍历:
for (Iterator it = map.entrySet().iterator();it.hasNext();){ Map.Entry entry = (Map.Entry)it.next(); Object key = entry.getKey(); Object value = entry.getValue();}
创建映射集合:
HashMap map = new HashMap();map.put(key1,obj1);map.put(key2,obj2);map.put(key2,obj2);
数组排序:
int[] nums = {1,4,7,324,,-4}; Arrays.sort(nums);System.out.println(Arrays.toString(nums));
列表排序:
ListunsortList = new ArrayList();unsortList.add("CCC");unsortList.add("111");unsortList.add("AAA");Collections.sort(unsortList);
列表搜索:
intindex = arrayList.indexOf(obj);
finding an object by value in a hashmap:
hashmap.containsValue(obj);
finding an object by key in a hashmap:
hashmap.containsKey(obj);
二分搜索:
int[] nums = newint[]{7,5,1,3,6,8,9,2};Arrays.sort(nums);int index = Arrays.binarySearch(nums,6);System.out.println("6 is at index: "+ index);
arrayList 转化为 array:
Object[] objects = arrayList.toArray();
将 hashmap 转化为 array:
Object[] objects = hashmap.entrySet().toArray();
04
时间与日期类型
打印时间与日期:
Date todaysDate = newDate(); //todays dateSimpleDateFormat formatter = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss"); //date formatString formattedDate = formatter.format(todaysDate);System.out.println(formattedDate);
将日期转化为日历:
Date mDate = newDate();Calendar mCal = Calendar.getInstance();mCal.setTime(mDate);
将 calendar 转化为 date:
Calendar mCal = Calendar.getInstance();Date mDate = mDate.getTime();
字符串解析为日期格式:
publicvoid StringtoDate(String x) throws ParseException{String date = "March 20, 1992 or 3:30:32pm"; DateFormat df = DateFormat.getDateInstance();Date newDate = df.parse(date); }
date arithmetic using date objects:
Date date = newDate();long time = date.getTime();time += 5*24*60*60*1000; //may give a numeric overflow error on IntelliJ IDEADate futureDate = newDate(time);System.out.println(futureDate);
date arithmetic using calendar objects:
Calendar today = Calendar.getInstance();today.add(Calendar.DATE,5);
difference between two dates:
long diff = time1 - time2; diff = diff/(1000*60*60*24);comparing dates:
boolean result = date1.equals(date2);
getting details from calendar:
Calendar cal = Calendar.getInstance();cal.get(Calendar.MONTH);cal.get(Calendar.YEAR);cal.get(Calendar.DAY_OF_YEAR);cal.get(Calendar.WEEK_OF_YEAR);cal.get(Calendar.DAY_OF_MONTH);cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);cal.get(Calendar.DAY_OF_MONTH);cal.get(Calendar.HOUR_OF_DAY);
calculating the elapsed time:
long startTime = System.currentTimeMillis();//times flies by..long finishTime = System.currentTimeMillis();long timeElapsed = startTime-finishTime;System.out.println(timeElapsed);
05
正则表达式
使用 REGEX 寻找匹配字符串:
String pattern = "[TJ]im"; Pattern regPat = Patternpile(pattern,Pattern.CASE_INSENSITIVE); String text = "This is Jim and that's Tim";Matcher matcher = regPat.matcher(text); if (matcher.find()){ String matchedText = matcher.group(); System.out.println(matchedText);}
替换匹配字符串:
String pattern = "[TJ]im";Pattern regPat = Patternpile(pattern,Pattern.CASE_INSENSITIVE); String text = "This is jim and that's Tim";Matcher matcher = regPat.matcher(text);String text2 = matcher.replaceAll("Tom");System.out.println(text2);
使用 StringBuffer 替换匹配字符串:
Pattern p = Patternpile("My");Matcher m = p.matcher("My dad and My mom");StringBuffer sb = newStringBuffer();boolean found = m.find(); while(found){ m.appendReplacement(sb,"Our"); found = m.find();}m.appendTail(sb);System.out.println(sb);
打印所有匹配次数:
String pattern = "\\sa(\\w)*t(\\w)*"; //contains "at"Pattern regPat = Patternpile(pattern);String text = "words something at atte afdgdatdsf hey";Matcher matcher = regPat.matcher(text);while(matcher.find()){ String matched = matcher.group(); System.out.println(matched);}
打印包含固定模式的行:
String pattern = "^a"; Pattern regPat = Patternpile(pattern);Matcher matcher = regPat.matcher("");BufferedReader reader = new BufferedReader(new FileReader("file.txt"));String line; while ((line = reader.readLine())!= null){ matcher.reset(line);if (matcher.find()){ System.out.println(line); }}
匹配新行:
String pattern = "\\d$"; //any single digitString text = "line one\n line two\n line three\n"; Pattern regPat = Patternpile(pattern, Pattern.MULTILINE);Matcher matcher = regPat.matcher(text);while (matcher.find()){ System.out.println(matcher.group());}
regex:
beginning of a string: ^
end of a string: $
0 or 1 times: ?
0 or more times: (*) //without brackets
1 or more times: +
alternative characters: [...]
alternative patterns: |
any character: .
a digit: d
a non-digit: D
whitespace: s
non-whitespace: S
word character: w
non word character: W
06
数字与数学操作处理
内建数据类型:
byte: 8bits, Byte
short: 16bits, Short
long: 64bits, Long
float: 32bits, Float
判断字符串是否为有效数字:
String str = "dsfdfsd54353%%%"; try{ int result = Integer.parseInt(str);}catch (NumberFormatException e){ System.out.println("not valid");}
比较 Double:
Double a = 4.5; Double b= 4.5;boolean result = a.equals(b);if (result) System.out.println("equal");
rounding:
double doubleVal = 43.234234200000000234040324;float floatVal = 2.98f;long longResult = Math.round(doubleVal);int intResult = Math.round(floatVal);System.out.println(longResult + " and " + intResult); // 43 and 3
格式化数字:
double value = 2343.8798;NumberFormat numberFormatter; String formattedValue;numberFormatter = NumberFormat.getNumberInstance();formattedValue = numberFormatter.format(value);System.out.format("%s%n",formattedValue); //2.343,88
格式化货币:
double currency = 234546457.99;NumberFormat currencyFormatter; String formattedCurrency;currencyFormatter = NumberFormat.getCurrencyInstance();formattedCurrency = currencyFormatter.format(currency);System.out.format("%s%n",formattedCurrency); // $ 234.546.457,99
二进制、八进制、十六进制转换:
int val = 25;String binaryStr = Integer.toBinaryString(val);String octalStr = Integer.toOctalString(val);String hexStr = Integer.toHexString(val);
随机数生成:
double rn = Math.random(); int rint = (int) (Math.random()*10); // random int between 0-10System.out.println(rn);System.out.println(rint);
计算三角函数:
doublecos = Math.cos(45);doublesin = Math.sin(45); doubletan = Math.tan(45);
计算对数
double logVal = Math.log(125.5);
Math library:
07
StringBuffer buffer = newStringBuffer();Formatter formatter = new Formatter(buffer, Locale.US);formatter.format("PI: "+Math.PI);System.out.println(buffer.toString());
formatter format calls:
打开文件:
BufferedReader br = new BufferedReader(new FileReader(textFile.txt)); //for readingBufferedWriter bw = new BufferedWriter(new FileWriter(textFile.txt)); //for writing
读取二进制数据:
InputStream is = new FileInputStream(fileName);int offset = ; int bytesRead = is.read(bytes, ofset, bytes.length-offset);
文件随机访问:
File file = new File(something.bin);RandomAccessFile raf = new RandomAccessFile(file,"rw");raf.seek(file.length());
读取 Jar/zip/rar 文件:
ZipFile file =new ZipFile(filename);Enumeration entries = file.entries(); while(entries.hasMoreElements()){ ZipEntry entry = (ZipEntry) entries.nextElement();if (entry.isDirectory()){//do something } else{ //do something }}file.close();
08
文件与目录
创建文件:
File f = new File("textFile.txt");boolean result = f.createNewFile();
文件重命名:
File f = new File("textFile.txt");File newf = new File("newTextFile.txt");boolean result = f.renameto(newf);
删除文件:
File f = new File("somefile.txt");f.delete();
改变文件属性:
File f = new File("somefile.txt");f.setReadOnly(); // making the file read onlyf.setLastModified(desired time);
获取文件大小:
File f = new File("somefile.txt");long length = file.length();
判断文件是否存在:
File f = new File("somefile.txt");boolean status = f.exists();
移动文件:
File f = new File("somefile.txt");File dir = new File("directoryName");boolean success = f.renameTo(new File(dir, file.getName()));
获取绝对路径:
File f = new File("somefile.txt");File absPath = f.getAbsoluteFile();
判断是文件还是目录:
File f = new File("somefile.txt");boolean isDirectory = f.isDirectory();System.out.println(isDirectory); //false
列举目录下文件:
File directory = new File("users/ege");String[] result = directory.list();
创建目录:
boolean result = new File("users/ege").mkdir();
09
网络客户端
服务器连接:
String serverName = "";Socket socket = new Socket(serverName, 80);System.out.println(socket);
网络异常处理:
try { Socket sock = new Socket(server_name, tcp_port); System.out.println("Connected to " + server_name); sock.close( ); } catch (UnknownHostException e) { System.err.println(server_name + " Unknown host"); return; } catch (NoRouteToHostException e) { System.err.println(server_name + " Unreachable" );return; } catch (ConnectException e) { System.err.println(server_name + " connect refused");return; } catch (java.io.IOException e) { System.err.println(server_name + ' ' + e.getMessage( )); return; }
10
包与文档
创建包:
packagecom.ege.example;使用 JavaDoc 注释某个类:
javadoc -d \home\html -sourcepath \home\src -subpackages java
Jar 打包:
jarcfproject.jar *.class
运行 Jar:
java-jarsomething.jar
排序算法
Bubble Sort
Linear Search
Binary Search
Selection Sort
Insertion Sort
精选文章
99%的人都理解错了HTTP中GET与POST的区别
《阿里巴巴Java开发手册》终极版IDE插件
Spring思维导图,让Spring不再难懂(mvc篇)
Spring思维导图,让Spring不再难懂(aop篇)
Spring思维导图,让Spring不再难懂(ioc篇)
Spring思维导图,让spring不再难懂(一)
Spring思维导图,让Spring不再难懂(cache篇)