精华内容
下载资源
问答
  • 一些有志青年,如大学在校生,在职人员,自由职业者,想通过学习Java编程谋求生路,着无疑是个好方向,但是大多人都存在这零基础是否可以学好Java编程,要如何学,自学Java视频教程学不会怎么办,这样的疑问 ...

      随着社会的发展,世界上并没有成为高手的捷径,面向各种领域各个行业,尤其是IT行业的发展不断扩张,以及人才需求不断扩大,一些有志青年,如大学在校生,在职人员,自由职业者,想通过学习Java编程谋求生路,着无疑是个好方向,但是大多人都存在这零基础是否可以学好Java编程,要如何学,自学Java视频教程学不会怎么办,这样的疑问

      首先我们要找到正确的学习方向,有一些人心存疑虑,不敢贸然离校或者辞职,无法做到到Java培训班全日制学习,为此一般会想到业余时间通过Java视频教程自学,小编认为自学Java视频教程不是十分的可取,为什么小编说不可取呢:

      1.自主学习需要定力和毅力,尤其是像Java编程这样有难度的编程语言

      2.自学缺乏辅导和指导,学习中肯定会遇到不少的难题,比如,编写一个程序,怎么搞都不成功,也查不到是哪里出现问题,甚至一个问题很有可能拖一个月解决不了。缺乏必要的辅导和指导,而使许多自学者遇到问题时,不知所措,从而放弃学习。

      3.自学缺乏学习氛围,惰性是人类的共性,在缺乏外在压力和阶段目标的前提下很难保障时刻保持进度,尤其是在困难重重之下,经常受外界的干扰而转移精力。

      以上都是自学编程所遇到的弊端,而西安鸥鹏Java培训机构为解决当下局面,为此开设了在线Java培训,由总监级老师直播授课,学员在业余时间学习,为没有时间全日制面授的学员打开通往Java工程师之路的大门。

      西安鸥鹏Java教学有以下几大特点

      1.主流项目开发实践(在项目实训中,学员将会结合自己所学的技术知识和开发思想,独立展开项目需求分析,完成企业流行项目开的开发实践。)

      2.定期批改审查作业(为保障教学质量,帮助学员领会课程内容,教学团队会依据学生以及作业情况定制一对一学习计划。)

      3.支持随时随地学习(学员在享受直播授课的同时,还能免费获得直播课程视频全部课件,学员可以永久学习;)

      4.闪电式扫除学习障碍(为帮助学员扫清学习障碍,学员可以随时在班级vip群讨论提问,授课老师会在24小时内进行答疑)

     

    展开全文
  • 如果真的想要java的话,自己就要对自己下狠心,以下是我的几点建议哈:1.全方面的来说,要想学好关于计算机这一方面的东西,如果只是一时兴趣三分钟热度的话,劝你最好不要浪费时间和金钱。首先,计算机是一种建立...

    如果真的想要学java的话,自己就要对自己下狠心,以下是我的几点建议哈:

    1.全方面的来说,要想学好关于计算机这一方面的东西,如果只是一时兴趣三分钟热度的话,劝你最好不要浪费时间和金钱。首先,计算机是一种建立在特殊语言的基础上而进行帮忙人们运算的程序。而且计算机大多是英语为主,要想学好这方面,英语必不可少。

    2.要学java我们就要从最基础的去了解。c语言是计算机这方面入门的最低门槛知识,虽然是基础,但是也不是那么容易,首先要有一颗认真仔细的心,计算机程序讲究的是语法,中英文的差别就是致命的缺点。

    3.java是同于C++和C#的计算机高级语言,所以其难度性可想而知,学习java的过程是一个很折磨人的过程,不仅需要细心而且还需要付出时间,如果在这一方面的天赋不是很高,那么付出的代价也不是那么的容易。

    4.我们可以在网上找自学的一些教材和视频,大概的了解java是一个怎么样的概念,然后自己就是付出时间的去专研。

    总的来说,学习计算机这一方面的知识,不仅需要有耐心,而且随着网络的不断发展,计算机也是不断的发生变化,这就需要自己不断的去学习,而且是自己去学,如果有想学习这一方面知识的朋友,请相信自己并不断的努力,成功不是靠想出来的,当你回头能够看见自己走过的脚印,这才是攀上成功的基础。

    展开全文
  • 随时时间的推移,企业对于Python开发者的要求也在不断提高,互联网公司注重效率,所以不会培养新人,所以想要从事Python开发,就要从开始靠我们自己到技术,以后的竞争会越来越激烈。优胜劣汰,物竞天择,适者生存...

    前信息化产业发展势头很好,IT就成为了很多普通人想要涉及的行业,因为相比于传统行业,IT行业涨薪幅度大,机会也多,所以就会大批的人想要转行来学习Python开发。目前来讲市场上需要的Python人员非常多,而且按照现在的势头,以后会需要更多的Python开发人员,理由是以后每个人公司都会有自己的网站,有自己的开发部,对于用户体验看的非常重要。所以Python程序员就会很吃香。随时时间的推移,企业对于Python开发者的要求也在不断提高,互联网公司注重效率,所以不会培养新人,所以想要从事Python开发,就要从开始靠我们自己学到技术,以后的竞争会越来越激烈。优胜劣汰,物竞天择,适者生存。

    如果你想要学好Python可以加入一个组织,这样大家学习的话就比较方便,还能够共同交流和分享资料,给你推荐一个学习的组织学习有可学习有困难或者想获取Python资料请加Python学习Q群629440234,互相学习,互相分享学习资料

    那既然这么多自学Python的人,放弃的,失败的,为什么如此之多,今天小编给大家总结几点一针见血的原因:

    bb

    1.

    作为外行人不懂这行,也不知道找专业的人交流沟通一下,毕竟你是个外行人肯定会有非常多不懂的地方,各行如隔山。况且是Python这种技术类型的工作,如果你都不了解怎么学有效率,应该注意哪些方式,自己就无脑的买书或者在网上找视频去学。那你可以自己及去想想,有什么理由能让你学成呢?毫无准备的人,毫无知情的人怎么可能成功转行呢?所以初学者还了解行业行情,多跟大牛请教一下,这是必须的。

    2.

    学的不系统,学的东西不是重点,做Python开发工作中,其实用的东西翻来覆去就是那么几样,Python的东西虽然多,但是并不是每个知识都学,有很多知识工作中永远都用不到,了解就可以了。但是作为初学者就是不知道重点是什么,盲目的学,最后肯定达不到企业需求的水平,最后不得不放弃。

    3.

    “看”多于“练”还是同样的原因,很多转行的学习Python的新人只是无脑的看书,看视频,但是却不知道学习Python是为了能动手做项目。虽然他看完了所有的视频,但是却什么都写不出来,没有多少实际操作。他认为自己看完了视频就算是学过了,其实他跟没学也没什么区别,嘴里还说着找不到工作,Python饱和了这样的话。还是由于自己的不懂。

    以上三点基本是所有人最后失败和放弃的主要原因。如果你想做Python的工作,应该避免上面的问题。

    那么想学习Python应该如何去做呢?

    首先我认为想去培训的人和不想去培训的人有两个心态,想去培训的人是决心要学的,不想去培训的人大部分都是浑水摸鱼的,所以放弃的概率是95%的。但是也有小部分是因为经济条件不好。我这里想说明什么呢?想去培训的,小编不建议你去培训,不想培训的,小编也不建议你不培训。我是意思是说,学习编程是一定需要老师的,我不信谁能无师自通把Python学的多么好。至少着急就业的人肯定不会,没人指导很难学成。所以小编建议学习Python开发选择一个线上的辅导班,成本低,如果你能坚持学到最后,那你就适合学习Python,成完后能力也不会很弱。如果你中途放弃了,说明你不适合,你也不会损失多少钱。

    展开全文
  • 怎么办?在Java 8之前的做法可能为: import java.util.ArrayList; import java.util.List; public class Demo02NormalFilter { public static void main(String[] args) { List<String> list = new ArrayList...

    Java【Stream流、方法引用】

    主要内容

    • Stream流
    • 方法引用

    目标

    • 能够理解流与集合相比的优点
    • 能够理解流的延迟执行特点
    • 能够通过集合、映射或数组获取流
    • 能够掌握常用的流操作
    • 能够使用输出语句的方法引用3
    • 能够通过4种方式使用方法引用
    • 能够使用类和数组的构造器引用8

    第一章 Stream流

    说到Stream便容易想到I/O Stream,而实际上,谁规定“流”就一定是“IO流”呢?在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端。

    1.1 引言

    传统集合的多步遍历代码

    几乎所有的集合(如Collection接口或Map接口等)都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候,除了必需的添加、删除、获取外,最典型的就是集合遍历。例如:

    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo01ForEach {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("张强");
            list.add("张三丰");
            for (String name : list) {
              	System.out.println(name);
            }
        }  
    }
    

    这是一段非常简单的集合遍历操作:对集合中的每一个字符串都进行打印输出操作。

    循环遍历的弊端

    Java 8的Lambda让我们可以更加专注于做什么(What),而不是怎么做(How),这点此前已经结合内部类进行了对比说明。现在,我们仔细体会一下上例代码,可以发现:

    • for循环的语法就是“怎么做
    • for循环的循环体才是“做什么

    为什么使用循环?因为要进行遍历。但循环是遍历的唯一方式吗?遍历是指每一个元素逐一进行处理,而并不是从第一个到最后一个顺次处理的循环。前者是目的,后者是方式。

    试想一下,如果希望对集合中的元素进行筛选过滤:

    1. 将集合A根据条件一过滤为子集B
    2. 然后再根据条件二过滤为子集C

    那怎么办?在Java 8之前的做法可能为:

    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo02NormalFilter {
      	public static void main(String[] args) {
          	List<String> list = new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("张强");
            list.add("张三丰");
    
            List<String> zhangList = new ArrayList<>();
            for (String name : list) {
                if (name.startsWith("张")) {
                  	zhangList.add(name);
                }
            }
    
            List<String> shortList = new ArrayList<>();
            for (String name : zhangList) {
                if (name.length() == 3) {
                  	shortList.add(name);
                }
            }
    
            for (String name : shortList) {
              	System.out.println(name);
            }
        }
    }
    

    这段代码中含有三个循环,每一个作用不同:

    1. 首先筛选所有姓张的人;
    2. 然后筛选名字有三个字的人;
    3. 最后进行对结果进行打印输出。

    每当我们需要对集合中的元素进行操作的时候,总是需要进行循环、循环、再循环。这是理所当然的么?**不是。**循环是做事情的方式,而不是目的。另一方面,使用线性循环就意味着只能遍历一次。如果希望再次遍历,只能再使用另一个循环从头开始。

    那,Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢?

    Stream的更优写法

    下面来看一下借助Java 8的Stream API,什么才叫优雅:

    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo03StreamFilter {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("张强");
            list.add("张三丰");
    
            list.stream()
              	.filter(s -> s.startsWith("张"))
                .filter(s -> s.length() == 3)
                .forEach(System.out::println);
        }
    }
    

    直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历,我们真正要做的事情内容被更好地体现在代码中。

    1.2 流式思想概述

    注意:请暂时忘记对传统IO流的固有印象!

    整体来看,流式思想类似于工厂车间的“生产流水线”。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yUAD7ZpG-1595494895047)(img/02-流水线.jpeg)]

    当需要对多个元素进行操作(特别是多步操作)的时候,考虑到性能及便利性,我们应该首先拼好一个“模型”步骤方案,然后再按照方案去执行它。
    在这里插入图片描述
    这张图中展示了过滤、映射、跳过、计数等多步操作,这是一种集合元素的处理方案,而方案就是一种“函数模型”。图中的每一个方框都是一个“流”,调用指定的方法,可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。

    这里的filtermapskip都是在对函数模型进行操作,集合元素并没有真正被处理。只有当终结方法count执行的时候,整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

    备注:“Stream流”其实是一个集合元素的函数模型,它并不是集合,也不是数据结构,其本身并不存储任何元素(或其地址值)。

    Stream(流)是一个来自数据源的元素队列

    • 元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
    • 数据源 流的来源。 可以是集合,数组 等。

    和以前的Collection操作不同, Stream操作还有两个基础的特征:

    • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
    • 内部迭代: 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式,流可以直接调用遍历方法。

    当使用一个流的时候,通常包括三个基本步骤:获取一个数据源(source)→ 数据转换→执行操作获取想要的结果,每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以像链条一样排列,变成一个管道。

    1.3 获取流

    java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。(这并不是一个函数式接口。)

    获取一个流非常简单,有以下几种常用的方式:

    • 所有的Collection集合都可以通过stream默认方法获取流;
    • Stream接口的静态方法of可以获取数组对应的流。

    根据Collection获取流

    首先,java.util.Collection接口中加入了default方法stream用来获取流,所以其所有实现类均可获取流。

    import java.util.*;
    import java.util.stream.Stream;
    
    public class Demo04GetStream {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            // ...
            Stream<String> stream1 = list.stream();
    
            Set<String> set = new HashSet<>();
            // ...
            Stream<String> stream2 = set.stream();
    
            Vector<String> vector = new Vector<>();
            // ...
            Stream<String> stream3 = vector.stream();
        }
    }
    

    根据Map获取流

    java.util.Map接口不是Collection的子接口,且其K-V数据结构不符合流元素的单一特征,所以获取对应的流需要分key、value或entry等情况:

    import java.util.HashMap;
    import java.util.Map;
    import java.util.stream.Stream;
    
    public class Demo05GetStream {
        public static void main(String[] args) {
            Map<String, String> map = new HashMap<>();
            // ...
            Stream<String> keyStream = map.keySet().stream();
            Stream<String> valueStream = map.values().stream();
            Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
        }
    }
    

    根据数组获取流

    如果使用的不是集合或映射而是数组,由于数组对象不可能添加默认方法,所以Stream接口中提供了静态方法of,使用很简单:

    import java.util.stream.Stream;
    
    public class Demo06GetStream {
        public static void main(String[] args) {
            String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
            Stream<String> stream = Stream.of(array);
        }
    }
    

    备注:of方法的参数其实是一个可变参数,所以支持数组。

    1.4 常用方法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L0BBu0OU-1595494895053)(img\stream语法.jpg)]

    流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:

    • 延迟方法:返回值类型仍然是Stream接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方法均为延迟方法。)

    • 终结方法:返回值类型不再是Stream接口自身类型的方法,因此不再支持类似StringBuilder那样的链式调用。本小节中,终结方法包括countforEach方法。

    备注:本小节之外的更多方法,请自行参考API文档。

    逐一处理:forEach

    虽然方法名字叫forEach,但是与for循环中的“for-each”昵称不同。

    void forEach(Consumer<? super T> action);
    

    该方法接收一个Consumer接口函数,会将每一个流元素交给该函数进行处理。

    复习Consumer接口

    java.util.function.Consumer<T>接口是一个消费型接口。
    Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据。
    

    基本使用:

    import java.util.stream.Stream;
    
    public class Demo12StreamForEach {
        public static void main(String[] args) {
            Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
            stream.forEach(name-> System.out.println(name));
        }
    }
    

    过滤:filter

    可以通过filter方法将一个流转换成另一个子集流。方法签名:

    Stream<T> filter(Predicate<? super T> predicate);
    

    该接口接收一个Predicate函数式接口参数(可以是一个Lambda或方法引用)作为筛选条件。

    在这里插入图片描述

    复习Predicate接口

    此前我们已经学习过java.util.stream.Predicate函数式接口,其中唯一的抽象方法为:

    boolean test(T t);
    

    该方法将会产生一个boolean值结果,代表指定的条件是否满足。如果结果为true,那么Stream流的filter方法将会留用元素;如果结果为false,那么filter方法将会舍弃元素。

    基本使用

    Stream流中的filter方法基本使用的代码如:

    import java.util.stream.Stream;
    
    public class Demo07StreamFilter {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.filter(s -> s.startsWith("张"));
        }
    }
    

    在这里通过Lambda表达式来指定了筛选的条件:必须姓张。

    映射:map

    如果需要将流中的元素映射到另一个流中,可以使用map方法。方法签名:

    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    

    该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。

    在这里插入图片描述

    复习Function接口

    此前我们已经学习过java.util.stream.Function函数式接口,其中唯一的抽象方法为:

    R apply(T t);
    

    这可以将一种T类型转换成为R类型,而这种转换的动作,就称为“映射”。

    基本使用

    Stream流中的map方法基本使用的代码如:

    import java.util.stream.Stream;
    
    public class Demo08StreamMap {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("10", "12", "18");
            Stream<Integer> result = original.map(str->Integer.parseInt(str));
        }
    }
    

    这段代码中,map方法的参数通过方法引用,将字符串类型转换成为了int类型(并自动装箱为Integer类对象)。

    统计个数:count

    正如旧集合Collection当中的size方法一样,流提供count方法来数一数其中的元素个数:

    long count();
    

    该方法返回一个long值代表元素个数(不再像旧集合那样是int值)。基本使用:

    import java.util.stream.Stream;
    
    public class Demo09StreamCount {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.filter(s -> s.startsWith("张"));
            System.out.println(result.count()); // 2
        }
    }
    

    取用前几个:limit

    limit方法可以对流进行截取,只取用前n个。方法签名:

    Stream<T> limit(long maxSize);
    

    参数是一个long型,如果集合当前长度大于参数则进行截取;否则不进行操作。基本使用:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wZEg33ql-1595494895060)(img\limit语法.jpg)]

    import java.util.stream.Stream;
    
    public class Demo10StreamLimit {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.limit(2);
            System.out.println(result.count()); // 2
        }
    }
    

    跳过前几个:skip

    如果希望跳过前几个元素,可以使用skip方法获取一个截取之后的新流:

    Stream<T> skip(long n);
    

    如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。基本使用:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QoFZEkFN-1595494895062)(img\skip语法.jpg)]

    import java.util.stream.Stream;
    
    public class Demo11StreamSkip {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.skip(2);
            System.out.println(result.count()); // 1
        }
    }
    

    组合:concat

    如果有两个流,希望合并成为一个流,那么可以使用Stream接口的静态方法concat

    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
    

    备注:这是一个静态方法,与java.lang.String当中的concat方法是不同的。

    该方法的基本使用代码如:

    import java.util.stream.Stream;
    
    public class Demo12StreamConcat {
        public static void main(String[] args) {
            Stream<String> streamA = Stream.of("张无忌");
            Stream<String> streamB = Stream.of("张翠山");
            Stream<String> result = Stream.concat(streamA, streamB);
        }
    }
    

    1.5 练习:集合元素处理(传统方式)

    题目

    现在有两个ArrayList集合存储队伍当中的多个成员姓名,要求使用传统的for循环(或增强for循环)依次进行以下若干操作步骤:

    1. 第一个队伍只要名字为3个字的成员姓名;存储到一个新集合中。
    2. 第一个队伍筛选之后只要前3个人;存储到一个新集合中。
    3. 第二个队伍只要姓张的成员姓名;存储到一个新集合中。
    4. 第二个队伍筛选之后不要前2个人;存储到一个新集合中。
    5. 将两个队伍合并为一个队伍;存储到一个新集合中。
    6. 根据姓名创建Person对象;存储到一个新集合中。
    7. 打印整个队伍的Person对象信息。

    两个队伍(集合)的代码如下:

    import java.util.ArrayList;
    import java.util.List;
    
    public class DemoArrayListNames {
        public static void main(String[] args) {
           //第一支队伍
            ArrayList<String> one = new ArrayList<>();
    
            one.add("迪丽热巴");
            one.add("宋远桥");
            one.add("苏星河");
            one.add("石破天");
            one.add("石中玉");
            one.add("老子");
            one.add("庄子");
            one.add("洪七公");
    
            //第二支队伍
            ArrayList<String> two = new ArrayList<>();
            two.add("古力娜扎");
            two.add("张无忌");
            two.add("赵丽颖");
            two.add("张三丰");
            two.add("尼古拉斯赵四");
            two.add("张天爱");
            two.add("张二狗");
    		// ....
        }
    }
    

    Person类的代码为:

    public class Person {
        
        private String name;
    
        public Person() {}
    
        public Person(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Person{name='" + name + "'}";
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    解答

    既然使用传统的for循环写法,那么:

    public class DemoArrayListNames {
        public static void main(String[] args) {
            List<String> one = new ArrayList<>();
            // ...
    
            List<String> two = new ArrayList<>();
            // ...
    
            // 第一个队伍只要名字为3个字的成员姓名;
            List<String> oneA = new ArrayList<>();
            for (String name : one) {
                if (name.length() == 3) {
                    oneA.add(name);
                }
            }
    
            // 第一个队伍筛选之后只要前3个人;
            List<String> oneB = new ArrayList<>();
            for (int i = 0; i < 3; i++) {
                oneB.add(oneA.get(i));
            }
    
            // 第二个队伍只要姓张的成员姓名;
            List<String> twoA = new ArrayList<>();
            for (String name : two) {
                if (name.startsWith("张")) {
                    twoA.add(name);
                }
            }
    
            // 第二个队伍筛选之后不要前2个人;
            List<String> twoB = new ArrayList<>();
            for (int i = 2; i < twoA.size(); i++) {
                twoB.add(twoA.get(i));
            }
    
            // 将两个队伍合并为一个队伍;
            List<String> totalNames = new ArrayList<>();
            totalNames.addAll(oneB);
            totalNames.addAll(twoB);
    
            // 根据姓名创建Person对象;
            List<Person> totalPersonList = new ArrayList<>();
            for (String name : totalNames) {
                totalPersonList.add(new Person(name));
            }
    
            // 打印整个队伍的Person对象信息。
            for (Person person : totalPersonList) {
                System.out.println(person);
            }
        }
    }
    

    运行结果为:

    Person{name='宋远桥'}
    Person{name='苏星河'}
    Person{name='石破天'}
    Person{name='张天爱'}
    Person{name='张二狗'}
    

    1.6 练习:集合元素处理(Stream方式)

    题目

    将上一题当中的传统for循环写法更换为Stream流式处理方式。两个集合的初始内容不变,Person类的定义也不变。

    解答

    等效的Stream流式处理代码为:

    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Stream;
    
    public class DemoStreamNames {
        public static void main(String[] args) {
            List<String> one = new ArrayList<>();
            // ...
    
            List<String> two = new ArrayList<>();
            // ...
    
            // 第一个队伍只要名字为3个字的成员姓名;
            // 第一个队伍筛选之后只要前3个人;
            Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
    
            // 第二个队伍只要姓张的成员姓名;
            // 第二个队伍筛选之后不要前2个人;
            Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);
    
            // 将两个队伍合并为一个队伍;
            // 根据姓名创建Person对象;
            // 打印整个队伍的Person对象信息。
            Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
        }
    }
    

    运行效果完全一样:

    Person{name='宋远桥'}
    Person{name='苏星河'}
    Person{name='石破天'}
    Person{name='张天爱'}
    Person{name='张二狗'}
    

    第二章 方法引用

    在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑?

    2.1 冗余的Lambda场景

    来看一个简单的函数式接口以应用Lambda表达式:

    @FunctionalInterface
    public interface Printable {
      	void print(String str);
    }
    

    Printable接口当中唯一的抽象方法print接收一个字符串参数,目的就是为了打印显示它。那么通过Lambda来使用它的代码很简单:

    public class Demo01PrintSimple {
        private static void printString(Printable data) {
          	data.print("Hello, World!");
        }
    
        public static void main(String[] args) {
          	printString(s -> System.out.println(s));
        }
    }
    

    其中printString方法只管调用Printable接口的print方法,而并不管print方法的具体实现逻辑会将字符串打印到什么地方去。而main方法通过Lambda表达式指定了函数式接口Printable的具体操作方案为:拿到String(类型可推导,所以可省略)数据后,在控制台中输出它

    2.2 问题分析

    这段代码的问题在于,对字符串进行控制台打印输出的操作方案,明明已经有了现成的实现,那就是System.out对象中的println(String)方法。既然Lambda希望做的事情就是调用println(String)方法,那何必自己手动调用呢?

    2.3 用方法引用改进代码

    能否省去Lambda的语法格式(尽管它已经相当简洁)呢?只要“引用”过去就好了:

    public class Demo02PrintRef {
        private static void printString(Printable data) {
            data.print("Hello, World!");
        }
    
        public static void main(String[] args) {
          	printString(System.out::println);
        }
    }
    

    请注意其中的双冒号::写法,这被称为“方法引用”,而双冒号是一种新的语法。

    2.4 方法引用符

    双冒号::为引用运算符,而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中,那么则可以通过双冒号来引用该方法作为Lambda的替代者。

    语义分析

    例如上例中,System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。那么对于printString方法的函数式接口参数,对比下面两种写法,完全等效:

    • Lambda表达式写法:s -> System.out.println(s);
    • 方法引用写法:System.out::println

    第一种语义是指:拿到参数之后经Lambda之手,继而传递给System.out.println方法去处理。

    第二种等效写法的语义是指:直接让System.out中的println方法来取代Lambda。两种写法的执行效果完全一样,而第二种方法引用的写法复用了已有方案,更加简洁。

    注:Lambda 中 传递的参数 一定是方法引用中 的那个方法可以接收的类型,否则会抛出异常

    推导与省略

    如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用,也是同样可以根据上下文进行推导。

    函数式接口是Lambda的基础,而方法引用是Lambda的孪生兄弟。

    下面这段代码将会调用println方法的不同重载形式,将函数式接口改为int类型的参数:

    @FunctionalInterface
    public interface PrintableInteger {
      	void print(int str);
    }
    

    由于上下文变了之后可以自动推导出唯一对应的匹配重载,所以方法引用没有任何变化:

    public class Demo03PrintOverload {
        private static void printInteger(PrintableInteger data) {
          	data.print(1024);
        }
    
        public static void main(String[] args) {
          	printInteger(System.out::println);
        }
    }
    

    这次方法引用将会自动匹配到println(int)的重载形式。

    2.5 通过对象名引用成员方法

    这是最常见的一种用法,与上例相同。如果一个类中已经存在了一个成员方法:

    public class MethodRefObject {
        public void printUpperCase(String str) {
          	System.out.println(str.toUpperCase());
        }
    }
    

    函数式接口仍然定义为:

    @FunctionalInterface
    public interface Printable {
      	void print(String str);
    }
    

    那么当需要使用这个printUpperCase成员方法来替代Printable接口的Lambda的时候,已经具有了MethodRefObject类的对象实例,则可以通过对象名引用成员方法,代码为:

    public class Demo04MethodRef {
        private static void printString(Printable lambda) {
          	lambda.print("Hello");
        }
    
        public static void main(String[] args) {
            MethodRefObject obj = new MethodRefObject();
            printString(obj::printUpperCase);
        }
    }
    

    2.6 通过类名称引用静态方法

    由于在java.lang.Math类中已经存在了静态方法abs,所以当我们需要通过Lambda来调用该方法时,有两种写法。首先是函数式接口:

    @FunctionalInterface
    public interface Calcable {
      	int calc(int num);
    }
    

    第一种写法是使用Lambda表达式:

    public class Demo05Lambda {
        private static void method(int num, Calcable lambda) {
          	System.out.println(lambda.calc(num));
        }
    
        public static void main(String[] args) {
          	method(-10, n -> Math.abs(n));
        }
    }
    

    但是使用方法引用的更好写法是:

    public class Demo06MethodRef {
        private static void method(int num, Calcable lambda) {
          	System.out.println(lambda.calc(num));
        }
    
        public static void main(String[] args) {
          	method(-10, Math::abs);
        }
    }
    

    在这个例子中,下面两种写法是等效的:

    • Lambda表达式:n -> Math.abs(n)
    • 方法引用:Math::abs

    2.7 通过super引用成员方法

    如果存在继承关系,当Lambda中需要出现super调用时,也可以使用方法引用进行替代。首先是函数式接口:

    @FunctionalInterface
    public interface Greetable {
      	void greet();
    }
    

    然后是父类Human的内容:

    public class Human {
        public void sayHello() {
          	System.out.println("Hello!");
        }
    }
    

    最后是子类Man的内容,其中使用了Lambda的写法:

    public class Man extends Human {
        @Override
        public void sayHello() {
            System.out.println("大家好,我是Man!");
        }
    
        //定义方法method,参数传递Greetable接口
        public void method(Greetable g){
            g.greet();
        }
    
        public void show(){
            //调用method方法,使用Lambda表达式
            method(()->{
                //创建Human对象,调用sayHello方法
                new Human().sayHello();
            });
            //简化Lambda
            method(()->new Human().sayHello());
            //使用super关键字代替父类对象
            method(()->super.sayHello());
        }
    }
    

    但是如果使用方法引用来调用父类中的sayHello方法会更好,例如另一个子类Woman

    public class Man extends Human {
        @Override
        public void sayHello() {
            System.out.println("大家好,我是Man!");
        }
    
        //定义方法method,参数传递Greetable接口
        public void method(Greetable g){
            g.greet();
        }
    
        public void show(){
            method(super::sayHello);
        }
    }
    

    在这个例子中,下面两种写法是等效的:

    • Lambda表达式:() -> super.sayHello()
    • 方法引用:super::sayHello

    2.8 通过this引用成员方法

    this代表当前对象,如果需要引用的方法就是当前类中的成员方法,那么可以使用“this::成员方法”的格式来使用方法引用。首先是简单的函数式接口:

    @FunctionalInterface
    public interface Richable {
       	void buy();
    }
    

    下面是一个丈夫Husband类:

    public class Husband {
        private void marry(Richable lambda) {
          	lambda.buy();
        }
    
        public void beHappy() {
          	marry(() -> System.out.println("买套房子"));
        }
    }
    

    开心方法beHappy调用了结婚方法marry,后者的参数为函数式接口Richable,所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了,则可以对Husband丈夫类进行修改:

    public class Husband {
        private void buyHouse() {
          	System.out.println("买套房子");
        }
    
        private void marry(Richable lambda) {
          	lambda.buy();
        }
    
        public void beHappy() {
          	marry(() -> this.buyHouse());
        }
    }
    

    如果希望取消掉Lambda表达式,用方法引用进行替换,则更好的写法为:

    public class Husband {
        private void buyHouse() {
          	System.out.println("买套房子");
        }
    
        private void marry(Richable lambda) {
          	lambda.buy();
        }
    
        public void beHappy() {
          	marry(this::buyHouse);
        }
    }
    

    在这个例子中,下面两种写法是等效的:

    • Lambda表达式:() -> this.buyHouse()
    • 方法引用:this::buyHouse

    2.9 类的构造器引用

    由于构造器的名称与类名完全一样,并不固定。所以构造器引用使用类名称::new的格式表示。首先是一个简单的Person类:

    public class Person {
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    然后是用来创建Person对象的函数式接口:

    public interface PersonBuilder {
        Person buildPerson(String name);
    }
    

    要使用这个函数式接口,可以通过Lambda表达式:

    public class Demo09Lambda {
        public static void printName(String name, PersonBuilder builder) {
          	System.out.println(builder.buildPerson(name).getName());
        }
    
        public static void main(String[] args) {
          	printName("赵丽颖", name -> new Person(name));
        }
    }
    

    但是通过构造器引用,有更好的写法:

    public class Demo10ConstructorRef {
        public static void printName(String name, PersonBuilder builder) {
          	System.out.println(builder.buildPerson(name).getName());
        }
    
        public static void main(String[] args) {
          	printName("赵丽颖", Person::new);
        }
    }
    

    在这个例子中,下面两种写法是等效的:

    • Lambda表达式:name -> new Person(name)
    • 方法引用:Person::new

    2.10 数组的构造器引用

    数组也是Object的子类对象,所以同样具有构造器,只是语法稍有不同。如果对应到Lambda的使用场景中时,需要一个函数式接口:

    @FunctionalInterface
    public interface ArrayBuilder {
      	int[] buildArray(int length);
    }
    

    在应用该接口的时候,可以通过Lambda表达式:

    public class Demo11ArrayInitRef {   
        private static int[] initArray(int length, ArrayBuilder builder) {
          	return builder.buildArray(length);
        }
    
        public static void main(String[] args) {
          	int[] array = initArray(10, length -> new int[length]);
        }
    }
    

    但是更好的写法是使用数组的构造器引用:

    public class Demo12ArrayInitRef {
        private static int[] initArray(int length, ArrayBuilder builder) {
          	return builder.buildArray(length);
        }
    
        public static void main(String[] args) {
          	int[] array = initArray(10, int[]::new);
        }
    }
    

    在这个例子中,下面两种写法是等效的:

    • Lambda表达式:length -> new int[length]
    • 方法引用:int[]::new
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,132
精华内容 452
关键字:

学不会怎么办