java让代码更优雅,java好玩代码

做java软件工程师,怎样才能写出好的代码?

Java代码之于java程序员而言就是左膀右臂,java代码写的好的java程序员明显更是企业的欢迎,一个优秀的java程序员的考核标准之一也是看他的编程水平。

创新互联坚持“要么做到,要么别承诺”的工作理念,服务领域包括:成都网站设计、成都做网站、企业官网、英文网站、手机端网站、网站推广等服务,满足客户于互联网时代的裕安网站设计、移动媒体设计的需求,帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴!

其实有的java程序员java代码会受到大家的追捧,是因为他在写代码时注意的细节往往多于那些不怎么关注java代码编程细节的程序员,俗话说:“细节决定成败”,那么如何写出好的java代码呢?IT培训介绍一起来讨论下:

1.重视注释

有的java程序员在写代码时,从来没有想过要在java代码后加上相关的注释,甚至是上万行的代码也没有想过加上注释,这就存在很大的问题,不说你的代码会跟其他人分享讨论,就你自己回顾你是怎么写好这篇代码的,你也是半天无法理出头绪,这就为维护和修改等等工作添加了很大的麻烦。所以,要想写出好的java代码,一定从简短的java代码编写开始注重在java代码后面加上相应的注释,养成良好的习惯。

2.重视排版整洁

看很多java程序员的排版总觉得在欣赏一幅艺术品,但是看到一些java程序员的排版却总觉得无力吐槽。同样是编写代码,但是给人的视觉体验是相当的不同,当然好的java代码给人的享受也是美的,所以要想写出好的代码,一定要重视排版整洁。

3.注重命名规则

现在在一个团队开发中,都会提前定制一个统一的命名规则,这样利于提高工作效益。但是很多java程序员是缺乏这个意识的,每次敲代码,更喜欢按照自己惯常的方式老命名模块、函数,这样是方便了自己,但是忽视团队协作,所以在日常工作中,特别是团队工作中一定要重视命名规则。

4.养成备份习惯

备份的重要性不用小编强调,相必你也知道。但是有的java程序员就是没有养成这样的好习惯,每次敲完代码就不记得随手保存,每次等到除了事故,比如电脑出了故障,辛辛苦苦敲打的java代码没保存找不回来的情况下就开始懊恼,与其这样还不如在一开始就养成良好的备份习惯,这样也方便自己日后查找利用。

这个java方法有什么更优雅的写法吗

首先支持楼上的:

不过在业务上是要查询dict.getEnable()为可用的并且Code作为查询条件,那为什么不直接查询呢?

这样岂不更有效率:

Criteria 查询:

Criteria criteria = getCriteria(DictionaryItem.class);

criteria.add(Restrictions.eq("enable",true));

criteria.add(Restrictions.eq("dictionaryType",dictType));

return criteria.list();

HQL:

Query query = this.getSession().createQuery("form DictionaryItem di where di.enable = true and di.dictionaryType=:dictionaryType");

query.setLong("dictionaryType", dictType.getCode());

return query.list();

想楼主这样先把对象都查询出来,在内存中做数据帅选的做法不是很赞同,数据量小还可以,如果数据量大,有消耗内存又消耗时间;

做优化不是拿时间换空间,就是拿空间换时间。你这样岂不是两头都没有~

java中的设计模式有什么作用啊?

你好,java的设计模式共有23种!都是表示类与类之间的构架关系,也就是表示对象的逻辑关系!

比较常用的有简单工厂,抽象工厂,单例模式,装饰模式,适配器模式等等,说白了模式就是前人经过大量的实践,总结出来的优化的对象关系!

你使用这些优秀的模式去搭建你的程序 无论从效率上还是可读性上,都给人一种很舒服的感觉。

如何写出优雅Java编程

一、不要使用魔法数字,尽量定义枚举、常量、宏:

我常常见到表示各种状态的数字,0,1,2....,我真的不知道这表示什么含义,如果

你在不在文档中说明的话,这个东东过几天连你自己都不知道个一二三了。

二、命名要具有描述力,尽量使用全名而不是自创的缩写,除非地球人都这么用这个缩写:

