Java8之Stream/Map - A一线天A - 博客园
随笔 - 52, 文章 - 0, 评论 - 1, 引用 - 0
package com.mavsplus.java8.turtorial.
import java.util.ArrayL
import java.util.L
import java.util.O
import java.util.UUID;
* java.util.Stream使用例子
* java.util.Stream表示了某一种元素的序列，在这些元素上可以进行各种操作。Stream操作可以是中间操作，也可以是完结操作。
* 完结操作会返回一个某种类型的值，而中间操作会返回流对象本身，并且你可以通过多次调用同一个流操作方法来将操作结果串起来。
* Stream是在一个源的基础上创建出来的，例如java.util.Collection中的list或者set（map不能作为Stream的源）。
* Stream操作往往可以通过顺序或者并行两种方式来执行。
* public interface Stream&T& extends BaseStream&T, Stream&T&& {
* 可以看到Stream是一个接口,其是1.8引入
* Java 8中的Collections类的功能已经有所增强，你可以之直接通过调用Collections.stream()或者Collection.
* parallelStream()方法来创建一个流对象
* @author landon
* @since 1.8.0_25
public class StreamUtilExample {
private List&String& stringList = new ArrayList&&();
public StreamUtilExample() {
private void init() {
initStringList();
* 初始化字符串列表
private void initStringList() {
stringList.add("zzz1");
stringList.add("aaa2");
stringList.add("bbb2");
stringList.add("fff1");
stringList.add("fff2");
stringList.add("aaa1");
stringList.add("bbb1");
stringList.add("zzz2");
* Filter接受一个predicate接口类型的变量，并将所有流对象中的元素进行过滤。该操作是一个中间操作，
* 因此它允许我们在返回结果的基础上再进行其他的流操作
* （forEach）。ForEach接受一个function接口类型的变量，用来执行对每一个元素的操作
* 。ForEach是一个中止操作。它不返回流，所以我们不能再调用其他的流操作
public void useStreamFilter() {
// stream()方法是Collection接口的一个默认方法
// Stream&T& filter(Predicate&? super T&
// predicate);filter方法参数是一个Predicate函数式接口并继续返回Stream接口
// void forEach(Consumer&? super T& action);foreach方法参数是一个Consumer函数式接口
// 解释:从字符串序列中过滤出以字符a开头的字符串并迭代打印输出
stringList.stream().filter((s) -& s.startsWith("a")).forEach(System.out::println);
* Sorted是一个中间操作，能够返回一个排过序的流对象的视图。流对象中的元素会默认按照自然顺序进行排序，
* 除非你自己指定一个Comparator接口来改变排序规则.
* 一定要记住，sorted只是创建一个流对象排序的视图，而不会改变原来集合中元素的顺序。原来string集合中的元素顺序是没有改变的
public void useStreamSort() {
// Stream&T& sorted();返回Stream接口
// 另外还有一个 Stream&T& sorted(Comparator&? super T&
// comparator);带Comparator接口的参数
stringList.stream().sorted().filter((s) -& s.startsWith("a")).forEach(System.out::println);
// 输出原始集合元素，sorted只是创建排序视图，不影响原来集合顺序
stringList.stream().forEach(System.out::println);
* map是一个对于流对象的中间操作，通过给定的方法，它能够把流对象中的每一个元素对应到另外一个对象上。
* 下面的例子就演示了如何把每个string都转换成大写的string.
* 不但如此，你还可以把每一种对象映射成为其他类型。对于带泛型结果的流对象，具体的类型还要由传递给map的泛型方法来决定。
public void useStreamMap() {
// &R& Stream&R& map(Function&? super T, ? extends R& mapper);
// map方法参数为Function函数式接口(R_String,T_String).
// 解释:将集合元素转为大写(每个元素映射到大写)-&降序排序-&迭代输出
// 不影响原来集合
stringList.stream().map(String::toUpperCase).sorted((a, b) -& b.compareTo(a)).forEach(System.out::println);
* 匹配操作有多种不同的类型，都是用来判断某一种规则是否与流对象相互吻合的。所有的匹配操作都是终结操作，只返回一个boolean类型的结果
public void useStreamMatch() {
// boolean anyMatch(Predicate&? super T& predicate);参数为Predicate函数式接口
// 解释:集合中是否有任一元素匹配以'a'开头
boolean anyStartsWithA = stringList.stream().anyMatch((s) -& s.startsWith("a"));
System.out.println(anyStartsWithA);
// boolean allMatch(Predicate&? super T& predicate);
// 解释:集合中是否所有元素匹配以'a'开头
boolean allStartsWithA = stringList.stream().allMatch((s) -& s.startsWith("a"));
System.out.println(allStartsWithA);
// boolean noneMatch(Predicate&? super T& predicate);
// 解释:集合中是否没有元素匹配以'd'开头
boolean nonStartsWithD = stringList.stream().noneMatch((s) -& s.startsWith("d"));
System.out.println(nonStartsWithD);
* Count是一个终结操作，它的作用是返回一个数值，用来标识当前流对象中包含的元素数量
public void useStreamCount() {
// long count();
// 解释:返回集合中以'a'开头元素的数目
long startsWithACount = stringList.stream().filter((s) -& s.startsWith("a")).count();
System.out.println(startsWithACount);
System.out.println(stringList.stream().count());
* 该操作是一个终结操作，它能够通过某一个方法，对元素进行削减操作。该操作的结果会放在一个Optional变量里返回。
public void useStreamReduce() {
// Optional&T& reduce(BinaryOperator&T& accumulator);
// @FunctionalInterface public interface BinaryOperator&T& extends
// BiFunction&T,T,T& {
// @FunctionalInterface public interface BiFunction&T, U, R& { R apply(T
// t, U u);
Optional&String& reduced = stringList.stream().sorted().reduce((s1, s2) -& s1 + "#" + s2);
// 解释:集合元素排序后-&reduce(削减 )-&将元素以#连接-&生成Optional对象(其get方法返回#拼接后的值)
reduced.ifPresent(System.out::println);
System.out.println(reduced.get());
* 使用并行流
* 流操作可以是顺序的，也可以是并行的。顺序操作通过单线程执行，而并行操作则通过多线程执行. 可使用并行流进行操作来提高运行效率
public void useParallelStreams() {
// 初始化一个字符串集合
int max = 1000000;
List&String& values = new ArrayList&&();
for (int i = 0; i & i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
// 使用顺序流排序
long sequenceT0 = System.nanoTime();
values.stream().sorted();
long sequenceT1 = System.nanoTime();
// 输出:sequential sort took: 51921 ms.
System.out.format("sequential sort took: %d ms.", sequenceT1 - sequenceT0).println();
// 使用并行流排序
long parallelT0 = System.nanoTime();
// default Stream&E& parallelStream() {
// parallelStream为Collection接口的一个默认方法
values.parallelStream().sorted();
long parallelT1 = System.nanoTime();
// 输出:parallel sort took: 21432 ms.
System.out.format("parallel sort took: %d ms.", parallelT1 - parallelT0).println();
// 从输出可以看出：并行排序快了一倍多
public static void main(String[] args) {
StreamUtilExample example = new StreamUtilExample();
example.useStreamFilter();
example.useStreamMap();
example.useStreamMatch();
example.useStreamCount();
example.useStreamReduce();
example.useParallelStreams();
package com.mavsplus.java8.turtorial.
import java.util.HashM
import java.util.M
* map是不支持流操作的。而更新后的map现在则支持多种实用的新方法，来完成常规的任务
* @author landon
* @since 1.8.0_25
public class MapUtilExample {
private Map&Integer, String& map = new HashMap&&();
public MapUtilExample() {
initPut();
* 使用更新后的map进行putIfAbsent
private void initPut() {
// putIfAbsent为Map接口中新增的一个默认方法
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
// 如果map中有对应K映射的V且不为null则直接返回;否则执行put
for (int i = 0; i & 10; i++) {
map.putIfAbsent(i, "value" + i);
// 放入了一个null元素
map.putIfAbsent(10, null);
// 替换null
map.putIfAbsent(10, "value10");
// 因为K-10有映射且不为null则忽略V-value11
map.putIfAbsent(10, "value11");
* 使用更新后的map进行for-each
public void forEach() {
// default void forEach(BiConsumer&? super K, ? super V& action)
// Map接口中新增的默认方法
// @FunctionalInterface public interface BiConsumer&T, U& {void accept(T
// t, U u);
map.forEach((id, val) -& System.out.println(val));
* 使用更新后的map进行compute&&-&重映射
public void compute() {
// default V computeIfPresent(K key,BiFunction&? super K, ? super V, ?
// extends V& remappingFunction)
// Map接口中新增的默认方法
// @FunctionalInterface public interface BiFunction&T, U, R& {R apply(T
// t, U u);
// --& V apply(K k,V v)
// ifPresent会判断key对应的v是否是null，不会null才会compute-&否则直接返回null
// 解释:将K-3映射的value-&compute-&"value3" + 3 = value33
puteIfPresent(3, (key, val) -& val + key);
System.out.println(map.get(3));
// 解释:这里将K-3映射的value进行重映射-&null
// 该方法源码实现会判断如果newValue为null则会执行remove(key)方法,将移除key
puteIfPresent(9, (key, val) -& null);
// 从上面的解释中得到，输出为false,因为已经被移除了
System.out.println(map.containsKey(9));
// default V computeIfAbsent(K key,Function&? super K, ? extends V&
// mappingFunction)
// 解释:代码实现上看，如果K-15映射的值为null,即不存在或者为null,则执行映射-&所以本例来看(没有15的key)，该方法相当于插入一个新值
puteIfAbsent(15, (key) -& "val" + key);
System.out.println(map.containsKey(15));
// 因为K-4映射的值存在，所以直接返回，即不会重映射,所以输出依然会是value4
puteIfAbsent(4, key -& "bam");
System.out.println(map.get(4));
* 使用更新后的map进行remove
public void remove() {
// default boolean remove(Object key, Object value) {
// Map接口中新增的默认方法
// 其源码实现是
// 1.当前key对应的值和传入的参数不一致时则直接返回，移除失败(用的是Objects.equals方法)
// 2.当前key对应的值为null且!containsKey(key),移除失败(即当前map中根本不存在这个key_【因为有一种情况是有这个key但是key映射的值为null】)
// -&否则执行移除
default boolean remove(Object key, Object value) {
Object curValue = get(key);
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
remove(key);
map.remove(3, "value4");
System.out.println(map.get(3));
// key和v匹配时则移除成功
map.remove(3, "value33");
System.out.println(map.get(3));
* getOrDefault是一个有用的方法
public void getOrDefault() {
// default V getOrDefault(Object key, V defaultValue) {
// Map接口中新增的默认方法
* default V getOrDefault(Object key, V defaultValue) {
return (((v = get(key)) != null) || containsKey(key))
: defaultV
// 源码实现:
// 1.如果对应的key有value且不为null，则直接返回如果为null且包含该key，则返回null(总之即必须要有该key)
// 2.如果没有该key，则用默认值
String retV = map.getOrDefault("20", "not found");
System.out.println(retV);
// 加入一个null
map.putIfAbsent(30, null);
// 输出null
System.out.println(map.get(30));
// 输出null
System.out.println(map.getOrDefault(30, "value30"));
public void merge() {
// default V merge(K key, V value,BiFunction&? super V, ? super V, ?
// extends V& remappingFunction)
// @FunctionalInterface public interface BiFunction&T, U, R& { R apply(T
// t, U u);
// merge为Map接口新增的默认方法
default V merge(K key, V value,
BiFunction&? super V, ? super V, ? extends V& remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = get(key);
V newValue = (oldValue == null) ? value :
remappingFunction.apply(oldValue, value);
if(newValue == null) {
remove(key);
put(key, newValue);
return newV
// 其源码实现:
// 1.分别检查参数remappingFunction和value是否为null(调用Objects.requireNonNull).-&为null则抛出空指针
// 2.判断oldValue是否为null,如果为null则将传入的newValue赋值;如果oldValue不为null则执行merge函数
// ---&apply(oldValue, value)
// 3.判断newValue-&如果为null则执行移除；否则执行插入
// k-9的值在执行compute方法的时候已经被移除了-&所以oldValue为null-&所以newValue为传入的参数value9-&执行插入
// 所以这里输出为value9
String newValue1 = map.merge(9, "value9", (value, newValue) -& value.concat(newValue));
System.out.println(newValue1);
System.out.println(map.get(9));
// k-9的值现在已经为value9了，所以执行merge函数-&"value9".concat("concat")-&newValue为"value9concat"
// 执行插入，所以这里输出为value9concat
String newValue2 = map.merge(9, "concat", (value, newValue) -& value.concat(newValue));
System.out.println(newValue2);
System.out.println(map.get(9));
// k-8值存在为value8-&执行merge函数-&直接返回"NewMerge8"-&newValue为"NewMerge8"
// 执行put-&所以这里输出"NewMerge8"
map.merge(8, "merge", (value, newValue) -& "NewMerge8");
System.out.println(map.get(8));
public static void main(String[] args) {
MapUtilExample example = new MapUtilExample();
example.forEach();
example.remove();
example.getOrDefault();
example.merge();Java 8：不要再用循环了 - ImportNew
正如我所写的，Java 8中的新功能特性改变了游戏规则。对Java开发者来说这是一个全新的世界，并且是时候去适应它了。
在这篇文章里，我们将会去了解传统循环的一些替代方案。在Java 8的新功能特性中，最棒的特性就是允许我们去表达我们想要完成什么而不是要怎样做。这正是循环的不足之处。要确保循环的灵活性是需要付出代价的。return、break 或者 continue都会显著地改变循环的实际表现。这迫使我们不仅要清楚我们要实现怎样的代码，还要了解循环是怎样工作的。
在介绍Java 8的流（Stream）时，我们学会了一些集合操作的实用技巧。现在我们要看看怎样把这些循环转换为更简洁，可读性更高的代码。
开始编码！
好吧，讲的够多了，是时候展示一些例子了！
这次我们要以文章为例子。一篇文章拥有一个标题，一个作者和几个标签。
private class Article {
private final S
private final S
private final List&String&
private Article(String title, String author, List&String& tags) {
this.title =
this.author =
this.tags =
public String getTitle() {
public String getAuthor() {
public List&String& getTags() {
每个例子都会包含一个使用传统循环的方案和一个使用Java 8新特性的方案。
在第一个例子里，我们要在集合中查找包含“Java”标签的第一篇文章。
看一下使用for循环的解决方案。
public Article getFirstJavaArticle() {
for (Article article : articles) {
if (article.getTags().contains(&Java&)) {
现在我们使用Stream API的相关操作来解决这个问题。
public Optional&Article& getFirstJavaArticle() {
return articles.stream()
.filter(article -& article.getTags().contains(&Java&))
.findFirst();
是不是很酷？我们首先使用 filter 操作去找到所有包含Java标签的文章，然后使用 findFirst() 操作去获取第一次出现的文章。因为Stream是“延迟计算”（lazy）的并且filter返回一个流对象，所以这个方法仅在找到第一个匹配元素时才会处理元素。
现在，让我们获取所有匹配的元素而不是仅获取第一个。
首先使用for循环方案。
public List&Article& getAllJavaArticles() {
List&Article& result = new ArrayList&&();
for (Article article : articles) {
if (article.getTags().contains(&Java&)) {
result.add(article);
使用Stream操作的方案。
public List&Article& getAllJavaArticles() {
return articles.stream()
.filter(article -& article.getTags().contains(&Java&))
.collect(Collectors.toList());
在这个例子里我们使用 collection 操作在返回流上执行少量代码而不是手动声明一个集合并显式地添加匹配的文章到集合里。
到目前为止还不错。是时候举一些突出Stream API强大的例子了。
根据作者来把所有的文章分组。
照旧，我们使用循环方案。
public Map&String, List&Article&& groupByAuthor() {
Map&String, List&Article&& result = new HashMap&&();
for (Article article : articles) {
if (result.containsKey(article.getAuthor())) {
result.get(article.getAuthor()).add(article);
ArrayList&Article& articles = new ArrayList&&();
articles.add(article);
result.put(article.getAuthor(), articles);
我们能否找到一个使用流操作的简洁方案来解决这个问题？
public Map&String, List&Article&& groupByAuthor() {
return articles.stream()
.collect(Collectors.groupingBy(Article::getAuthor));
很好！使用 groupingBy 操作和 getAuthor 方法，我们得到了更简洁、可读性更高的代码。
现在，我们查找集合中所有不同的标签。
我们从使用循环的例子开始。
public Set&String& getDistinctTags() {
Set&String& result = new HashSet&&();
for (Article article : articles) {
result.addAll(article.getTags());
好，我们来看看如何使用Stream操作来解决这个问题。
public Set&String& getDistinctTags() {
return articles.stream()
.flatMap(article -& article.getTags().stream())
.collect(Collectors.toSet());
棒极了！flatmap 帮我把标签列表转为一个返回流，然后我们使用 collect 去创建一个集合作为返回值。
一切皆有可能
以上的就是如何使用可读性更高的代码代替循环的例子。务必仔细看看，因为这篇文章仅仅提到它的一些皮毛而已。
收到solarfuse和dhruvgairola的评论后，更新了getDistinctTags()例子，使用集合（Set）作为返回集合。
原文链接：
- 译文链接： [ 转载请保留原文出处、译者和译文链接。]
关于作者：
新浪微博：
不错，看了一下楼主知乎上的其他文章，感觉还是有蛮多可取之处。
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
– 好的话题、有启发的回复、值得信赖的圈子
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– UI,网页，交互和用户体验
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
& 2017 ImportNewjquery获取元素索引值index()示例
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了jquery获取元素索引值index()方法,需要的朋友可以参考下
jquery获取元素索引值index()方法：jquery的index()方法 搜索匹配的元素，并返回相应元素的索引值，从0开始计数。 如果不给 .index() 方法传递参数，那么返回值就是这个jQuery对象集合中第一个元素相对于其同辈元素的位置。 如果参数是一组DOM元素或者jQuery对象，那么返回值就是传递的元素相对于原先集合的位置。 如果参数是一个选择器，那么返回值就是原先元素相对于选择器匹配元素中的位置。如果找不到匹配的元素，则返回-1。
代码如下: &ul& &li id="foo"&foo&/li& &li id="bar"&bar&/li& &li id="baz"&baz&/li& &/ul& $('li').index(document.getElementById('bar')); //1，传递一个DOM对象，返回这个对象在原先集合中的索引位置 $('li').index($('#bar')); //1，传递一个jQuery对象 $('li').index($('li:gt(0)')); //1，传递一组jQuery对象，返回这个对象中第一个元素在原先集合中的索引位置 $('#bar').index('li'); //1，传递一个选择器，返回#bar在所有li中的做引位置 $('#bar').index(); //1，不传递参数，返回这个元素在同辈中的索引位置。
jquery获取元素索引值index()示例
代码如下: //用于二级或者三级联动 &div id="nav"& &a href="/"&建站素材&/a& &a href="/"&jquery特效&/a& &a href="/"&懒人主机&/a& &a href="/qd63/"&前端路上&/a& &/div& $("#nav a").click(function(){ //四个经典的用法 var index1 = $("#nav a").index(this); var index2 = $("#nav a").index($(this)); var index3 = $(this).index() var index3 = $(this).index("a") alert(index3);
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具Java8 使用filter对集合过滤的时候怎么取到当前的索引即index？ - 知乎24被浏览3986分享邀请回答0添加评论分享收藏感谢收起list中添加，获取，删除元素；
list中是否包含某个元素；
list中根据索引将元素数值改变(替换)；
list中查看（判断）元素的索引；
根据元素索引位置进行的判断；
利用list中索引位置重新生成一个新的list（截取集合）；
对比两个list中的所有元素；
判断list是否为空；
返回Iterator集合对象；
将集合转换为字符串；
将集合转换为数组；
集合类型转换；
备注：内容中代码具有关联性。
1.list中添加，获取，删除元素；
　　添加方法是：.add(e)；　　获取方法是：.get(index)；　　删除方法是：.remove(index)； 按照索引删除；　　.remove(Object o)； 按照元素内容删除；
List&String& person=new ArrayList&&();
person.add("jackie"); //索引为0 //.add(e)
person.add("peter"); //索引为1
person.add("annie"); //索引为2
person.add("martin"); //索引为3
person.add("marry"); //索引为4
person.remove(3); //.remove(index)
person.remove("marry");
//.remove(Object o)
String per="";
per=person.get(1);
System.out.println(per);
////.get(index)
for (int i = 0; i & person.size(); i++) {
System.out.println(person.get(i)); //.get(index)
2.list中是否包含某个元素；
　　方法：.contains（Object o）； 返回true或者false
List&String& fruits=new ArrayList&&();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("桃子");
//for循环遍历list
for (int i = 0; i & fruits.size(); i++) {
System.out.println(fruits.get(i));
String appleString="苹果";
//true or false
System.out.println("fruits中是否包含苹果："+fruits.contains(appleString));
if (fruits.contains(appleString)) {
System.out.println("我喜欢吃苹果");
System.out.println("我不开心");
3.list中根据索引将元素数值改变(替换)；
　　注意 .set(index, element); 和 .add(index, element); 的不同；
String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
List&String& people=new ArrayList&&();
people.add(a);
people.add(b);
people.add(c);
people.set(0, d); //.set(index, element);
//将d唐僧放到list中索引为0的位置，替换a白龙马
people.add(1, e); //.add(index, element);
//将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位
//增强for循环遍历list
for(String str:people){
System.out.println(str);
4.list中查看（判断）元素的索引；　　
　　注意：.indexOf（）； 和 &lastIndexOf（）的不同；
List&String& names=new ArrayList&&();
names.add("刘备"); //索引为0
names.add("关羽"); //索引为1
names.add("张飞"); //索引为2
names.add("刘备"); //索引为3
names.add("张飞"); //索引为4
System.out.println(names.indexOf("刘备"));
System.out.println(names.lastIndexOf("刘备"));
System.out.println(names.indexOf("张飞"));
System.out.println(names.lastIndexOf("张飞"));
5.根据元素索引位置进行的判断;
if (names.indexOf("刘备")==0) {
System.out.println("刘备在这里");
}else if (names.lastIndexOf("刘备")==3) {
System.out.println("刘备在那里");
System.out.println("刘备到底在哪里？");
6.利用list中索引位置重新生成一个新的list（截取集合）；
　　方法： .subList(fromIndex, toIndex)；　　.size() ； 该方法得到list中的元素数的和
List&String& phone=new ArrayList&&();
phone.add("三星"); //索引为0
phone.add("苹果"); //索引为1
phone.add("锤子"); //索引为2
phone.add("华为"); //索引为3
phone.add("小米"); //索引为4
//原list进行遍历
for(String pho:phone){
System.out.println(pho);
//生成新list
phone=phone.subList(1, 4); //.subList(fromIndex, toIndex)
//利用索引1-4的对象重新生成一个list，但是不包含索引为4的元素，4-1=3
for (int i = 0; i & phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和
System.out.println("新的list包含的元素是"+phone.get(i));
7.对比两个list中的所有元素；
　　//两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象
//1.if (person.equals(fruits)) {
System.out.println("两个list中的所有元素相同");
System.out.println("两个list中的所有元素不一样");
if (person.hashCode()==fruits.hashCode()) {
System.out.println("我们相同");
System.out.println("我们不一样");
8.判断list是否为空；
　　//空则返回true，非空则返回false
if (person.isEmpty()) {
System.out.println("空的");
System.out.println("不是空的");
9.返回Iterator集合对象；
System.out.println("返回Iterator集合对象:"+person.iterator());
1+0.将集合转换为字符串；
String liString="";
liString=person.toString();
System.out.println("将集合转换为字符串:"+liString);
11.将集合转换为数组；
System.out.println("将集合转换为数组:"+person.toArray());
12.集合类型转换；
//1.默认类型
List&Object& listsStrings=new ArrayList&&();
　　for (int i = 0; i & person.size(); i++) {
listsStrings.add(person.get(i));
//2.指定类型
List&StringBuffer& lst=new ArrayList&&();
　　for(String string:person){
　　lst.add(StringBuffer(string));
13.去重复；
List&String& lst1=new ArrayList&&();
lst1.add("aa");
lst1.add("dd");
lst1.add("ss");
lst1.add("aa");
lst1.add("ss");
for (int i = 0; i &lst1.size()-1; i++) {
for (int j = lst1.size()-1; j &i; j--) {
if (lst1.get(j).equals(lst1.get(i))) {
lst1.remove(j);
System.out.println(lst1);
List&String& lst2=new ArrayList&&();
for (String s:lst1) {
if (Collections.frequency(lst2, s)&1) {
lst2.add(s);
System.out.println(lst2);
附完整代码：
package MyTest01;
import java.util.ArrayL
import java.util.L
public class ListTest01 {
public static void main(String[] args) {
//list中添加，获取，删除元素
List&String& person=new ArrayList&&();
person.add("jackie"); //索引为0 //.add(e)
person.add("peter"); //索引为1
person.add("annie"); //索引为2
person.add("martin"); //索引为3
person.add("marry"); //索引为4
person.remove(3); //.remove(index)
person.remove("marry");
//.remove(Object o)
String per="";
per=person.get(1);
System.out.println(per);
////.get(index)
for (int i = 0; i & person.size(); i++) {
System.out.println(person.get(i)); //.get(index)
//list总是否包含某个元素
List&String& fruits=new ArrayList&&();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("桃子");
//for循环遍历list
for (int i = 0; i & fruits.size(); i++) {
System.out.println(fruits.get(i));
String appleString="苹果";
//true or false
System.out.println("fruits中是否包含苹果："+fruits.contains(appleString));
if (fruits.contains(appleString)) {
System.out.println("我喜欢吃苹果");
System.out.println("我不开心");
//list中根据索引将元素数值改变(替换)
String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
List&String& people=new ArrayList&&();
people.add(a);
people.add(b);
people.add(c);
people.set(0, d); //.set(index, element)
//将d唐僧放到list中索引为0的位置，替换a白龙马
people.add(1, e); //.add(index, element);
//将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位
//增强for循环遍历list
for(String str:people){
System.out.println(str);
//list中查看（判断）元素的索引
List&String& names=new ArrayList&&();
names.add("刘备"); //索引为0
names.add("关羽"); //索引为1
names.add("张飞"); //索引为2
names.add("刘备"); //索引为3
names.add("张飞"); //索引为4
System.out.println(names.indexOf("刘备"));
System.out.println(names.lastIndexOf("刘备"));
System.out.println(names.indexOf("张飞"));
System.out.println(names.lastIndexOf("张飞"));
//根据元素索引位置进行的判断
if (names.indexOf("刘备")==0) {
System.out.println("刘备在这里");
}else if (names.lastIndexOf("刘备")==3) {
System.out.println("刘备在那里");
System.out.println("刘备到底在哪里？");
//利用list中索引位置重新生成一个新的list（截取集合）
List&String& phone=new ArrayList&&();
phone.add("三星"); //索引为0
phone.add("苹果"); //索引为1
phone.add("锤子"); //索引为2
phone.add("华为"); //索引为3
phone.add("小米"); //索引为4
//原list进行遍历
for(String pho:phone){
System.out.println(pho);
//生成新list
phone=phone.subList(1, 4); //.subList(fromIndex, toIndex)
//利用索引1-4的对象重新生成一个list，但是不包含索引为4的元素，4-1=3
for (int i = 0; i & phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和
System.out.println("新的list包含的元素是"+phone.get(i));
//对比两个list中的所有元素
//两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象
if (person.equals(fruits)) {
System.out.println("两个list中的所有元素相同");
System.out.println("两个list中的所有元素不一样");
if (person.hashCode()==fruits.hashCode()) {
System.out.println("我们相同");
System.out.println("我们不一样");
//判断list是否为空
//空则返回true，非空则返回false
if (person.isEmpty()) {
System.out.println("空的");
System.out.println("不是空的");
//返回Iterator集合对象
System.out.println("返回Iterator集合对象:"+person.iterator());
//将集合转换为字符串
String liString="";
liString=person.toString();
System.out.println("将集合转换为字符串:"+liString);
//将集合转换为数组，默认类型
System.out.println("将集合转换为数组:"+person.toArray());
////将集合转换为指定类型（友好的处理）
//1.默认类型
List&Object& listsStrings=new ArrayList&&();
for (int i = 0; i & person.size(); i++) {
listsStrings.add(person.get(i));
//2.指定类型
List&StringBuffer& lst=new ArrayList&&();
for(String string:person){
lst.add(StringBuffer(string));
private static StringBuffer StringBuffer(String string) {
阅读(...) 评论()