java predicate 是什么，java集合类哪个函数可以
这篇文章给大家聊聊关于java predicate 是什么，以及java集合类哪个函数可以对应的知识点，希望对各位有所帮助，不要忘了收藏本站哦。
想要java软件安装包,有哪位朋友有吗
软件介绍
java se development kit 9 64位，简称为java9 64位，是由oracle公司官方推出的一款Java语言的软件开发工具包，面向Java开发人员，包括一个完整的JRE以及用于开发、调试和监视Java应用的工具，是整个Java的核心，其中包括了Java运行环境（Java Runtime EnvirnmeJava开发工具和Java基础类库源代码）。java se 9是Java Platform的新更新，此版本包括期待已久的新特性，如Java Platform模块化、性能提升、支持新标准以及许多其他改进。其中Java Platform模块化是java se development kit 9的最大特色，在引入了模块系统之后，JDK被重新组织成 94个模块。Java应用可以通过新增的jlink工具，创建出只包含所依赖的JDK模块的自定义运行时镜像，这样可以极大的减少Java 9运行时环境的大小，使得JDK可以在更小的设备中使用。
所需工具：点击下载java se development kit 9
java se development kit 9 64位新特性
1、Java平台级模块系统
Java 9的定义功能是一套全新的模块系统。当代码库越来越大，创建复杂，盘根错节的“意大利面条式代码”的几率呈指数级的增长。这时候就得面对两个基础的问题:很难真正地对代码进行封装,而系统并没有对不同部分（也就是 JAR文件）之间的依赖关系有个明确的概念。每一个公共类都可以被类路径之下任何其它的公共类所访问到,这样就会导致无意中使用了并不想被公开访问的 API。此外，类路径本身也存在问题:你怎么知晓所有需要的 JAR都已经有了,或者是不是会有重复的项呢?模块系统把这俩个问题都给解决了。
模块化的 JAR文件都包含一个额外的模块描述器。在这个模块描述器中,对其它模块的依赖是通过“requires”来表示的。另外,“exports”语句控制着哪些包是可以被其它模块访问到的。所有不被导出的包默认都封装在模块的里面。如下是一个模块描述器的示例，存在于“module-info.java”文件中:
请注意，两个模块都包含封装的包，因为它们没有被导出（使用橙色盾牌可视化）。没有人会偶然地使用来自这些包中的类。Java平台本身也使用自己的模块系统进行了模块化。通过封装 JDK的内部类，平台更安全，持续改进也更容易。
当启动一个模块化应用时， JVM会验证是否所有的模块都能使用，这基于 `requires`语句——比脆弱的类路径迈进了一大步。模块允许你更好地强制结构化封装你的应用并明确依赖。你可以在这个课程中学习更多关于 Java 9中模块工作的信息。
2. Linking
当你使用具有显式依赖关系的模块和模块化的 JDK时，新的可能性出现了。你的应用程序模块现在将声明其对其他应用程序模块的依赖以及对其所使用的 JDK模块的依赖。为什么不使用这些信息创建一个最小的运行时环境，其中只包含运行应用程序所需的那些模块呢？这可以通过 Java 9中的新的 jlink工具实现。你可以创建针对应用程序进行优化的最小运行时映像而不需要使用完全加载 JDK安装版本。
3. JShell:交互式 Java REPL
许多语言已经具有交互式编程环境，Java现在加入了这个俱乐部。您可以从控制台启动 jshell，并直接启动输入和执行 Java代码。 jshell的即时反馈使它成为探索 API和尝试语言特性的好工具。
测试一个 Java正则表达式是一个很好的说明 jshell如何使您的生活更轻松的例子。交互式 shell还可以提供良好的教学环境以及提高生产力，您可以在此了解更多信息。在教人们如何编写 Java的过程中，不再需要解释“public static void main（String [] args）”这句废话。
4.改进的 Javadoc
有时一些小事情可以带来很大的不同。你是否就像我一样在一直使用 Google来查找正确的 Javadoc页面呢？这不再需要了。Javadoc现在支持在 API文档中的进行搜索。另外，Javadoc的输出现在符合兼容 HTML5标准。此外，你会注意到，每个 Javadoc页面都包含有关 JDK模块类或接口来源的信息。
5.集合工厂方法
通常，您希望在代码中创建一个集合（例如，List或 Set），并直接用一些元素填充它。实例化集合，几个“add”调用，使得代码重复。 Java 9，添加了几种集合工厂方法：
除了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致“UnsupportedOperationException”。
6.改进的 Stream API
长期以来，Stream API都是 Java标准库最好的改进之一。通过这套 API可以在集合上建立用于转换的申明管道。在 Java 9中它会变得更好。Stream接口中添加了 4个新的方法：
dropWhile, takeWhile, ofNullable。还有个 iterate方法的新重载方法，可以让你提供一个 Predicate(判断条件)来指定什么时候结束迭代：
第二个参数是一个 Lambda，它会在当前 IntStream中的元素到达 100的时候返回 true。因此这个简单的示例是向控制台打印 1到 99。
除了对 Stream本身的扩展，Optional和 Stream之间的结合也得到了改进。现在可以通过 Optional的新方法 `stram`将一个 Optional对象转换为一个(可能是空的) Stream对象：
在组合复杂的 Stream管道时，将 Optional转换为 Stream非常有用。
7.私有接口方法
Java9为我们带来了接口的默认方法。接口现在也可以包含行为，而不仅仅是方法签名。但是，如果在接口上有几个默认方法，代码几乎相同，会发生什么情况？通常，您将重构这些方法，调用一个可复用的私有方法。但默认方法不能是私有的。将复用代码创建为一个默认方法不是一个解决方案，因为该辅助方法会成为公共API的一部分。使用 Java 9，您可以向接口添加私有辅助方法来解决此问题：
如果您使用默认方法开发 API，那么私有接口方法可能有助于构建其实现。
8. HTTP/2
Java 9中有新的方式来处理 HTTP调用。这个迟到的特性用于代替老旧的
`HttpURLConnection` API，并提供对 WebSocket和 HTTP/2的支持。注意：新的
HttpClient API在 Java 9中以所谓的孵化器模块交付。也就是说，这套 API不能保证 100%完成。
9.多版本兼容 JAR
我们最后要来着重介绍的这个特性对于库的维护者而言是个特别好的消息。当一个新版本的 Java出现的时候，你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的 Java版本(许多情况下就是 Java 6或者 7)。这实际上意味着未来的很长一段时间，你都不能在库中运用 Java 9所提供的新特性。
10、支持Unicode 8.0。JDK 8支持Unicode 6.2。
Unicode的6.3，7.0和8.0标准相结合引入10555个字符，29个脚本，和42块，所有这些在JDK 9支撑。
java9 64位安装教程：
1、软件下载解压完成后，点击jdk-9_windows-x64打开软件包，等待片刻后点击下一步开始安装软件。
2、选择安装组件和安装路径。
3、确定软件安装目录。
4、java9 64位安装完成。
更新日志
java se development kit 9是一个主要的功能版本，以下总结了Java SE 9和JDK 9（Oracle的Java SE 9的实现）中的功能和增强功能。
A、关键变化：
一、Java平台模块系统
介绍一种新的Java编程组件，这个模块是一个有名的，自描述的代码和数据集合。这个模块系统：
1、引入了一个新的可选阶段，即链接时间，该时间在编译时间和运行时间之间，在此期间可以将一组模块组装并优化为自定义运行时映像;看到jlink在工具Java平台，标准版工具参考。
2、将选项添加到工具javac，jlink以及java可以指定模块路径的位置，这些模块路径定位了模块的定义。
3、介绍模块化的JAR文件，它是一个JAR文件，module-info.class在其根目录中有一个文件。
4、介绍JMOD格式，除了可以包含本地代码和配置文件之外，它是与JAR类似的打包格式;看到这个jmod工具。
二、JEP 223：新的版本字符串计划
提供简化的版本字符串格式，有助于清楚地区分主要，次要，安全和修补程序更新版本。
B、新增功能
1、使用安装程序的用户界面启用或禁用Web部署
提供在安装程序的欢迎页面中启用或禁用Web部署的选项。要启用Web部署，请在“欢迎”页面中选择“自定义安装”，单击“安装”，然后选中“在浏览器中启用Java内容”复选框。
2、JEP 222：jshell：Java Shell（Read-Eval-Print Loop）
将Read-Eval-Print Loop（REPL）功能添加到Java平台。
该jshell工具提供了一个用于评估Java编程语言的声明，语句和表达式的交互式命令行界面。
它有助于对编码选项进行原型设计和探索，并立即得到结果和反馈。即时反馈与以表达式开始的能力相结合对教育非常有用，无论是学习Java语言，还是学习新的API或语言功能。
3、JEP 228：添加更多的诊断命令
定义其他诊断命令以提高诊断Hotspot和JDK问题的能力。
3、JEP 231：删除启动时JRE版本选择
删除了在启动时请求不是JRE版本的JRE版本的功能。
4、JEP 238：多版本JAR文件
扩展JAR文件格式，使多个Java特定版本的类文件能够共存于一个归档中。
5、JEP 240：删除JVM TI hprof代理
hprof从JDK中删除代理。该hprof代理程序被编写为JVM工具接口的演示代码，并不打算成为生产工具。
6、JEP 241：删除jhat工具
jhat从JDK中删除该工具。
7、JEP 245：验证JVM命令行标志参数
验证所有数字JVM命令行标志的参数以避免失败，如果发现它们是无效的，则会显示相应的错误消息。
我的世界java版22w15a更新内容介绍
我的世界java版在近日更新了22w15a版本，部分玩家可能不清楚更新了什么，下面一起来看看我的世界java版22w15a更新内容介绍吧。
我的世界java版22w15a更新内容介绍
NEWS
MINECRAFT SNAPSHOT 22W15A
Minecraft快照 22W15A
A Minecraft Java Snapshot
一个Minecraft Java版快照
Let me tell you a little story about hubris. Well, not so much a story as a lament. Because some of you have been thinking that the warden was a little too easy. I won’t name names, but I know you’re out there. Why else would we be adding ranged attacks for this already terrifying mob? Was the sniffing not enough? When will it end? Not today, apparently.
让我告诉你一个关于傲慢的小故事。好吧，与其说是一个故事，不如说是一声哀叹。因为你们中的一些人一直认为，(对付)监守者有点太简单了。我这里就不点名了，但我知道这样的人大有人在。否则我们为什么要为这个已经很恐怖的怪物增加远程攻击?仅仅是靠嗅觉还不够吗?这啥时候会结束?显然不是今天。
Enjoy a new terrifying warden along with more advancements and technical changes.
享受一个新的可怕的监守者吧，以及更多的改进和技术性改动。
NEW FEATURES IN 22W15A
22W15A的新增特性
Added advancement“When the Squad Hops into Town” for getting each Frog variant on a Lead
添加进度“When the Squad Hops into Town”当你使用拴绳牵引每种青蛙的变种时获得
Added advancement“Sneak 100” for sneaking near a Sculk Sensor or Warden to prevent it hearing you
添加进度“Sneak 100”当你在一个幽匿传感体或者监守者附近潜行以防它感知到你时获得
Added a new ranged attack to the Warden
为监守者添加了一种新的远程攻击
WARDEN RANGED ATTACK
监守者远程攻击
Building up high, hiding behind walls or being out of range of their powerful melee attack will cause Wardens to switch to their ranged attack
向高处搭方块，躲在墙后，或者保持在他们强大的近战攻击范围之外，都会导致监守者转而使用远程攻击。
Their rib cages will open up to shriek a sonically charged ranged attack that can penetrate walls
它们的胸腔会张开，尖啸着发出远程的冲击波攻击，可以穿透墙壁。
CHANGES IN 22W15A
22W15A的修改内容
Added Darkness effect to“How Did We Get Here?” advancement
将黑暗效果添加至“为什么会变成这样呢?”进度的要求中
Allays have a natural health regen of 2 health per second
悦灵现在拥有自然的生命恢复效果，每秒恢复2点血量
The main menu background now shows a Wild Update panorama
主菜单背景现在显示一个荒野更新全景图
Mud generates all the way from the surface down to stone in Mangrove Swamps
泥巴在红树林沼泽中从地表一直生成至石头上方
Tall Mangroves are far more common than Short Mangroves in Mangrove Swamps
在红树林沼泽中，高大的红树远比矮小的红树更常见。
Moss Carpet generates on top of Mangrove Tree’s roots
苔藓地毯生成于红树根的上方
The Wandering Trader will now sometimes offer Propagules for sale
流浪商人现在有时候会出售红树胎生苗
A previous change to Noteblocks that only Wool and Wool Carpets would block the sounds has been reverted
之前对音符盒的改动，即只有羊毛和羊毛地毯可以阻挡声音的问题现在已经恢复。
Wardens can now sniff you from further away
监守者现在可以在更远的距离闻到你
The vertical range Wardens get angry at a target while sniffing is now 20 blocks instead of 6 blocks
监守者在嗅探时对目标产生仇恨的垂直范围现在是20米高，而不是6米
CHANGES TO VIBRATIONS
振动的改动
Carpets, like Wool blocks, will now dampen the vibrations caused by their placing, breaking or dropping as items
现在地毯和羊毛方块一样，将减弱因其放置、破坏或掉落成为物品而产生的振动
Carpets now also dampen the vibrations caused by running and jumping over them
地毯现在还能减弱在上面跑和跳跃所引发的振动。
TECHNICAL CHANGES IN 22W15A
22W15A的技术性修改
Removed item_delivered_to_player advancement trigger
移除 item_delivered_to_player进度触发器
Added thrown_item_picked_up_by_player advancement trigger
添加 thrown_item_picked_up_by_player进度触发器
Added avoid_vibration advancement trigger
添加 avoid_vibration进度触发器
Added sonic_explosion particle
添加 sonic_explosion粒子效果
ADVANCEMENTS
进度
NEW TRIGGERS
新触发器
THROWN_ITEM_PICKED_UP_BY_PLAYER
THROWN_ITEM_PICKED_UP_BY_PLAYER
Triggered when a player picks up an item that was thrown by an entity
当玩家捡起一个被实体扔出的物品时触发。
Conditions：
条件：
player- a predicate for the player picking up the item
player-拾取物品的玩家的谓词
entity- a predicate for the entity that threw the item
entity-扔出物品的实体的谓词
item- a predicate for the item
item-被扔出物品的谓词
AVOID_VIBRATION
AVOID_VIBRATION
Triggered when a vibration event is ignored because the source player is holding the sneak key
当振动事件由于玩家正按着潜行键而被忽略时被触发。
Conditions：
条件：
player- a player for which this trigger runs
player-运行这个触发器的玩家
GAME EVENTS
游戏事件
Renamed game event tag ignore_vibrations_on_occluding_block to dampenable_vibrations
重命名游戏事件标签 ignore_vibrations_on_occluding_block为 dampenable_vibrations
Added block tag dampens_vibrations to indicate blocks which will not trigger vibrations when placed, broken or stepped on
增加了方块标签dampens_vibrations，以表示在放置、破坏或踩踏时不会触发振动的方块。
Renamed item tag occludes_vibration_signals to dampens_vibrations item tag as well
重命名物品标签 occludes_vibration_signals为 dampens_vibrations物品标签
FIXED BUGS IN 22W15A
22W15A修复的漏洞
MC-36783- Item frames/Glow item frames don’t change their hitbox if they contain a map
MC-36783-物品展示框和荧光物品展示框在装有地图时不会改变其判定箱
MC-147686- Joining a world that uses custom resources shows default resources until fully loaded
MC-147686-加入使用自定义资源的世界后首先显示的是默认资源，直至自定义资源完全加载
MC-183520- Phantoms with NoAI can go through blocks
MC-183520- NoAI的幻翼可以穿过方块
MC-212610- Glow lichens cannot be put on soul sand
MC-212610-无法把发光地衣放到灵魂沙上
MC-212629- Leashes from two or more invisible entities connect to each other
MC-212629-两个及以上隐身实体上的拴绳会互相连接
MC-216567- Vines cannot be placed on the sides of 8 layers of snow
MC-216567-藤蔓无法放在 8层雪堆积而成的方块的侧面
MC-216569- Glow lichen cannot be placed on the side of 8 layers of snow
MC-216569-发光地衣无法放在 8层雪堆积而成的方块的侧面
MC-219642- Vines cannot be placed on the sides of soul sand
MC-219642-藤蔓无法放在灵魂沙的侧面
MC-231458- The word“ingot” within the“Serious Dedication” advancement description is improperly capitalized
MC-231458-进度“终极奉献”描述中的"ingot"大小写错误
MC-235035- Sleeping in a custom dimension with“natural” set to false causes crash
MC-235035-在一个natural设置为假的自定义维度睡觉会导致崩溃
MC-237924- The word“villager” within the“Star Trader” advancement description is improperly capitalized
MC-237924-进度“星际商人”描述中的"villager"未大写
MC-249072- Sculk shriekers replace water blocks
MC-249072-幽匿尖啸体会替换水方块
MC-249087- The inside texture of mangrove roots darkens when solid blocks are placed adjacent to them
MC-249087-在红树根的旁边放置固体方块后，其内部的纹理会变暗
MC-249094- Unexpected culling of inner sculk shrieker faces
MC-249094-幽匿尖啸体面部内侧有不正确的切刻
MC-249111- sculk_charge cannot be used in/particle command
MC-249111-/particle命令中无法使用 sculk_charge
MC-249208- Vines, glow lichens, and sculk veins cannot be placed on the side or top faces of mud
MC-249208-藤蔓、发光地衣和幽匿脉络无法放在泥巴的侧面或顶面
MC-249315- Mangrove Roots cannot be composted
MC-249315-红树根无法用于堆肥
MC-249347- Map color for mangrove sign and mangrove wall sign is incorrect
MC-249347-地图上对红树木告示牌和墙上的红树木告示牌的颜色标示不正确
MC-249423- You can’t open the boat with chests without a shift, even when you can’t get into the boat
MC-249423-不按住 Shift键时无法打开运输船上的箱子，甚至无法上船
MC-249445- Activated sculk shriekers fail to summon the warden when broken
MC-249445-激活的幽匿尖啸体在被破坏后无法生成监守者
MC-249488- Darkness pulsing option is not saved
MC-249488-黑暗脉动效果选项无法保存
MC-249495- Inconsistent shading in boat item sprites
MC-249495-船的物品图标的阴影不一致
MC-249664- Warden despawns when far away
MC-249664-在离得很远的时候，监守者会消失
MC-249688- Mangrove stairs come after nether wood stairs in the Building Blocks tab
MC-249688-在创造模式物品栏的“建筑方块”分类中，红树木楼梯放在了下界木质楼梯的后面
MC-249737- Allay can be pushed around with{NoAI:1b}
MC-249737-拥有{NoAI:1b}的悦灵能被推动
MC-249741- New advancement names are not properly capitalized
MC-249741-新进度的名称未正确大小写
MC-249785- Warden can be pushed when emerging and digging
MC-249785-监守者在出现和潜埋的时候能被推动
MC-249917- Mangrove trees don’t replace certain blocks with roots
MC-249917-红树不会把一些方块替换成树根
MC-249923- Recovery compass isn’t sorted with regular compass in creative inventory
MC-249923-在创造模式物品栏中，追溯指针未与普通指南针放在一起
MC-249927- You can use a Recovery Compass on a Lodestone
MC-249927-可以对磁石使用追溯指针
MC-249931- Growing a Mangrove Tree with bone meal creates a ghost block
MC-249931-用骨粉催长出红树后会产生幽灵方块
MC-249933- Game crash related to the Frog occurred(Accessing LegacyRandomSource from multiple threads)
MC-249933-与青蛙有关的游戏崩溃(Accessing LegacyRandomSource from multiple threads)
MC-249934- Mangrove roots sometimes don’t generate waterlogged when generating within water
MC-249934-红树根在水中生成时有一定概率未充水
MC-249936- Cave carvers don’t cut through mud
MC-249936-雕刻器洞穴无法穿越泥巴生成
MC-249938- Mangrove Leaves do not drop from Silk Touch tools
MC-249938-使用精准采集工具破坏红树树叶不会掉落其物品形式
MC-249942- Water got removed after waterlogged Mangrove Propagule grows
MC-249942-充水的红树胎生苗在长成后会把水清除
MC-249947- Top of Sculk Shrieker model is vertically squished
MC-249947-幽匿尖啸体的顶部模型被垂直挤压
MC-249966- Warden can forget a target it just roared at
MC-249966-监守者在对着目标咆哮过后就忘记了目标
MC-249968- Powering a beacon disconnects player from server
MC-249968-激活信标使玩家从服务器断开连接
MC-249977- Harsh chunk borders appear when upgrading a 1.18.2 world
MC-249977-升级 1.18.2的世界时会出现突兀的区块边界
MC-249979- Chance to have mangrove roots not waterlogged when growing from a sapling while underwater
MC-249979-在水下用树苗栽种红树木时，红树根有一定概率未充水
MC-249980- The Birthday Song advancement description is incorrectly capitalized
MC-249980-进度“生日快乐歌”的描述中有不正确的大小写
MC-249984- note_block is inconsistently spelled as noteblock in the allay_deliver_cake_to_noteblock advancement
MC-249984-进度 allay_deliver_cake_to_noteblock中错把 note_block拼写成了 noteblock
MC-250017- UUID launch argument required
MC-250017-需要 UUID启动参数
MC-250025- The“You Got a Friend in Me” advancement is incorrectly presented in the past tense
MC-250025-进度“找到一个好朋友”(You Got a Friend in Me)错误地使用了过去时态
MC-250099- Mangrove Log and Mangrove Planks don’t spawn in bonus chest
MC-250099-红树林原木和红树林模板不在奖励箱中生成
MC-250101- Can’t plant sugar cane on mud
MC-250101-无法在泥巴上种植甘蔗
MC-250103- Can’t plant bamboo on mud
MC-250103-无法在泥巴上种植竹子
MC-250104- Can’t plant
java集合类哪个函数可以
java集合里面的函数
java集合里面的函数_java集合【1】———从集合接口框架说起
百里方欣
原创
关注
0点赞·155人阅读
(一) java集合分类
之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue.主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说java里面的集合类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列集合的规范，每次只能存储一个元素，而Map接口定义了双列集合的规范，每次能存储一对元素。
Iterable接口:主要是实现遍历功能
Collection接口:允许重复
Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。
List接口：有序且可重复，可以根据元素的索引来访问集合中的元素。
Queue接口：队列集合
Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。
整个接口框架关系如下(来自百度百科)：
(1) Iterable接口
1.内部定义的方法
java集合最源头的接口，实现这个接口的作用主要是集合对象可以通过迭代器去遍历每一个元素。
源码如下：
//返回一个内部元素为T类型的迭代器(JDK1.5只有这个接口)
Iterator iterator();
//遍历内部元素，action意思为动作，指可以对每个元素进行操作(JDK1.8添加)
default void forEach(Consumer super T> action){}
//创建并返回一个可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。
default Spliterator spliterator(){
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Java 8新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。
下面我们分别展示三个接口的调用：
1.1 iterator方法
public static void iteratorHasNext(){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
//返回迭代器
Iterator iterator=list.iterator();
// hashNext可以判断是否还有元素
while(iterator.hasNext()){
//next()作用是返回当前指针指向的元素,之后将指针移向下个元素
System.out.println(iterator.next());
}
}
当然也可以使用for-each loop方式遍历
for(String item: list){
System.out.println(item);
}
但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：
public class IterableTest{
public IterableTest(){}
public static void main(String[] args){
iteratorHasNext();
}
public static void iteratorHasNext(){
List list= new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
Iterator iterator= list.iterator();
Iterator var2= list.iterator();
while(var2.hasNext()){
String item=(String)var2.next();
System.out.println(item);
}
}
}
需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败【fast-fail】机制。
public static void iteratorHasNext(){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
for(String item: list){
if(item.equals("Jam")){
list.remove(item);
}
System.out.println(item);
}
}
从下面的错误我们可以看出，第一个元素是有被打印出来的，也就是remove操作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。
Jam
Exception in thread"main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at IterableTest.iteratorHasNext(IterableTest.java:15)
at IterableTest.main(IterableTest.java:7)
1.2 forEach方法
其实就是把对每一个元素的操作当成了一个对象传递进来，对每一个元素进行处理。
default void forEach(Consumer super T> action){
Objects.requireNonNull(action);
for(T t: this){
action.accept(t);
}
}
```java
当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在java8中参数是`java.util.function.Consumer`,可以称为**消费行为**或者说**动作**类型。
```java
list.forEach(x-> System.out.print(x));
同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。
public class ConsumerTest{
public static void main(String[] args){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
MyConsumer myConsumer= new MyConsumer();
Iterator it= list.iterator();
list.forEach(myConsumer);
}
static class MyConsumer implements Consumer{
@Override
public void accept(Object t){
System.out.println("自定义打印："+ t);
}
}
}
输出的结果：
自定义打印：Jam
自定义打印：Jane
自定义打印：Sam
1.3 spliterator方法
这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，java默认在集合框架中提供了一个默认的Spliterator实现，底层也就是Stream.isParallel()实现的，我们可以看一下源码：
// stream使用的就是spliterator
default Stream stream(){
return StreamSupport.stream(spliterator(), false);
}
default Spliterator spliterator(){
return Spliterators.spliterator(this, 0);
}
public static Stream stream(Spliterator spliterator, boolean parallel){
Objects.requireNonNull(spliterator);
return new ReferencePipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
parallel);
}
使用的方法如下：
public static void spliterator(){
List list= Arrays.asList("1","2","3","4","5","6","7","8","9","10");
//获取可迭代器
Spliterator spliterator= list.spliterator();
//一个一个遍历
System.out.println("tryAdvance:");
spliterator.tryAdvance(item->System.out.print(item+""));
spliterator.tryAdvance(item->System.out.print(item+""));
System.out.println("\n-------------------------------------------");
//依次遍历剩下的
System.out.println("forEachRemaining:");
spliterator.forEachRemaining(item->System.out.print(item+""));
System.out.println("\n------------------------------------------");
// spliterator1:0~10
Spliterator spliterator1= list.spliterator();
// spliterator1:6~10 spliterator2:0~5
Spliterator spliterator2= spliterator1.trySplit();
// spliterator1:8~10 spliterator3:6~7
Spliterator spliterator3= spliterator1.trySplit();
System.out.println("spliterator1:");
spliterator1.forEachRemaining(item->System.out.print(item+""));
System.out.println("\n------------------------------------------");
System.out.println("spliterator2:");
spliterator2.forEachRemaining(item->System.out.print(item+""));
System.out.println("\n------------------------------------------");
System.out.println("spliterator3:");
spliterator3.forEachRemaining(item->System.out.print(item+""));
}
tryAdvance()一个一个元素进行遍历
forEachRemaining()顺序地分块遍历
trySplit()进行分区形成另外的 Spliterator，使用在并行操作中，分出来的是前面一半，就是不断把前面一部分分出来
结果如下：
tryAdvance:
1 2
-------------------------------------------
forEachRemaining:
3 4 5 6 7 8 9 10
------------------------------------------
spliterator1:
8 9 10
------------------------------------------
spliterator2:
1 2 3 4 5
------------------------------------------
spliterator3:
6 7
还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。
2. Collection接口 extend Iterable
Collection接口可以算是集合类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的差异比较大。
2.1内部定义的方法
源码如下：
boolean add(Object o)//添加元素
boolean remove(Object o)//移除元素
boolean addAll(Collection c)//批量添加
boolean removeAll(Collection c)//批量移除
void retainAll(Collection c)//移除在c中不存在的元素
void clear()//清空集合
int size()//集合大小
boolean isEmpty()//是否为空
boolean contains(Object o)//是否包含在集合中
boolean containsAll(Collection c)//是否包含所有的元素
Iterator iterator()//获取迭代器
Object[] toArray()//转成数组
default boolean removeIf(Predicate super E> filter){}//删除集合中复合条件的元素，删除成功返回true
boolean equals(Object o)
int hashCode()
default Spliterator spliterator(){}//获取可分割迭代器
default Stream stream(){}//获取流
default Stream parallelStream(){}//获取并行流
里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3...，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。
List list= Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
list.parallelStream()
.forEach(out::println);
2.2继承Collection的主要接口
graph LR;
Collection-->List-有顺序,可重复
List-有顺序,可重复-->LinkedList-使用链表实现,线程不安全
List-有顺序,可重复-->ArrayList-数组实现,线程不安全
List-有顺序,可重复-->Vector-数组实现,线程安全
Vector-数组实现,线程安全-->Stack-堆栈,先进后出
Collection-->Set-不可重复,内部排序
Set-不可重复,内部排序-->HashSet-hash表存储
HashSet-hash表存储-->LinkHashSet-链表维护插入顺序
Set-不可重复,内部排序-->TreeSet-二叉树实现,排序
Collection-->Queue-队列,先进先出
2.2.1 List extend Collection
继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。
最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的操作，唯一不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList操作的效率会比Vector好一些。
里面是接口定义的方法：
int size();//获取大小
boolean isEmpty();//判断是否为空
boolean contains(Object o);//是否包含某个元素
Iterator iterator();//获取迭代器
Object[] toArray();//转化成为数组(对象)
T[] toArray(T[] a);//转化为数组(特定位某个类)
boolean add(E e);//添加
boolean remove(Object o);//移除元素
boolean containsAll(Collection> c);//是否包含所有的元素
boolean addAll(Collection extends E> c);//批量添加
boolean addAll(int index, Collection extends E> c);//批量添加，指定开始的索引
boolean removeAll(Collection> c);//批量移除
boolean retainAll(Collection> c);//将c中不包含的元素移除
default void replaceAll(UnaryOperator operator){}//替换
default void sort(Comparator super E> c){}//排序
void clear();//清除所有的元素
boolean equals(Object o);//是否相等
int hashCode();//计算获取hash值
E get(int index);//通过索引获取元素
E set(int index, E element);//修改元素
void add(int index, E element);//在指定位置插入元素
E remove(int index);//根据索引移除某个元素
int indexOf(Object o);//根据对象获取索引
int lastIndexOf(Object o);//获取对象元素的最后一个元素
ListIterator listIterator();//获取List迭代器
ListIterator listIterator(int index);//根据索引获取当前的位置的迭代器
List subList(int fromIndex, int toIndex);//截取某一段数据
default Spliterator spliterator(){}//获取可切分迭代器
上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。
操作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfBoundsException。
说起List的实现子类：
ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List集合。线程不安全。
LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。
Vector：和ArrayList差不多，但是是线程安全的，即同步。
2.2.2 Set extend Collection
Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。
下面是源码方法：
int size();//获取大小
boolean isEmpty();//是否为空
boolean contains(Object o);//是否包含某个元素
Iterator iterator();//获取迭代器
Object[] toArray();//转化成为数组
T[] toArray(T[] a);//转化为特定类的数组
boolean add(E e);//添加元素
boolean remove(Object o);//移除元素
boolean containsAll(Collection> c);//是否包含所有的元素
boolean addAll(Collection extends E> c);//批量添加
boolean retainAll(Collection> c);//移除所有不存在于c集合中的元素
boolean removeAll(Collection> c);//移除所有在c集合中存在的元素
void clear();//清空集合
boolean equals(Object o);//是否相等
int hashCode();//计算hashcode
default Spliterator spliterator(){}//获取可分割迭代器
主要的子类：
HashSet
允许空值
通过HashCode方法计算获取hash值，确定存储位置，无序。
LinkedHashSet
HashSet的子类
有顺序
TreeSet
如果无参数构建Set，则需要实现Comparable方法。
亦可以创建时传入比较方法，用于排序。
2.2.3 Queue extend Collection
队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。
下面是源码：
boolean add(E e);//插入一个元素到队列，失败时返回IllegalStateException(如果队列容量不够)
boolean offer(E e);//插入一个元素到队列，失败时返回false
E remove();//移除队列头的元素并移除
E poll();//返回并移除队列的头部元素，队列为空时返回null
E element();//返回队列头元素
E peek();//返回队列头部的元素，队列为空时返回null
主要的子接口以及实现类有：
Deque(接口):Queue的子接口，双向队列，可以从两边存取
ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中
AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法
PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，
BlockingQueue：在java.util.concurrent包中，阻塞队列，满足当前无法处理的操作。
(2) Map接口
定义双列集合的规范Map，每次存储一对元素，即key和value。
key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。
key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。
下面的源码的方法：
V put(K key, V value);//添加元素
V remove(Object key);//删除元素
void putAll(Map extends K,? extends V> m);//批量添加
void clear()//移除所有元素
V get(Object key);//通过key查询元素
int size();//查询集合大小
boolean isEmpty();//集合是否为空
boolean containsKey(Object key);//是否包含某个key
boolean containsValue(Object value);//是否包含某个value
Set keySet();//获取所有key的set集合
Collection values();//获取所有的value的set集合
Set> entrySet();//返回键值对的set，每一个键值对是一个entry对象
boolean equals(Object o);//用于比较的函数
int hashCode();//计算hashcode
default V getOrDefault(Object key, V defaultValue)//获取key对应的Value，没有则返回默认值()
default void forEach(BiConsumer super K,? super V> action){}//遍历
default void replaceAll(BiFunction super K,? super V,? extends V> function){}//批量替换
//缺少这个key的时候才会添加进去
//返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value
default V putIfAbsent(K key, V value){}
default boolean remove(Object key, Object value){}//移除元素
default boolean replace(K key, V oldValue, V newValue){}//替换
default V replace(K key, V value){}//替换
//和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值
default V computeIfAbsent(K key,Function super K,? extends V> mappingFunction){}
//和computeIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回
default V computeIfPresent(K key,BiFunction super K,? super V,? extends V> remappingFunction){}
//不管如何都会执行映射函数，返回value
default V compute(K key,BiFunction super K,? super V,? extends V> remappingFunction){}
default V merge(K key, V value,BiFunction super V,? super V,? extends V> remappingFunction){}
值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个.
Map的常用的实现子类：
HashMap：由数组和链表组成，线程不安全，无序。
LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。
ConcurrentHashMap：线程安全，1.7JDK使用锁分离，每一段Segment都有自己的独立锁，相对来说效率也比较高。JDK1.8抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。
HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。
(二)总结
这些集合原始接口到底是什么？为什么需要？
我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的集合接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千集合世界。
【作者简介】：
秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。
平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~
关于本次java predicate 是什么和java集合类哪个函数可以的问题分享到这里就结束了，如果解决了您的问题，我们非常高兴。