我常常看到一些自创的缩写,这个缩写或许只有你自己知道,类名,方法名,参数名

尤其要有好的描述里,局部变量尚可容忍。我宁可容忍超过40个字符的命令,也不愿意

看到只有一两个字母的命名,当然迭代用的i,j除外。当然命名不要太长,太长说明你的类和

方法要做的事情太多,请你拆分出更多细粒度功能单一的类和方法。

三、同一类东东命名方式尽可能统一,比如类名使用大写字母开头的单词,变量使用

下划线分割开来的小写字母单词,常量使用下滑线分割的开来的大写字母单词。不要

交替使用。

四、函数、类功能尽可能单一,不要试图写一个万能/超级函数或者类。

一个类和方法要有单一的职责,这样的类和方法只做一件事,并且容易把他做好。

1、不要试图写一个强大无比的方法。

我常常看到一些试图写的多么“精妙”无比多么“强大”的函数,事实上不是什么精妙,而是

代码的臭味道。精妙强大无比万能的方法往往你耗费大量精力去设计算法,试图覆盖现在的各

种可能,而无法面对将来新的需求,随着新的需求,你的这个精妙的方法需要的修改并且改起来

极其痛苦。在一次次的痛苦与精妙的演化中,你的方法越来越复杂,并且每一次修改你都会面

临影响以前功能的风险。这个方法使用者需要小心的处理你的精妙之处,如果没有精妙传递好参

数,那么这个方法再也不精妙了,而是直接废掉了。

KISS(keep it simple and stupid)原理就是这个道理,你要使你的代码尽可能简单,让人

看到有一目了然的清爽,而不是因为设计了一个精妙无比的万能方法而沾沾自喜。这里的简单不是

简洁的代名字。有时候简洁是那种传说的“精妙”的代码。

2、不要写做多件事情的方法和类,你做一件事情,你就写一个对应的方法,不要试图通过参数来判定各种情况,然后做事情,并且做的事情和你方法描述的不一致。当你发现你的方法名字想不出来好的名字了,或者要加or和and了,那么请你拆分出更多单一的方法。

不要举一些linux完成多种功能系统调用,这是被迫的,因为系统调用的数量是有限制的,它只有有限的空间来描述系统调用号和系统调用的映射表,不要在应用程序开发中效仿而误以为优雅强大。我最恶心根据参数,然后一大堆的if..else 和switch..case判断。

五、不要修改已有的类和方法而是扩展它。

这是程序设计的一个重要原则,开闭原则,在面向对象的语言中尤为重要。在面向过程中主要表现在,不要在一个函数要应对和这个函数相似的一个需求了,就在这个加个if,来修改这个方法,试图重用和避免重复。而是要把公用的部分抽出来成一个小的功能函数,然后增加一个应对新的类似这个需求的处理方法。在面向对象中,例如使用策略模式、访问者模式、Extend Object模式。

六、不要重复你自己(DRY):

程序最怕的是copy,paste,到处是重复的代码。copy,paste经常被误以为快速完成需要用的功能的高效方式而被到处使用。你每重复一次,你就得负责保持他们的一致性,你就得在一处增加新的功能时,你就的把这个的功能加到其他地方。还在我刚会写代码的时候去了一个小公司,他们的代码到处是copy,paste的痕迹,当要在现有的功能增加审计功能是,他们开始下命令了,每个人加几行代码来做审计,真不知道那么多人写的审计版本,分散到那么多处,这个审计功能是否可信有用。

避免DRY的方法就是抽象,分离变化。不管是面向对象还是面向过程,分离变化并抽象之是最主要的设计原则。设计模式中的模板方法,我们常用的回调都是我们常用的方法。

我发现越是提供更多回调处理的语言和框架,就越具有灵活性和易用性。ruby语言之所以有如此的威力,主要是因为它提供了更多的回调处理。它可以在动态的给一个类增加方法,这样可以在超类中定义增加方法的方法,然后再子类调用,子类就具有无比的能力。它的block提供了强大的回调机制,我只要不知道如何处理了我就yield出来,method missing机制更是神秘无比,你可以写出像find_by_name_and_age,2.days.ago这样像自然语言一样易读的代码。

