-
?
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
-
?
Java程序员常用的软件
盼柳
展开
java程序员常用的软件
一、常用的开发工具
(1)Eclipse
Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言,它只是一个框架和一组服务,用于通过插件组件构建开发环境。幸运的是,Eclipse 附带了一个标准的插件集,包括Java开发工具(Java Development Kit,JDK)。
(2)IntelliJ IDEA
IDEA 全称 IntelliJ IDEA,是java语言开发的集成环境,IntelliJ在业界被公认为最好的java开发工具之一,尤其在智能代码助手、代码自动提示、重构、J2EE支持、Ant、JUnit、CVS整合、代码审查、 创新的GUI设计等方面的功能可以说是超常的。IDEA是JetBrains公司的产品,这家公司总部位于捷克共和国的首都布拉格,开发人员以严谨著称的东欧程序员为主。
二、常用的接口测试工具
(1)SoapUI
SoapUI是一个开源测试工具,通过soap/http来检查、调用、实现Web Service的功能/负载/符合性测试。该工具既可作为一个单独的测试软件使用,也可利用插件集成到Eclipse,maven2.X,Netbeans 和intellij中使用。SoapUI Pro是SoapUI的商业非开源版本,实现的功能较开源的SoapUI更多。
(2)JMeter
Apache JMeter是Apache组织开发的压力测试工具,也是目前应用最广泛的开源性能测试工具之一。它最初被设计用于Web应用测试,后来扩展到其他测试领域。像其他性能测试工具一样,JMeter可以用于对服务器、网络或对象模拟巨大的负载,来测试不同压力类别下应用系统的强度,分析应用系统的整体性能。JMeter由100% JAVA开发,开源,具备完全的可移植性;采用Swing界面和轻量组件支持包;支持插件扩展,可以通过扩展插件支持新的协议,监控系统资源,展示更丰富的性能图表等。企业能够在JMeter的基础上实现二次开发,扩展JMeter的功能为己所用。不过要记住Jmeter由JAVA开发,安装Jmeter之前需要先安装JDK。Jmeter功能非常强大是笔者最喜欢的接口测试工具,没有之一。
三、常用的远程连接工具
(1)Xshell和Xftp
Xshell是一个功能强大的终端模拟器,支持SSH、SFTP、TELNET、远程登录命令连接; Xftp是一个灵活和轻量级SFTP / FTP客户端用户需要安全地通过网络传输文件。它提供了强大的功能,如直接编辑多个窗格、文件夹同步、他们支持服务器到服务器转移和第三方编辑器集成。
(2)SecureCRT和SecureFX
SecureCRT是一款支持SSH协议(SSH1和SSH2)的终端仿真程序,简单地说是Windows下登录UNIX或Linux服务器主机的软件;SecureFX是对应的文件上传工具,使用SecureFX可以让我们使用SSH协议上传文件到远程服务器。
(3)VNC
VNC (Virtual Network Console)是虚拟网络控制台的缩写。它 是一款优秀的远程控制工具软件,由著名的 AT&T 的欧洲研究实验室开发的。VNC 是在基于 UNIX 和 Linux 操作系统的免费的开源软件,远程控制能力强大,高效实用,其性能可以和 Windows 和 MAC 中的任何远程控制软件媲美。 在 Linux 中,VNC 包括以下四个命令:vncserver,vncviewer,vncpasswd,和 vncconnect。大多数情况下用户只需要其中的两个命令:vncserver 和 vncviewer。
四、数据库管理工具
(1)Navicat Premium
Navicat Premium是一个可多重连接的数据库管理工具,它可让你以单一程序同时连接到MySQL、SQL Server、sqlite、Oracle 及 PostgreSQL数据库,让管理不同类型的数据库更加方便。
(2)Dbvisualizer
DbVisualizer是一个完全基于JDBC的跨平台数据库管理工具,内置SQL语句编辑器(支持语法高亮),凡是具有JDBC数据库接口的数据库都可以管理,已经在Oracle, Sybase, DB2, Informix, MySQL, InstantDB, Cloudcape, HyperSonic ,Mimer SQL上通过测试。
(3)PL/SQL Developer
PL/SQL Developer是一个面向Oracle 数据库开发存储程序单元的集成开发环境IDE ,pl sql developer侧重于易用性、代码品质和生产力,充分发挥Oracle应用程序开发过程中的主要优势,使用pl sql developer,你能方便地创建你的客户端/ 服务器应用程序的服务器部分。
五、数据库设计工具
(1)PowerDesigner
powerdesigner免费版是一款用于数据库设计的软件。powerdesigner免费版可以方便的对管理系统信息进行分析与设计,它包括了数据库模型设计的全部过成。软件可以制作数据流程图、概念数据模型、物理数据模型,还可以为数据仓库制作结构模型等强大的功能。该软件能与大部分其他的开发工具进行配合节省开发时间。
(2)PDMReader
PdmReader是浏览速查pdm(*.pdm)文件的免费工具软件,无需注册,与SyBase公司的PowerDesigner产品相比的优势是:使用PdmReader进行数据字典管理,它可以以最快的速度找到您要查到的数据字典信息,大大提高日常工作效率。PdmReader也是连接oracle,sql server,access等数据库并提供实用辅助功能的客户端工具(ado方式连接数据库),比如SQL脚本导出,excel,word,html,xls,txt文件导出等。
六、数据交换工具
(1)kettle
Kettle是一款国外开源的ETL工具,纯java编写,可以在Window、Linux、Unix上运行,数据抽取高效稳定。
Kettle 中文名称叫水壶,该项目的主程序员MATT 希望把各种数据放到一个壶里,然后以一种指定的格式流出。
(2)ODI
ODI是英文缩写,有以下释义--对外直接投资,Oracle的数据集成类工具,开放数据链路接口,医学用的光距尺灯。
七、其他常用软件
(1)文本编辑工具 Notepad++ 与 UltraEdit
(2)对比工具 beyond compare
(3)反编译工具JD-GUI 和 JD-Eclipse
(4)版本控制系统 SVN 和gitHub
(5)办公软件 office 2010 和 WPS
-
?
快速开发:Java开发者常用工具插件集锦
卓安萱
展开
现在项目进度进入到前中期,基本框架都稳定了,目前主要在做业务方面的完善。最近的开发效率不如一开始高,这两天总结思考了以下几点:,希望在日后的工作当中有所帮助。
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 11 中 11 个不为人知的瑰宝
London
展开
作者 | 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 synchronized原理总结
Jade
展开
锁的内存语义
synchronized的底层是使用操作系统的mutex lock实现的。
内存可见性:同步快的可见性是由“如果对一个变量执行lock操作,将会清空工作内存中此变量的值,在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值”、“对一个变量执行unlock操作之前,必须先把此变量同步回主内存中(执行store和write操作)”这两条规则获得的。
操作原子性:持有同一个锁的两个同步块只能串行地进入
锁的内存语义:
当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中
当线程获取锁时,JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量
锁释放和锁获取的内存语义:
线程A释放一个锁,实质上是线程A向接下来将要获取这个锁的某个线程发出了(线程A对共享变量所做修改的)消息。
线程B获取一个锁,实质上是线程B接收了之前某个线程发出的(在释放这个锁之前对共享变量所做修改的)消息。
线程A释放锁,随后线程B获取这个锁,这个过程实质上是线程A通过主内存向线程B发送消息
synchronized锁
synchronized用的锁是存在Java对象头里的。
JVM基于进入和退出Monitor对象来实现方法同步和代码块同步。代码块同步是使用monitorenter和monitorexit指令实现的,monitorenter指令是在编译后插入到同步代码块的开始位置,而monitorexit是插入到方法结束处和异常处。任何对象都有一个monitor与之关联,当且一个monitor被持有后,它将处于锁定状态。
根据虚拟机规范的要求,在执行monitorenter指令时,首先要去尝试获取对象的锁,如果这个对象没被锁定,或者当前线程已经拥有了那个对象的锁,把锁的计数器加1;相应地,在执行monitorexit指令时会将锁计数器减1,当计数器被减到0时,锁就释放了。如果获取对象锁失败了,那当前线程就要阻塞等待,直到对象锁被另一个线程释放为止。
注意两点:
1、synchronized同步快对同一条线程来说是可重入的,不会出现自己把自己锁死的问题;
2、同步块在已进入的线程执行完之前,会阻塞后面其他线程的进入。
Mutex Lock
监视器锁(Monitor)本质是依赖于底层的操作系统的Mutex Lock(互斥锁)来实现的。每个对象都对应于一个可称为" 互斥锁" 的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
互斥锁:用于保护临界区,确保同一时间只有一个线程访问数据。对共享资源的访问,先对互斥量进行加锁,如果互斥量已经上锁,调用线程会阻塞,直到互斥量被解锁。在完成了对共享资源的访问后,要对互斥量进行解锁。
mutex的工作方式:
1) 申请mutex
2) 如果成功,则持有该mutex
3) 如果失败,则进行spin自旋. spin的过程就是在线等待mutex, 不断发起mutex gets, 直到获得mutex或者达到spin_count限制为止
4) 依据工作模式的不同选择yiled还是sleep
5) 若达到sleep限制或者被主动唤醒或者完成yield, 则重复1)~4)步,直到获得为止
由于Java的线程是映射到操作系统的原生线程之上的,如果要阻塞或唤醒一条线程,都需要操作系统来帮忙完成,这就需要从用户态转换到核心态中,因此状态转换需要耗费很多的处理器时间。所以synchronized是Java语言中的一个重量级操作。在JDK1.6中,虚拟机进行了一些优化,譬如在通知操作系统阻塞线程之前加入一段自旋等待过程,避免频繁地切入到核心态中:
synchronized与java.util.concurrent包中的ReentrantLock相比,由于JDK1.6中加入了针对锁的优化措施(见后面),使得synchronized与ReentrantLock的性能基本持平。ReentrantLock只是提供了synchronized更丰富的功能,而不一定有更优的性能,所以在synchronized能实现需求的情况下,优先考虑使用synchronized来进行同步。
Java对象头
在运行期间,Mark Word里存储的数据会随着锁标志位的变化而变化,以32位的JDK为例:
锁优化
偏向锁、轻量级锁、重量级锁
Synchronized是通过对象内部的一个叫做监视器锁(monitor)来实现的,监视器锁本质又是依赖于底层的操作系统的Mutex Lock(互斥锁)来实现的。而操作系统实现线程之间的切换需要从用户态转换到核心态,这个成本非常高,状态之间的转换需要相对比较长的时间,这就是为什么Synchronized效率低的原因。因此,这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。
Java SE 1.6为了减少获得锁和释放锁带来的性能消耗,引入了“偏向锁”和“轻量级锁”:锁一共有4种状态,级别从低到高依次是:无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。锁可以升级但不能降级。
偏向锁
HotSpot的作者经过研究发现,大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得。偏向锁是为了在只有一个线程执行同步块时提高性能。
当一个线程访问同步块并获取锁时,会在对象头和栈帧中的锁记录里存储锁偏向的线程ID,以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁,只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径,因为轻量级锁的获取及释放依赖多次CAS原子指令,而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令(由于一旦出现多线程竞争的情况就必须撤销偏向锁,所以偏向锁的撤销操作的性能损耗必须小于节省下来的CAS原子指令的性能消耗)。
偏向锁获取过程:
(1)访问Mark Word中偏向锁的标识是否设置成1,锁标志位是否为01——确认为可偏向状态。
(2)如果为可偏向状态,则测试线程ID是否指向当前线程,如果是,进入步骤(5),否则进入步骤(3)。
(3)如果线程ID并未指向当前线程,则通过CAS操作竞争锁。如果竞争成功,则将Mark Word中线程ID设置为当前线程ID,然后执行(5);如果竞争失败,执行(4)。
(4)如果CAS获取偏向锁失败,则表示有竞争(CAS获取偏向锁失败说明至少有过其他线程曾经获得过偏向锁,因为线程不会主动去释放偏向锁)。当到达全局安全点(safepoint)时,会首先暂停拥有偏向锁的线程,然后检查持有偏向锁的线程是否活着(因为可能持有偏向锁的线程已经执行完毕,但是该线程并不会主动去释放偏向锁),如果线程不处于活动状态,则将对象头设置成无锁状态(标志位为“01”),然后重新偏向新的线程;如果线程仍然活着,撤销偏向锁后升级到轻量级锁状态(标志位为“00”),此时轻量级锁由原持有偏向锁的线程持有,继续执行其同步代码,而正在竞争的线程会进入自旋等待获得该轻量级锁。
(5)执行同步代码。
偏向锁的释放过程:
如上步骤(4)。偏向锁使用了一种等到竞争出现才释放偏向锁的机制:偏向锁只有遇到其他线程尝试竞争偏向锁时,持有偏向锁的线程才会释放锁,线程不会主动去释放偏向锁。偏向锁的撤销,需要等待全局安全点(在这个时间点上没有字节码正在执行),它会首先暂停拥有偏向锁的线程,判断锁对象是否处于被锁定状态,撤销偏向锁后恢复到未锁定(标志位为“01”)或轻量级锁(标志位为“00”)的状态。
关闭偏向锁:
偏向锁在Java 6和Java 7里是默认启用的。由于偏向锁是为了在只有一个线程执行同步块时提高性能,如果你确定应用程序里所有的锁通常情况下处于竞争状态,可以通过JVM参数关闭偏向锁:-XX:-UseBiasedLocking=false,那么程序默认会进入轻量级锁状态。
轻量级锁
轻量级锁是为了在线程近乎交替执行同步块时提高性能。
轻量级锁的加锁过程:
(1)在代码进入同步块的时候,如果同步对象锁状态为无锁状态(锁标志位为“01”状态,是否为偏向锁为“0”),虚拟机首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record)的空间,用于存储锁对象目前的Mark Word的拷贝,官方称之为 Displaced Mark Word。这时候线程堆栈与对象头的状态如下图所示。
(2)拷贝对象头中的Mark Word复制到锁记录中。
(3)拷贝成功后,虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针,并将Lock record里的owner指针指向object mark word。如果更新成功,则执行步骤(3),否则执行步骤(4)。
(4)如果这个更新动作成功了,那么这个线程就拥有了该对象的锁,并且对象Mark Word的锁标志位设置为“00”,即表示此对象处于轻量级锁定状态,这时候线程堆栈与对象头的状态如下图所示。
(5)如果这个更新操作失败了,虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧,如果是就说明当前线程已经拥有了这个对象的锁,那就可以直接进入同步块继续执行。否则说明多个线程竞争锁,若当前只有一个等待线程,则可通过自旋稍微等待一下,可能另一个线程很快就会释放锁。 但是当自旋超过一定的次数,或者一个线程在持有锁,一个在自旋,又有第三个来访时,轻量级锁膨胀为重量级锁,重量级锁使除了拥有锁的线程以外的线程都阻塞,防止CPU空转,锁标志的状态值变为“10”,Mark Word中存储的就是指向重量级锁(互斥量)的指针,后面等待锁的线程也要进入阻塞状态。
轻量级锁的解锁过程:
(1)通过CAS操作尝试把线程中复制的Displaced Mark Word对象替换当前的Mark Word。
(2)如果替换成功,整个同步过程就完成了。
(3)如果替换失败,说明有其他线程尝试过获取该锁(此时锁已膨胀),那就要在释放锁的同时,唤醒被挂起的线程。
重量级锁
如上轻量级锁的加锁过程步骤(5),轻量级锁所适应的场景是线程近乎交替执行同步块的情况,如果存在同一时间访问同一锁的情况,就会导致轻量级锁膨胀为重量级锁。Mark Word的锁标记位更新为10,Mark Word指向互斥量(重量级锁)
Synchronized的重量级锁是通过对象内部的一个叫做监视器锁(monitor)来实现的,监视器锁本质又是依赖于底层的操作系统的Mutex Lock(互斥锁)来实现的。而操作系统实现线程之间的切换需要从用户态转换到核心态,这个成本非常高,状态之间的转换需要相对比较长的时间,这就是为什么Synchronized效率低的原因。
(具体见前面的mutex lock)
偏向锁、轻量级锁、重量级锁之间转换
偏向所锁,轻量级锁都是乐观锁,重量级锁是悲观锁。
一个对象刚开始实例化的时候,没有任何线程来访问它的时候。它是可偏向的,意味着,它现在认为只可能有一个线程来访问它,所以当第一个线程来访问它的时候,它会偏向这个线程,此时,对象持有偏向锁。偏向第一个线程,这个线程在修改对象头成为偏向锁的时候使用CAS操作,并将对象头中的ThreadID改成自己的ID,之后再次访问这个对象时,只需要对比ID,不需要再使用CAS在进行操作。
一旦有第二个线程访问这个对象,因为偏向锁不会主动释放,所以第二个线程可以看到对象时偏向状态,这时表明在这个对象上已经存在竞争了。检查原来持有该对象锁的线程是否依然存活,如果挂了,则可以将对象变为无锁状态,然后重新偏向新的线程。如果原来的线程依然存活,则马上执行那个线程的操作栈,检查该对象的使用情况,如果仍然需要持有偏向锁,则偏向锁升级为轻量级锁,(偏向锁就是这个时候升级为轻量级锁的),此时轻量级锁由原持有偏向锁的线程持有,继续执行其同步代码,而正在竞争的线程会进入自旋等待获得该轻量级锁;如果不存在使用了,则可以将对象回复成无锁状态,然后重新偏向。
轻量级锁认为竞争存在,但是竞争的程度很轻,一般两个线程对于同一个锁的操作都会错开,或者说稍微等待一下(自旋),另一个线程就会释放锁。 但是当自旋超过一定的次数,或者一个线程在持有锁,一个在自旋,又有第三个来访时,轻量级锁膨胀为重量级锁,重量级锁使除了拥有锁的线程以外的线程都阻塞,防止CPU空转。
其他锁优化
锁消除
锁消除即删除不必要的加锁操作。虚拟机即时编辑器在运行时,对一些“代码上要求同步,但是被检测到不可能存在共享数据竞争”的锁进行消除。
根据代码逃逸技术,如果判断到一段代码中,堆上的数据不会逃逸出当前线程,那么可以认为这段代码是线程安全的,不必要加锁。
看下面这段程序:
public class SynchronizedTest { public static void main(String[] args) { SynchronizedTest test = new SynchronizedTest(); for (int i = 0; i < 100000000; i++) { test.append("abc", "def"); } } public void append(String str1, String str2) { StringBuffer sb = new StringBuffer(); sb.append(str1).append(str2); }}
虽然StringBuffer的append是一个同步方法,但是这段程序中的StringBuffer属于一个局部变量,并且不会从该方法中逃逸出去(即StringBuffer sb的引用没有传递到该方法外,不可能被其他线程拿到该引用),所以其实这过程是线程安全的,可以将锁消除。
锁粗化
如果一系列的连续操作都对同一个对象反复加锁和解锁,甚至加锁操作是出现在循环体中的,那即使没有出现çº...
-
?
Java使用Apache POI导出Excel
归隐
展开
一.POI简单介绍
Apache POI 是用Java 编写的免费开源的跨平台的 Java API,Apache POI提供API给Java程式对 Microsoft Office 格式档案读和写的功能
HSSF 提供读写Microsoft Excel XLS格式档案的功能。
XSSF 提供读写Microsoft Excel OOXML XLSX格式档案的功能。
HWPF 提供读写Microsoft Word DOC格式档案的功能。
HSLF 提供读写Microsoft PowerPoint格式档案的功能。
HDGF 提供读Microsoft Visio格式档案的功能。
HPBF 提供读Microsoft Publisher格式档案的功能。
HSMF 提供读Microsoft Outlook格式档案的功能。
二.操作步骤
1.环境配置:导入jar包
org.apache.poi poi 3.16
2.创建一个Excel工作簿
@Test public void test() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel工作蒲.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }
3.创建一个sheet页
@Test public void sheet() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 wb.createSheet("第一个sheet页"); wb.createSheet("第二个sheet页"); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel工作蒲带有sheet页.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }
sheet页
4.创建行和列
@Test public void row() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("学生信息sheet页"); //创建一行 Row row = sheet.createRow(0); //创建一个单元格 Cell cell =null; for(int i = 0 ;i<5;i++){ row.createCell(i).setCellValue("写入信息:单元格内容"+i); } //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel学生信息.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }
5.创建一个时间样式到Excel
@Test public void date() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("时间sheet页"); //创建一行 Row row = sheet.createRow(0); //创建一个单元格 Cell cell = row.createCell(0); cell.setCellValue(new Date()); CreationHelper creationHelper = wb.getCreationHelper(); //设置单元格样式 CellStyle cellStyle = wb.createCellStyle(); cellStyle.setDataFormat(creationHelper.createDataFormat().getFormat("YYYY-MM-DD hh:mm:ss")); cell = row.createCell(1); cell.setCellValue(new Date()); //设置日期样式 cell.setCellStyle(cellStyle); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel日期格式.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }
6.单元格对其方式及行高
@Test public void style() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("第一个sheet"); //创建一行 Row row = sheet.createRow(0); //设置行高 row.setHeightInPoints(30); //创建一个单元格 createCell(wb,row,(short)0,HSSFCellStyle.ALIGN_CENTER,HSSFCellStyle.VERTICAL_BOTTOM); createCell(wb,row,(short)1,HSSFCellStyle.ALIGN_JUSTIFY,HSSFCellStyle.VERTICAL_CENTER); createCell(wb,row,(short)2,HSSFCellStyle.ALIGN_CENTER_SELECTION,HSSFCellStyle.VERTICAL_JUSTIFY); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel样式.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); } /** * 创建一个单元格设置对应的对其方式 * @param workbook 工作蒲 * @param row 行 * @param column 列 */ private static void createCell(Workbook workbook, Row row, short column,short halign,short valign){ Cell cell = row.createCell(column);//创建单元格 cell.setCellValue(new HSSFRichTextString("我是富文本"));//设置值 CellStyle cellStyle = workbook.createCellStyle();//创建样式 cellStyle.setAlignment(halign);//设置单元格水平方向对其方式 cellStyle.setVerticalAlignment(valign);//设置单元格垂直方向对其方式 cell.setCellStyle(cellStyle); }
合并单元格
@Test public void test1() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("第一个sheet"); //创建一行 Row row = sheet.createRow(1); //设置行高 row.setHeightInPoints(30); //创建一个单元格 Cell cell = row.createCell(1); cell.setCellValue("合并单元格"); //合并单元格(起始行,结束行,起始列,结束列) sheet.addMergedRegion(new CellRangeAddress(1,2,1,2)); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel样式.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }
-
?
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篇)
-
?
java初学者学习心得
曲醉香
展开
学习了一学期的Java课程,觉得是该总结自己的心得体会了。开始学习任何一门课(包括java),兴趣最重要。
还记得我编写的第一个经典程序“Hello Word”。从那时起我已开始走进Java的世界。
当时自己不是很理解为什么main方法一定要这样来定义public static void main(String[] args),能不能不这样写?
问了好多同学,他们告诉我的答案是一样的“java本身要求就是这样子的”。但我自己不甘心,就进行了下面的好多操作:
把main改个名字运行一下,看看报什么错误,然后根据出错信息进行分析;把main的public取掉,在试试看,报什么错误;static去掉还能不能运行;不知道main方法是否一定要传一个String[]数组的,把String[]改掉,改成int[],或者String试试看;不知道是否必须写args参数名称的,也可以把args改成别的名字,看看运行结果如何。
结果把Hello World程序反复改了七八次,不断运行,分析运行结果,最后就彻底明白为什么了main方法是这样定义的了。
接着在以后的学习中我也采用这样的方法解决问题,却发现自己的速度比别人慢了好多,我就把自己的课余时间也分一部分给了java。
因为基础是最重要的,只有基础牢固才有可能对后面的学习有更加深刻的认识!
同时,对一个最简单的程序也应该多去调试,多想想如果改动一下会出现什么结果?为什么必须那样写?多去想想这些问题然后去操作,会让你有更多的收获。这样反复地思考是很有用的。
在学习Java的语法时,Java的语法是类似c语言的,所以学习的比较轻松。唯一需要注意的是有几个不容易搞清楚的关键字的用法,public,protected,private,static,什么时候用,为什么要用,怎么用,和同学一起讨论了好久才得以解决。
在学习Java的面向对象的编程语言的特性。比如继承,构造器,抽象类,接口,方法的多态,重载,覆盖,Java的异常处理机制。
对于一个没有面向对象语言背景的人来说,我觉得这个过程需要花很长很长时间,因为学习Java之前没有C++的经验,只有C语言的经验,花了很长时间,才彻底把这些概念都搞清楚,把书上面的例子反复的揣摩,修改,尝试,把那几章内容反复的看过来,看过去,看了很多遍,才彻底领悟了。
开始熟悉Java的类库。基础类库里面的类非常非常多。据说有3000多个。但是我真正使用的只有几个,比如说 java.io.*; java.util.*; java.sql.*;等。
此外,我对于static,public,private,Exception,try{ },catch { },finally{ }等等一开始都不是很懂,都是把书上面的例子运行成功,然后就开始破坏它,不断的根据自己心里面的疑问来重新改写程序,看看能不能运行,运行出来是个什么样子,是否可以得到预期的结果。
这样虽然比较费时间,不过一个例子程序这样反复破坏几次之后。我就对这个相关的知识彻底学通了。
有时候甚至故意写一些错误的代码来运行,看看能否得到预期的运行错误。这样对于编程的掌握是及其深刻的。
在学习Java的过程中我得出这样的结论:
1.学习中,要养成良好的习惯(写括号时要成对,字母大小写要区分,单词拼写要准确)。
2.在学习的过程中,最好不是仅仅停留在java表层,不是抄书上的例子运行出结果就可以。要注意,即便对一个简单的例子也要有耐心去琢磨、调试、改动。
3.在学习的过程中一定要动手做、试着写代码,而不是抱一本书看看就行。很多东西和体会必须自己动手才能真正属于自己。
4.在Java的学习过程中,可能会遇到形形色色的问题不容易解决,应多去专业论坛了解相关的知识,书本上的知识有限。要会从网上搜索有用的信息 加以整理,促进学习的深入和知识水平的提高。
说学到一定程度要尝试着自己做东西,但觉得自己仅仅经过一学期的学习,还远远不够,希望自己在以后学习中继续努力,能够真真正正拥有一门编程语言!
-
?
跟我学java编程—什么是流程图?
青枫
展开
流程图是算法的图形化描述。俗话说:一张图胜过千言万语,用流程图可以清晰地描述出算法的思路和过程。
● 从生活中认识流程图
说到流程图,同学们可能会感到比较陌生和不理解,其实我们在生活中,经常会看到流程图,也会读懂流程图,并能按照流程图的要求去执行流程图中的各个步骤。
例如:现在家庭中一般都有电冰箱、洗衣机等家用电器,家用电器包装箱里面都会附带使用说明书,使用说明书包含了产品的使用方法、注意事项以及一般故障排除流程等内容,当家用电器发生故障时,可以先根据使用说明书的故障排除流程进行故障检查,多半故障原因是因使用不当造成的。下图是某一洗衣机不启动的故障原因排除流程图:
图 1-4 洗衣机不启动故障排除流程图流程图明确给出了排除因使用不当原因而造成洗衣机不启动故障的排查方法和流程,可以参照流程图给出的步骤,逐步排查洗衣机不能启动的原因。
按照流程图给出的步骤:
第一步需要检查电源是否接通,如果电源有问题,则解决电源问题后,故障排除。如果电源没有问题,则进入第二个步骤。
第二步需要检查洗衣机门是否关严,如果洗衣机门没有关严,则关严洗衣机门,故障排除。如果洗衣机门已关严,则进入第三个步骤。
第三步需要检查洗衣机进水部分,查看水龙头是否打开,没有水压,洗衣机也不能启动,如果水龙头没有打开,则打开水龙头,故障排除。如果水龙头已打开且有水压,则进入第四个步骤。
第四步需要检查是否按下了启动键并有蜂鸣声,如果没有按下启动键,则按下启动键,故障排除。如果已按下启动键且有蜂鸣声,则需要给售后服务打电话报修。
● 认识流程图的符号
在第一节什么是计算机程序和本节都给出了流程图样例,看了这么多流程图,同学们一定很奇怪,流程图的椭圆框、菱形框、平行四边形、长方形以及带线的箭头都表示什么意义?画流程图是不是可以用其它形状画呢?
其实,流程图是可以允许用其它图形符号画的,只要自己能看明白,能记住流程就行。问题是,如果你希望其他人也能看懂你的流程图,可能就有点麻烦了,你需要给他们解释你流程图中采用的每个图形所表示的含义是什么,当需要给多个人解释时,这时你一定在想,如果这些图形表示的含义他们都知道该多好,就不用我一个个去讲,去沟通了。
因此,规范的流程图可以帮助人们对流程的统一认识,便于沟通和讨论,有助于工作效率的提高。它使用一组预定义的符号来说明如何执行特定任务,这些预先定义的符号已经标准化,从而让全世界的开发人员都可以采用这些符号而不会引起混淆。表1-1对流程图中使用的符号进行了汇总。
● 绘制流程图
在第二节什么是程序算法中,我们留了一道习题,思考一个计算长方形面积的简单问题,这个问题我们可以用流程图来表示。
问题的解决可分为下面几个步骤:
1) 设置num1和num2两个变量,用于存储用户输入的长度和宽度,设置result变量用来存储num1和num2的乘积。变量用于存储值,程序可修改这个值,后面Java语法会详细讲解;
2) 接受用户输入的长度和宽度,并存储到num1和num2两个变量;
3) 判断num1和num2是否大于0,如果大于0,继续下一个步骤,否则提示用户重新输入长度和宽度;
4) 计算num1和num2的乘积,并将乘积结果存储到result变量;
5) 显示result变量的值到屏幕。
流程图可以采用多个工具软件进行绘制,下面所列是常用的绘制流程图的工具软件,建议使用Microsoft Visio软件绘制,本课程流程图采用Microsoft Visio软件绘制,流程图见图1-5。绘制步骤参见配套视频。
(1)Microsoft Visio 2010或更高版本
(2)在线流程图绘制工具processon
(3)PPT、Word等软件
图 1-5 计算面积流程图图 1-5 计算面积流程图使用图形表示算法是非常好的思路,绘制流程图的过程就是整理思路的过程。通过绘制流程图,可以对算法进行一次完整的梳理,及时发现问题,调整思路。流程图一定要有开始和结束;菱形框表示判断,判断必须有两个分支,或者满足条件或者不满足条件;平行四边形框表示输入输出框,用于输入数据和输出数据的处理;矩形框表示处理过程,用于数值计算和业务处理;引线表示流程的方向。
思考一个计算三个数中,求最大值的问题,要解决这个问题,需执行那些步骤?并绘制流程图。
要求:接受用户输入的三个数值,判断输入的三个数值不能为零,求出最大值,将计算结果显示到显示器上。
-
?
Java免费培训靠谱吗?谈谈我成为程序员的经历
尤兰达
展开
我是一名计算机辅助设计专业的本科毕业生,工作以后,同事们一直都叫我大学生。开始的时候我还认为可能是我还年轻,还有很多东西需要学习。在公司里做过一些模块之后,才发现同事们叫我大学生也是对我工作能力的一种肯定。其实,我是一个喜欢钻研技术的人,在大学的时候,时间没有像高中那么紧张,学习需要自己合理利用业余时间。所以,我在闲暇之余时常在网上找一些Java的免费培训资料,有比较系统的视频,甚至还有讲义和源码,这对巩固我的专业知识还是很有帮助的。
在大学里,专业课的第一门是C程序设计,这门课具有基础性;在学完C之后,我在暑假又预习了C++;在大三的时候我开始全面接触Java。当时在大学里也有这门课程,我在网上下载了一套系统的Java教学视频,是马士兵老师的。Java课程我学的比较细,基础的概念、语法逻辑基本通过自学可以学会。为了不影响我大学的期末考试,所以我也没有在细节上多费时间。在大三结束后的暑假,我开始看剩下的Java学习资料,包括一些源码和开源的项目。可能是学的比较深入了,很多地方抓不住重点,思路不够清晰。而大学里的Java课程已经结业,这成了摆在我面前的一道难题。
大四上半学期短暂而匆忙,进入到寒假,同学们有实习的、有考研的、还有准备出国留学的……而我还想把Java编程中的困惑解决掉。毕竟要想成为Java程序员,在毕业后就能很快找到收入理想的工作,这些难题是不可以逃避的。于是,在一位学长的推荐下,我来到尚学堂。这也算是一种求助吧,毕竟我希望能够在Java的道路上走得更远!
其实,刚来到这里内心还是比较纠结的。因为我一个堂堂计算机相关专业的本科生,也沦落到报班补习的地步?其实现在回想起来,我这样想也是正常的。既然决定要学习,主要还是自己有弥补知识缺陷和提升专业技能的诉求。所以还是要及时调整好心态,既来之则安之。这里的Java学习是分阶段的,在第一阶段先是JavaSE,也就是Java入门级。在JavaSE阶段中,上课的第一天老师教给我们写HelloWord! (这个我已经自己做过),不过跟上同学们复习一遍,也能查缺补漏。记得老师只是敲了这样一句代码public static void main(String args){System.out.println(“Hello Word!”)}就这么简单,在控制台就显示出了HelloWord。不过,记得当时我发现自己对这段程序底层的实现还不是特别清楚,于是当下我就请教了老师,老师也为我做了比较详细的解答。通过这件事情我还是觉得,再简单的内容也要谦虚谨慎地面对,不能大意和自满。
其实对我帮助和提高最大的阶段还是Java高级阶段。其实高级很辛苦,因为每天写代码会写到手抽筋,这个不重要,主要是积累代码量。其实高级就是简化我们中级的时候Servlet的操作。有的框架产生了好多代码,但是我觉还是高兴不起来,因为,要处理更复杂的配置文件了也就是XML格式的配置文件,一点配置不好就会抛很多异常。但是对我也是好事情,因为这部分是我在大学时候最困惑的部分。在老师的辅导下我终于弄懂里面的机制了。我非常感谢代课老师,他能为我们无私地分享他的工作经验,而且思路清晰条理,甚至还有大牛级的神操作。于是我逐渐学会了处理各种异常,找到了很多规律,从简单的异常处理到复杂的异常处理,最终意识到在这个过程中自己的能力也提升了。总之Java高级阶段的学习,让我战胜了很多困难,这也是我在这里学习最满意的地方。
分享了这么多,可以把我的经历做一个简单的总结了。我从网上Java免费培训资料开始,让我充实了大学的学习内容;接受专业的培训,解决了在专业课中出现的问题,同时积累了一些经验。当我把这些经验带到工作中,成长和进步就很快,时不时还能让同事刮目相看,可能这就是同事们称呼我大学生的原因吧。我能够在毕业之际就找到一份自己满意的工作,我也为我的努力感到骄傲。学无止境,天道酬勤!我会用我的技术点亮我人生的精彩!