七、不要跨越边界,在适合的地方写代码。

在分层的架构中,不要跨越层的边界。例如web开发的三层架构:

数据访问层(DAO)、业务层(Service)、表现层。

不要在业务层裸写SQL来做事情,不要在业务层掺和进来表现层的东东,不要在表现层/控制器中写业务的东东。既然已经分层了,那么就要好好的遵守它,如果到处跨越边界的话,那么和不分层没有什么区别,使得每一层都不伦不类。例如你应该在业务层进行事务管理,而你的控制器到处是业务代码,那将无法控制。如果你的业务层到处是SQL,我不知道你的DAO存在的意义了。

八、分层的web架构:

DAO层最好按照模型来划分dao类,如果业务很简单,也可以将相关的模型合并为一个DAO。

Service层,不要按照DAO和Service一一对应的方式划分,而是要按照业务的类别和实际情况来划分。事实上Service层通常是用来处理涉及到多个模型的业务,而涉及到一个模型的业务,常常被放在模型中,这是一种自然而更面向对象的设计方法。只有数据的模型被称为贫血型模型,这种模型被认为是对面向对象的一种背离,而在模型中放置专有的业务方法,不仅有利于公用,而且模型更具有描述力。

九、关于MVC:

MVC是一种松耦合的设计方案,最容易误用的就是控制器(c)。控制器只负责调用业务方法,准备好数据供View去展现。而不要把业务和如何展示的东东放在里面。我常常看到有人在控制器中拼html片段和写一些业务相关的代码。

十、顺便说一下异常的使用。

如果你是使用语言支持异常机制,那么尽可能的使用异常机制和定义好与自己业务相关的异常,而不是通过返回值表示正确和错误。如果你使用的语言支持异常机制,请不要写类linux下c似的代码形式,每写一个函数,我就写一个判断返回值调用是否成功,严重分离了我对核心业务的关注。异常提供了优雅的处理错误的方法。

如何写出更好的Java代码

1. 优雅需要付出代价。

从短期利益来看,对某个问题提出优雅的解决方法,似乎可能花你更多的时间。但当它终于能够正确执行并可轻易套用于新案例中,不需要花上数以时计,甚至以天计或以月计的辛苦代价时,你会看得到先前所花功夫的回报(即使没有人可以衡量这一点)。这不仅给你一个可更容易开发和调试的程序,也更易于理解和维护。这正是它在金钱上的价值所在。这一点有赖某种人生经验才能够了解,因为当你努力让某一段程序代码变得比较优雅时,你并不是处于一种具生产力的状态下。但是,请抗拒那些催促你赶工的人们,因为那么做只会减缓你的速度罢了。

2. 先求能动,再求快。

即使你已确定某段程序代码极为重要,而且是系统的重要瓶颈,这个准则依然成立。尽可能简化设计,让系统能够先正确动作。如果程序的执行不够快,再量测其效能。几乎你总是会发现,你所认为的”瓶颈”其实都不是问题所在。把你的时间花在刀口上吧。

3. 记住”各个击破”的原理。

如果你所探讨的问题过于混杂,试着想像该问题的基本动作会是什么,并假设这一小块东西能够神奇地处理掉最难的部分。这”一小块”东西其实就是对象–请撰写运用该对象的程序代码,然后检视对象,并将其中困难的部分再包装成其他对象,依此类推。

4. 区分class开发者和class使用者(使用端程序员)。

Class 使用者扮演着”客户”角色,不需要(也不知道)class的底层运作方式。Class开发者必须是class设计专家,并撰写class,使它能够尽可能被大多数新手程序员所用,而且在程序中能够稳当执行。一套程序库只有在具备通透性的情况下,使用起来才会容易。

5.当你撰写class时,试着给予明了易懂的名称,减少不必要的注解。

你给客户端程序员的接口,应该保持概念上的单纯性。不了这个目的,当函数的重载(overloading)适合制作出直觉、易用的接口时,请善加使用。

6. 也必你的分析和设计必须让系统中的classes保持最少,须让其Public interfaces保持最少,以及让这些classes和其他classes之间的关联性( 尤其是base classes)保持最少。

如果你的设计所得结果更甚于此,请问问自己,是否其中每一样东西在整个程序生命期中都饶富价值?如果并非如此,那么,维护它们会使你付出代价。开发团队的成员都有不维护”无益于生产力提升”的任何东西的倾向;这是许多设计方法无法解释的现象。

7. 让所有东西尽量自动化。先撰写测试用的程序代码(在你撰写class之前),并让它和class结合在一起。请使用makefile或类似工具,自动进行测试动作。

通过这种方式,只要执行测试程序,所有的程序变动就可以自动获得验证,而且可以立即发现错误。由于你知道的测试架构所具备的安全性,所以当你发现新的需求时,你会更勇于进行全面修改。请记住,程序语言最大的改进,是来自型别检查、异常处理等机制所赋予的内置测试动作。但这些功能只能协助你到达某种程度。开发一个稳固系统时,你得自己验证自己的classes或程序的性质。

8. 在你撰写class之前先写测试码,以便验证你的class 是否设计完备。如果你无法撰写测试码,你便无法知道你的class 的可能长相。撰写测试码通常能够显现出额外的特性(features)或限制 ( constraints)__它们并不一定总是能够在分析和设计过程中出现。测试码也可做为展示class 用法的示例程序。

9. 所有软件设计上的问题,都可以通过”引入额外的概念性间接层(conceptual indirection)”加以简化。这个软件工程上的基础法则是抽象化概念的根据,而抽象化概念正是面向对象程序设计的主要性质。

10. 间接层(indirection)应该要有意义(和准则-9致)。

这里所指的意义可以像”将共用程序代码置于惟一函数”这么简单。如果你加入的间接层(或抽象化、或封装等等)不具意义,它可能就和没有适当的间接层一样糟糕。

11. 让class尽可能微小而无法切割(atomic)。

赋予每个class单一而清楚的用途。如果你的classes或你的系统成长得过于复杂,请将复杂的classes切割成比较简单的几个classes。最明显的一个判断指针就是class的大小:如果它很大,那么它工作量过多的机会就可能很高,那就应该被切割。重新设计class的建议线索是:

1) 复杂的switch语句:请考虑运用多态(Polymorphism)。

2) 许多函数各自处理类型极为不同的动作:请考虑切割为多个不同的(classes)。

12. 小心冗长的引数列(argument lists)。

冗长的引数列会使函数的调用动作不易撰写、阅读、维护。你应该试着将函数搬移到更适当的class中,并尽量以对象为引数。

13. 不要一再重复。

如果某段程序代码不断出现于许多derived class函数中,请将该段程序代码置于某个base class 函数内,然后在derived class函数中调用。这么做不仅可以省下程序代码空间,也可以让修改该段程序代码动作更易于进行。有时候找出此种共通程序代码还可以为接口增加实用功能。

14. 小心switch语句或成串的if-else 子句。

通常这种情况代表所谓的”type-check coding”。也就是说究竟会执行哪一段程序代码,乃是依据某种型别信息来做抉择(最初,确切型别可能不十分明显)。你通常可以使用继承和多态来取代此类程序代码;Polymorphical method (多态函数)的调用会自动执行此类型别检验,并提供更可靠更容易的扩充性。

15. 从设计观点来看,请找出变动的事物,并使它和不变的事物分离。

也就是说,找出系统中可能被你改变的元素,将它们封装于classes中。你可以在《Thinking in Patterns with Java》(可免费下载于 www. BruceEckel. Com)大量学习到这种观念。

16. 不要利用subclassing来扩充基础功能。

如果某个接口元素对class而言极重要,它应该被放在base class 里头,而不是直到衍生(derivation)时才被加入。如果你在继承过程中加入了函数,或许你应该重新思考整个设计。

17. 少就是多。

从class 的最小接口开始妨展,尽可能在解决问题的前提下让它保持既小又单纯。不要预先考量你的class被使用的所有可能方式。一旦class被实际运用,你自然会知道你得如何扩充接口。不过,一旦class被使用后,你就无法在不影响客户程序代码的情况下缩减其接口。如果你要加入更多函数倒是没有问题–不会影响既有的客户程序代码,它们只需重新编译即可。但即使新函数取代了旧函数的功能,也请你保留既有接口。如果你得通过”加入更多引数”的方式来扩充既有函数的接口,请你以新引数写出一个重载化的函数;通过 这种方式就不会影响既有函数的任何客户了。

18. 大声念出你的classes,确认它们符合逻辑。

请base class和derived class 之间的关系是”is-a”(是一种),让class和成员对象之间的关系是”has-a”(有一个)。

19. 当你犹豫不决于继承(inheritance)或合成(组合,composition)时,请你问问自己,是否需要向上转型(upcast)为基础型别。

如果不需要,请优先选择合成(也就是是使用成员对象)。这种作法可以消除”过多基础型别”。如果你采用继承,使用者会认为他们应该可以向上转型。

20. 运用数据成员来表示数值的变化,运用经过覆写的函数(overrided method)来代表行为的变化 。

也就是说,如果你找到了某个 class, 带有一些状态变量,而其函数会依据这些变量值切换不同的行为,那么你或许就应该重新设计,在subclasses 和覆写后的函数(overrided methods)中展现行为止的差异。

21. 小心重载(overloading)。

函数不应该依据引数值条件式地选择执行某一段程序代码。这种情况下你应该撰写两个或更多个重载函数(overloaded methods)

22. 使用异常体系(exception hierarchies)

最好是从Java标准异常体系中衍生特定的classes, 那么,捕捉异常的人便可以捕捉特定异常,之后才捕捉基本异常。如果你加入新的衍生异常,原有的客户端程序仍能通过其基础型别来捕捉它。

23. 有时候简单的聚合(aggregation)就够了。

飞机上的”旅客舒适系统”包括数个分离的元素:座椅、空调、视讯设备等等,你会需要在飞机上产生许多这样的东西。你会将它们声明为Private成员并开发出一个全新的接口吗?不会的,在这个例子中,元素也是Public接口的一部分,所以仍然是安全的。当然啦,简单聚合并不是一个常被运用的解法,但有时候的确是。

24. 试着从客户程序员和程序维护的角度思考。

你的class应该设计得尽可能容易使用。你应该预先考量可能性有的变动,并针对这些 可能的变动进行设计,使这些变动日后可轻易完成。

25. 小心”巨大对象并发症”。

这往往是刚踏OOP领域的过程式(procedural)程序员的一个苦恼,因为他们往往最终还是写出一个过程式程序,并将它们摆放到一个或两个巨大对象中。注意,除了application framework (应用程序框架,译注:一种很特殊的、大型OO程序库,帮你架构程序本体)之外,对象代表的是程序中的观念,而不是程序本身。

26. 如果你得用某种丑陋的方式来达成某个动作,请将丑陋的部分局限在某个class里头。

27. 如果你得用某种不可移植方式来达成某个动作,请将它抽象化并局限于某个class里头。这样一个”额外间接层”能够防止不可移植的部分扩散到整个程序。这种作法的具体呈现便是Bridge设计模式(design pattern)。

28. 对象不应仅仅只用来持有数据。

对象也应该具有定义明确界限清楚的行为。有时候使用”数据对象”是适当的,但只有在通用形容器不适用时,才适合刻意以数据对象来包装、传输一群数据项。

29. 欲从既有的classes身上产生新的classes时,请以组合(composition)为优先考量。

你应该只在必要时才使用继承。如果在组合适用之处你却选择了继承,你的设计就渗杂了非必要的复杂性。

30. 运用继承和函数覆写机制来展现行为上的差异,运用fields(数据成员)来展现状态上的差异。

这句话的极端例子,就是继承出不同的classes表现各种不同的颜色,而不使用”color”field.

31. 当心变异性(variance)。

语意相异的两个对象拥有相同的动作(或说责任)是可能的。OO世界中存在着一种天生的引诱,让人想要从某个class继承出另一个subclass,为的是获得继承带来的福利。这便是所谓”变异性”。但是,没有任何正当理由足以让我们强迫制造出某个其实并不存在的superclass/subclass关系。比较好的解决方式是写出一个共用的base class,它为两个derived classes制作出共用接口–这种方式会耗用更多空间,但你可以如你所盼望地从继承机制获得好处,而且或许能够在设计上获得重大发现。

32. 注意继承上的限制。

最清晰易懂的设计是将功能加到继承得来的class里头;继承过程中拿掉旧功能(而非增加新功能)则是一种可疑的设计。不过,规则可以打破。如果你所处理的是旧有的class程序库,那么在某个class的subclass限制功能,可能会比重新制定整个结构(俾使新class得以良好地相称于旧 class)有效率得多。

33. 使用设计模式(design patterns)来减少”赤裸裸无加掩饰的机能(naked functionality)”。

举个例子,如果你的class只应该产出惟一一个对象,那么请不要以加思索毫无设计的手法来完成它,然后撰写”只该产生一份对象”这样的注解就拍拍屁股走人。请将它包装成singleton(译注:一个有名的设计模式,可译为”单件”)。如果主程序中有多而混乱的”用以产生对象”的程序代码,请找出类似 factory method这样的生成模式(creational patterns),使价钱可用以封装生成动作减少”赤裸裸无加掩饰的机能”(naked functionality)不仅可以让你的程序更易理解和维护,也可以阻止出于好意却带来意外的维护者。

34. 当心”因分析而导致的瘫痪(analysis paralysis)”。

请记住,你往往必须在获得所有信息之前让项目继续前进。而且理解未知部分的最好也最快的方式,通常就是实际前进一步而不只是纸上谈兵。除非找到解决办法,否则无法知道解决办法。Java拥有内置的防火墙,请让它们发挥作用。你在单一class或一组classes中所犯的错误,并不会伤害整个系统的完整性。

35. 当你认为你已经获得一份优秀的分析、设计或实现时,请试着加以演练。

将团队以外的某些人带进来-他不必非得是个顾问不可,他可以是公司其他团队的成员。请那个人以新鲜的姿态审视你们的成果,这样可以在尚可轻易修改的阶段找出问题,其收获会比因演练而付出的时间和金钱代价来得高。实现 (Implementation)

36. 一般来说,请遵守Sun的程序编写习惯。

价钱可以在以下网址找到相关文档:java.sun.com/docs/codeconv/idex.html。本书尽可能遵守这些习惯。众多Java程序员看到的程序代码,都有是由这些习惯构成的。如果你固执地停留在过去的编写风格中,你的(程序代码)读者会比较辛苦。不论你决定采用什么编写习惯,请在整个程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一个用来重排Java程序的免费工具。

37. 无论使用何种编写风格,如果你的团队(或整个公司,那就更好了)能够加以标准化,那么的确会带来显著效果。这代表每个人都可以在其他人不遵守编写风格修改其作品,这是个公平的游戏。标准化的价值在于,分析程序代码时所花的脑力较小,因而可以专心于程序代码的实质意义。

38. 遵守标准的大小写规范。

将 class名称的第一个字母应为大写。数据成员、函数、对象(references)的第一个字母应为小写。所有识别名称的每个字都应该连在一块儿,所有非首字的第一个字母都应该大写。例如: ThisIsAClassName thisIsAMethodOrFieldName 如果你在static final 基本型别的定义处指定了常量初始式(constant initializers),那么该识别名称应该全为大写,代表一个编译期常量。 Packages是个特例,其名称皆为小写,即使非首字的字母亦是如此。域名(org, net, edu 等等)皆应为小写。(这是Java 1.1迁移至Java 2时的一项改变) 。

39、不要自己发明”装饰用的”Private数据成员名称。

通常这种的形式是在最前端加上底线和其他字符,匈牙利命名法(Hungarian notation)是其中最差的示范。在这种命名法中,你得加入额外字符来表示数据的型别、用途、位置等等。仿佛你用的是汇编语言(assembly language)而编译器没有提供任何协肋似的。这样的命名方式容易让人混淆又难以阅读,也不易推行和维护。就让classes和packages来进行”名称上的范

围制定(name scoping)”吧。

40、当你拟定通用性的class时,请遵守正规形式(canonical form)。

包括equals( )、hashCode( )、clone( ) ( 实现出Cloneable),并实现出Comparable和Serialiable等等。

用Java 8 增加的 Stream API 能实现哪些优雅的算法

Java 8引入了全新的Stream API。这里的Stream和I/O流不同,它更像具有Iterable的集合类,但行为和集合类又有所不同。

Stream API引入的目的在于弥补Java函数式编程的缺陷。对于很多支持函数式编程的语言,map()、reduce()基本上都内置到语言的标准库中了,不过,Java 8的Stream API总体来讲仍然是非常完善和强大,足以用很少的代码完成许多复杂的功能。

创建一个Stream有很多方法,最简单的方法是把一个Collection变成Stream。我们来看最基本的几个操作:

public static void main(String[] args) {

ListInteger numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

StreamInteger stream = numbers.stream();

stream.filter((x) - {

return x % 2 == 0;

}).map((x) - {

return x * x;

}).forEach(System.out::println);

}

集合类新增的stream()方法用于把一个集合变成Stream,然后,通过filter()、map()等实现Stream的变换。Stream还有一个forEach()来完成每个元素的迭代。

为什么不在集合类实现这些操作,而是定义了全新的Stream API?Oracle官方给出了几个重要原因:

一是集合类持有的所有元素都是存储在内存中的,非常巨大的集合类会占用大量的内存,而Stream的元素却是在访问的时候才被计算出来,这种“延迟计算”的特性有点类似Clojure的lazy-seq,占用内存很少。

二是集合类的迭代逻辑是调用者负责,通常是for循环,而Stream的迭代是隐含在对Stream的各种操作中,例如map()。

要理解“延迟计算”,不妨创建一个无穷大小的Stream。

如果要表示自然数集合,显然用集合类是不可能实现的,因为自然数有无穷多个。但是Stream可以做到。

自然数集合的规则非常简单,每个元素都是前一个元素的值+1,因此,自然数发生器用代码实现如下:

class NaturalSupplier implements SupplierLong {

long value = 0;

public Long get() {

this.value = this.value + 1;

return this.value;

}

}

反复调用get(),将得到一个无穷数列,利用这个Supplier,可以创建一个无穷的Stream:

public static void main(String[] args) {

StreamLong natural = Stream.generate(new NaturalSupplier());

natural.map((x) - {

return x * x;

}).limit(10).forEach(System.out::println);

}

对这个Stream做任何map()、filter()等操作都是完全可以的,这说明Stream API对Stream进行转换并生成一个新的Stream并非实时计算,而是做了延迟计算。

当然,对这个无穷的Stream不能直接调用forEach(),这样会无限打印下去。但是我们可以利用limit()变换,把这个无穷Stream变换为有限的Stream。

利用Stream API,可以设计更加简单的数据接口。例如,生成斐波那契数列,完全可以用一个无穷流表示(受限Java的long型大小,可以改为BigInteger):

class FibonacciSupplier implements SupplierLong {

long a = 0;

long b = 1;

@Override

public Long get() {

long x = a + b;

a = b;

b = x;

return a;

}

}

public class FibonacciStream {

public static void main(String[] args) {

StreamLong fibonacci = Stream.generate(new FibonacciSupplier());

fibonacci.limit(10).forEach(System.out::println);

}

}

如果想取得数列的前10项,用limit(10),如果想取得数列的第20~30项,用:

ListLong list = fibonacci.skip(20).limit(10).collect(Collectors.toList());

最后通过collect()方法把Stream变为List。该List存储的所有元素就已经是计算出的确定的元素了。

用Stream表示Fibonacci数列,其接口比任何其他接口定义都要来得简单灵活并且高效。


分享题目:java让代码更优雅,java好玩代码
分享链接:http://myzitong.com/article/dsipddi.html