精华内容
下载资源
问答
  • java详细学习路线路线

    万次阅读 多人点赞 2018-05-20 16:15:02
    java详细路线: 原文出自点击打开链接 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? ...

     

     

    java详细路线:

     

    原文出自点击打开链接

    本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢?

    路线

    Java发展到现在,按应用来分主要分为三大块:J2SE,J2ME和J2EE。

    这三块相互补充,应用范围不同。

    J2SE就是Java2的标准版,主要用于桌面应用软件的编程;

    J2ME主要应用于嵌入是系统开发,如手机和PDA的编程;

    J2EE是Java2的企业版,主要用于分布式的网络程序的开发,如电子商务网站和ERP系统。

    先学习j2se

    要学习j2ee就要先学习j2se,刚开始学习j2se先建议不要使用IDE,然后渐渐的过渡到使用IDE开发,毕竟用它方便嘛。学习j2se推荐两本书,《java2核心技术一二卷》,《java编程思想》,《java模式》。其中《java编程思想》要研读,精读。这一段时间是基本功学习,时间会很长,也可能很短,这要看学习者自身水平而定。

    不要被IDE纠缠

    在学习java和j2ee过程中,你会遇到五花八门的IDE,不要被他们迷惑,学JAVA的时候,要学语言本身的东西,不要太在意IDE的附加功能,JAVA编程在不同IDE之间的转换是很容易的,过于的在意IDE的功能反而容易耽误对语言本身的理解。目前流行的IDE有jbuilder,eclipse和eclipse的加强版WSAD。用好其中一个就可以了,推荐从eclipse入手j2ee。因为Jbuilder更适合于写j2se程序。

    选择和学习服务器使用配置

    当你有了j2se和IDE的经验时,可以开始j2ee的学习了,web服务器:tomcat,勿庸置疑,tomcat为学习web服务首选。而应用服务器目前主要有三个:jboss、weblogic、websphere。有很多项目开始采用jboss,并且有大量的公司开始做websphere或weblogic向jboss应用服务器的移植(节省成本),这里要说的是,学习tomcat和jboss我认为是首选,也是最容易上手的。学习服务器使用配置最好去询问有经验的人(有条件的话),因为他们或许一句话就能解决问题,你自己上网摸索可能要一两天(我就干过这种傻事),我们应该把主要时间放在学习原理和理论上,一项特定技术的使用永远代替不了一个人的知识和学问。

    学习web知识

    如果你是在做电子商务网站等时,你可能要充当几个角色,这是你还要学习:

    html,可能要用到vscode或者webstorm或者sublime或者等IDE。

    Javascript,学会简单的数据校验,数据联动显示等等。

    J2eeAPI学习

    学习j2eeAPI和学习服务器应该是一个迭代的过程。

    先学习jsp和servlet编程,这方面的书很多,我建立看oreilly公司的两本《jsp设计》和《java servlet编程》,oreilly出的书总是那本优秀,不得不佩服。

    学习jdbc数据库编程,j2ee项目大多都是MIS系统,访问数据库是核心。这本应属于j2se学习中,这里拿出来强调一下。

    学习jndi api,它和学习ejb可以结合起来。

    学习ejb api,推荐书《精通ejb》

    经过上面的这些的学习,大概可以对付一般的应用了。

    有人说跟着sun公司的《j2ee tutorial》一路学下来,当然也可以。

    学习ejb设计模式和看代码(最重要)

    设计模式是练内功,其重要性可以这么说吧,如果你不会用设计模式的话,你将写出一堆使用了ejb的垃圾,有慢又是一堆bug,其结果不如不用ejb实现(ejb不等于j2ee)

    无论学习什么语言,都应该看大量代码,你看的代码量不到一定数量,是学不好j2ee的。

    目前有很多开源的工程可以作为教材:

    jive论坛

    petstore sun公司

    dune sun公司

    等等,研读一个,并把它用到自己的工程中来。

    J2ee其他学习

    当你渐渐对j2ee了解到一定深度时,你要开始关注当前领域中的一些技术变化,J2ee是一块百家争鸣的领域,大家都在这里提出自己的解决方案,例如structs,hiberate,ofbiz等等,学习这些东西要你的项目和目标而定,预先补充一下未尝不可,但不用涉及太深,毕竟学习原理和理论是最最重要的事。

    目前常见j2eeAPI

    JavaServer Pages(JSP)技术1.2

    Java Servlet技术2.3

    JDBC API 2.0

    Java XML处理API(JAXP)1.1

    Enterprise JavaBeans技术2.0

    Java消息服务(JMS)1.0

    Java命名目录接口(JNDI)1.2

    Java事务API(JTA) 1.0

    JavaMail API 1.2

    JavaBeans激活架构(JAF)1.0

    J2EE连接器体系结构(JCA)1.0

    Java认证和授权服务(JAAS)1.0

    学习上面的某些API要以你的项目而定,了解所有他们总之是有好处的。

    上面印证了大家说的一句话,java语言本身不难学,但是技术太多,所以学java很费劲。回想一下,基本上每个初学者,在刚学习java的时候可能都会问别人这么一句话,你怎么知道的哪个方法(api)在哪个包里的?呵呵,无他,唯手熟尔。

    1 基础是王道。我们的基础要扎实扎实再扎实。

    以上面的整个流程来看java的技术分支很多,要想完全掌握是绝对不可能的。我们只有从中精通1到2个部分。但是java也是有通性的,所谓万变不离其宗。java的所有编程思路都是“面向对象”的编程。所以大家在往更高境界发展以前一定要打好基础,这样不管以后是jree还是j3d都有应刃而解的感觉。在这里强烈推荐“java编程思想”.

    2 所谓打好基础并不是说要熟悉所有的java代码。我说的意思是要了解java的结构。class,methode,object,各种套用import,extend 让自己在结构上对java有个立体而且整体的了解即刻。其实java的学习不用固执于对代码的熟悉,1来java本身带有很多demo,java2d

    的所有问题几乎都有demo的样例。2来java是开放代码,即使没有demo网络上也有很多高手把自己的代码分享。所以不要怕没有参考,参考是到处都有的。

    3 最后还有1点经验和大家分享,对sun的api一定要学会活用,不论是学习还是作为参考api都有很大的帮助,在完全了解java的结构的基础上,不论什么方法都是可以通过api来找到的.所以不要怕找不到方法,了解结构,了解api就能找到方法。

    重点

    精通:能够掌握此技术的85%技术要点以上,使用此技术时间超过两年,并使用此技术成功实施5个以上的项目。能使用此技术优化性能或代码,做到最大可能的重用。

    熟练:能够掌握此技术的60%技术要点以上,使用此技术时间超过一年,并使用此技术成功实施3个以上的项目。能使用此技术实现软件需求并有经验的积累在实现之前能做优化设计尽可能的实现模块或代码的重用。

    熟悉:能够掌握此技术的50%技术要点以上,使用此技术时间超过半年上,并使用此技术成功实施1个以上的项目。能使用此技术实现软件需求。

    了解:可以在实际需要时参考技术文档或帮助文件满足你的需要,基本知道此项技术在你运用是所起的作用,能够调用或者使用其根据规定提供给你的调用方式。

    二:基本要求

    1:html 掌握程度:熟练。原因:不会html你可能写JSP?

    2:javascript/jscript:掌握程度:熟悉。原因:client端的数据校验、一些页面处理需要你使用脚本。

    3:CSS 掌握程度:熟悉。原因:实现页面风格的统一通常会使用css去实现。

    4:java基础编程 掌握程度:熟练。原因:不会java你能写JSP?开玩笑吧。还有你必须非常熟悉以下几个包java.lang;java.io;java.sql;java.util;java.text;javax.sevrlet;javax.servlet.http; javax.mail;等。

    5:sql 掌握程度:熟练。原因:如果你不使用数据库的话你也许不需要掌握sql。同时你必须对以下几种数据库中的一种以上的sql比较熟悉。Oracle,DB2,Mysql,Postgresql.

    6:xml 掌握程度:了解 原因:AppServer的配置一般是使用XML来实现的。

    7:ejb 掌握程度:了解 原因:很多项目中商业逻辑是由ejb来实现的,所以呢„„

    8:以下几种AppServer(engnier) 你需要了解一个以上。

    a:)Tomcat b:)WebLogic c:)WebSphere d:)JRun e:)Resin 原因:你的jsp跑在什么上面啊!

    三:选择要求(因项目而定)

    1:LDAP 掌握程度:了解 原因:LADP越来越多的运用在权限控制上面。

    2:Struts 掌握程度:熟练 原因:如果符合MVC设计通常会使用Struts实现C。

    3:Xsp 掌握程度:根据需要而定很多时候是不使用的,但在不需要使用ejb但jsp+servlet+bean实现不了的时候Xsp是一个非常不错的选择。

    4:Linux 掌握程度:熟悉 原因:如果你的运用跑在Linux/Unix上你最少要知道rm ,mv,cp,vi,tar gzip/gunzip 是用来做什么的吧。

    四:工具的使用 1:UltraEdit(EditPlus)+jakarta-ant+jakarta-log4j; 2:Jubilder4-6 3:Visual Age For Java 4:VCafe

    以上的工具你选择你自己熟悉的吧。不过强烈建议你用log4j做调试工具。

    五:成长之路

    1:html 学习时间,如果你的智商在80以上,15天时间应该够用了。至少你能手写出一个页面来。

    2:jacascript/jscript学习时间,这真的不好说,比较深奥的东西,够用的话一个礼拜可以学写皮毛。

    3:css 学习时间,三天的时间你应该知道如何使用css了,不要求你写,一般是美工来写css。

    4:java 学习时间,天才也的三个月吧。慢满学吧。如果要精通,那我不知道需要多少时间了。用来写

    jsp,四个月应该够了。

    5:sql 学习时间,只需要知道insert ,delete ,update ,select,create/drop table的话一天你应该知道了。

    6:xml 学习时间,我不知道我还没有学会呢。呵呵。不过我知道DTD是用来做什么的。

    7:ejb 学习时间,基本的调用看3天你会调用了。不过是建立在你学会java的基础上的。

    8:熟悉AppServer,Tomcat四天你可以掌握安装,配置。把jsp跑起来了。如果是WebLogic也够了,但要使用ejb那不关你的事情吧。SA做什么去了。

    9:熟悉Linux那可得需要不少时间。慢慢看man吧。

    10:Struts如果需要你再学习。

    目标

    1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF,J2EEDP)以及综合模式。你应该十分了解UML,尤其是class,object,interaction以及statediagrams。

    2. 你需要学习JAVA语言的基础知识以及它的核心类库(collections,serialization,streams, networking, multithreading,reflection,event,handling,NIO,localization,以及其他)。

    3.你应该了解JVM,classloaders,classreflect,以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。

    4. 如果你将要写客户端程序,你需要学习WEB的小应用程序(applet),必需掌握GUI设计的思想和方法,以及桌面程序的SWING,AWT, SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。

    5.你需要学习java数据库技术,如JDBCAPI并且会使用至少一种persistence/ORM构架,例如Hibernate,JDO, CocoBase,TopLink,InsideLiberator(国产JDO红工厂软件)或者iBatis。

    6.你还应该了解对象关系的阻抗失配的含义,以及它是如何影响业务对象的与关系型数据库的交互,和它的运行结果,还需要掌握不同的数据库产品运茫 热?oracle,mysql,mssqlserver。

    7.你需要学习JAVA的沙盒安全模式(classloaders,bytecodeverification,managers,policyandpermissions,

    codesigning, digitalsignatures,cryptography,certification,Kerberos,以及其他)还有不同的安全/认证 API,例如JAAS(JavaAuthenticationandAuthorizationService),JCE (JavaCryptographyExtension),JSSE(JavaSecureSocketExtension),以及JGSS (JavaGeneralSecurityService)。

    8.你需要学习Servlets,JSP,以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。

    9.你需要熟悉主流的网页框架,例如JSF,Struts,Tapestry,Cocoon,WebWork,以及他们下面的涉及模式,如MVC/MODEL2。

    10.你需要学习如何使用及管理WEB服务器,例如tomcat,resin,Jrun,并且知道如何在其基础上扩展和维护WEB程序。

    11.你需要学习分布式对象以及远程API,例如RMI和RMI/IIOP。

    12.你需要掌握各种流行中间件技术标准和与java结合实现,比如Tuxedo、CROBA,当然也包括javaEE本身。

    13.你需要学习最少一种的XMLAPI,例如JAXP(JavaAPIforXMLProcessing),JDOM(JavaforXMLDocumentObjectModel),DOM4J,或JAXR(JavaAPIforXMLRegistries)。

    14. 你应该学习如何利用JAVAAPI和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC),SAAJ (SOAPwithAttachmentsAPIforJava),JAXB(JavaArchitectureforXMLBinding),JAXM (JavaAPIforXMLMessaging), JAXR(JavaAPIforXMLRegistries),或者JWSDP(JavaWebServicesDeveloperPack)。

    15.你需要学习一门轻量级应用程序框架,例如Spring,PicoContainer,Avalon,以及它们的IoC/DI风格(setter,constructor,interfaceinjection)。

    16. 你需要熟悉不同的J2EE技术,例如JNDI(JavaNamingandDirectoryInterface),JMS (JavaMessageService),JTA/JTS(JavaTransactionAPI/JavaTransactionService), JMX (JavaManagementeXtensions),以及JavaMail。

    17.你需要学习企业级 JavaBeans(EJB)以及它们的不同组件模式:Stateless/StatefulSessionBeans,EntityBeans(包含 Bean- ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL),或者 Message-DrivenBeans(MDB)。

    18.你需要学习如何管理与配置一个J2EE应用程序服务器,如WebLogic,JBoss等,并且利用它的附加服务,例如簇类,连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。

    19.你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩

    写为AOP),以及他们的主流JAVA规格和执行。例如AspectJ和AspectWerkz。

    20. 你需要熟悉对不同有用的API和frame work等来为你服务。例如Log4J(logging/tracing),Quartz (scheduling),JGroups(networkgroupcommunication),JCache (distributedcaching), Lucene(full-textsearch),JakartaCommons等等。

    21.如果你将要对接或者正和旧的系统或者本地平台,你需要学习JNI (JavaNativeInterface) and JCA (JavaConnectorArchitecture)。

    22.你需要熟悉JINI技术以及与它相关的分布式系统,比如掌握CROBA。

    23.你需要JavaCommunityProcess(JCP)以及他的不同JavaSpecificationRequests(JSRs),例如Portlets(168),JOLAP(69),DataMiningAPI(73),等等。

    24.你应该熟练掌握一种JAVAIDE例如sunOne,netBeans,IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了:)

    25.JAVA(精确的说是有些配置)是冗长的,它需要很多的人工代码(例如EJB),所以你需要熟悉代码生成工具,例如XDoclet。

    26.你需要熟悉一种单元测试体系(JNunit),并且学习不同的生成、部署工具(Ant,Maven)。

    27.你需要熟悉一些在JAVA开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。

    28.你需要能够深入了解加熟练操作和配置不同的操作系统,比如GNU/linux,sunsolaris,macOS等,做为跨平台软件的开发者。

    29.你还需要紧跟java发展的步伐,比如现在可以深入的学习javaME,以及各种java新规范,技术的运用,如新起的web富客户端技术。

    30.你必需要对opensource有所了解,因为至少java的很多技术直接是靠开源来驱动发展的,如java3D技术。(BlogJava-Topquan's Blog)

    原文出自点击打开链接

    当然学习了基础知识,也少不了了解一些数据结构与算法

    数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容,如有错误,欢迎指出。

    为了便于描述,文中涉及到的代码部分都是用Java语言编写的,其实Java本身对常见的几种数据结构,线性表、栈、队列等都提供了较好的实现,就是我们经常用到的Java集合框架,有需要的可以阅读这篇文章。Java - 集合框架完全解析

    一、线性表
      1.数组实现
      2.链表
    二、栈与队列
    三、树与二叉树
      1.树
      2.二叉树基本概念
      3.二叉查找树
      4.平衡二叉树
      5.红黑树
    四、图
    五、总结
    

    一、线性表

    线性表是最常用且最简单的一种数据结构,它是n个数据元素的有限序列。

    实现线性表的方式一般有两种,一种是使用数组存储线性表的元素,即用一组连续的存储单元依次存储线性表的数据元素。另一种是使用链表存储线性表的元素,即用一组任意的存储单元存储线性表的数据元素(存储单元可以是连续的,也可以是不连续的)。

    数组实现

    数组是一种大小固定的数据结构,对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后,它的大小就无法改变了,但是当数组不能再存储线性表中的新元素时,我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。

    • 代码1 创建一个更大的数组来替换当前数组
    int[] oldArray = new int[10];
            
    int[] newArray = new int[20];
            
    for (int i = 0; i < oldArray.length; i++) {
        newArray[i] = oldArray[i];
    }
    
    // 也可以使用System.arraycopy方法来实现数组间的复制     
    // System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
            
    oldArray = newArray;
    
    • 代码2 在数组位置index上添加元素e
    //oldArray 表示当前存储元素的数组
    //size 表示当前元素个数
    public void add(int index, int e) {
    
        if (index > size || index < 0) {
            System.out.println("位置不合法...");
        }
    
        //如果数组已经满了 就扩容
        if (size >= oldArray.length) {
            // 扩容函数可参考代码1
        }
    
        for (int i = size - 1; i >= index; i--) {
            oldArray[i + 1] = oldArray[i];
        }
    
        //将数组elementData从位置index的所有元素往后移一位
        // System.arraycopy(oldArray, index, oldArray, index + 1,size - index);
    
        oldArray[index] = e;
    
        size++;
    }
    

    上面简单写出了数组实现线性表的两个典型函数,具体我们可以参考Java里面的ArrayList集合类的源码。数组实现的线性表优点在于可以通过下标来访问或者修改元素,比较高效,主要缺点在于插入和删除的花费开销较大,比如当在第一个位置前插入一个元素,那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加或者删除元素的效率,可以采用链式结构来实现线性表。

    链表

    链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成,这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next,Next指向下一个节点,这样当添加或者删除时,只需要改变相关节点的Next的指向,效率很高。

    单链表的结构

    下面主要用代码来展示链表的一些基本操作,需要注意的是,这里主要是以单链表为例,暂时不考虑双链表和循环链表。

    • 代码3 链表的节点
    class Node<E> {
    
        E item;
        Node<E> next;
        
        //构造函数
        Node(E element) {
           this.item = element;
           this.next = null;
       }
    }
    
    • 代码4 定义好节点后,使用前一般是对头节点和尾节点进行初始化
    //头节点和尾节点都为空 链表为空
    Node<E> head = null;
    Node<E> tail = null;
    
    • 代码5 空链表创建一个新节点
    //创建一个新的节点 并让head指向此节点
    head = new Node("nodedata1");
    
    //让尾节点也指向此节点
    tail = head;
    
    • 代码6 链表追加一个节点
    //创建新节点 同时和最后一个节点连接起来
    tail.next = new Node("node1data2");
    
    //尾节点指向新的节点
    tail = tail.next;
    
    • 代码7 顺序遍历链表
    Node<String> current = head;
    while (current != null) {
        System.out.println(current.item);
        current = current.next;
    }
    
    • 代码8 倒序遍历链表
    static void printListRev(Node<String> head) {
    //倒序遍历链表主要用了递归的思想
        if (head != null) {
            printListRev(head.next);
            System.out.println(head.item);
        }
    }
    
    • 代码 单链表反转
    //单链表反转 主要是逐一改变两个节点间的链接关系来完成
    static Node<String> revList(Node<String> head) {
    
        if (head == null) {
            return null;
        }
    
        Node<String> nodeResult = null;
    
        Node<String> nodePre = null;
        Node<String> current = head;
    
        while (current != null) {
    
            Node<String> nodeNext = current.next;
    
            if (nodeNext == null) {
                nodeResult = current;
            }
    
            current.next = nodePre;
            nodePre = current;
            current = nodeNext;
        }
    
        return nodeResult;
    }
    

    上面的几段代码主要展示了链表的几个基本操作,还有很多像获取指定元素,移除元素等操作大家可以自己完成,写这些代码的时候一定要理清节点之间关系,这样才不容易出错。

    链表的实现还有其它的方式,常见的有循环单链表,双向链表,循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点,整体构成一个链环。 双向链表 主要是节点中包含两个指针部分,一个指向前驱元,一个指向后继元,JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。

    二、栈与队列

    栈和队列也是比较常见的数据结构,它们是比较特殊的线性表,因为对于栈来说,访问、插入和删除元素只能在栈顶进行,对于队列来说,元素只能从队列尾插入,从队列头访问和删除。

    栈是限制插入和删除只能在一个位置上进行的表,该位置是表的末端,叫作栈顶,对栈的基本操作有push(进栈)和pop(出栈),前者相当于插入,后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表,即后进先出。

    栈的模型

    下面我们看一道经典题目,加深对栈的理解。

    关于栈的一道经典题目

    上图中的答案是C,其中的原理可以好好想一想。

    因为栈也是一个表,所以任何实现表的方法都能实现栈。我们打开JDK中的类Stack的源码,可以看到它就是继承类Vector的。当然,Stack是Java2前的容器类,现在我们可以使用LinkedList来进行栈的所有操作。

    队列

    队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。

    队列示意图

    我们可以使用链表来实现队列,下面代码简单展示了利用LinkedList来实现队列类。

    • 代码9 简单实现队列类
    public class MyQueue<E> {
    
        private LinkedList<E> list = new LinkedList<>();
    
        // 入队
        public void enqueue(E e) {
            list.addLast(e);
        }
    
        // 出队
        public E dequeue() {
            return list.removeFirst();
        }
    }
    

    普通的队列是一种先进先出的数据结构,而优先队列中,元素都被赋予优先级。当访问元素的时候,具有最高优先级的元素最先被删除。优先队列在生活中的应用还是比较多的,比如医院的急症室为病人赋予优先级,具有最高优先级的病人最先得到治疗。在Java集合框架中,类PriorityQueue就是优先队列的实现类,具体大家可以去阅读源码。

    三、树与二叉树

    树型结构是一类非常重要的非线性数据结构,其中以树和二叉树最为常用。在介绍二叉树之前,我们先简单了解一下树的相关内容。

    ** 树 是由n(n>=1)个有限节点组成一个具有层次关系的集合。它具有以下特点:每个节点有零个或多个子节点;没有父节点的节点称为节点;每一个非根节点有且只有一个 父节点 **;除了根节点外,每个子节点可以分为多个不相交的子树。

    树的结构

    二叉树基本概念

    • 定义

    二叉树是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。

    • 相关性质

    二叉树的每个结点至多只有2棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒。

    二叉树的第i层至多有2(i-1)个结点;深度为k的二叉树至多有2k-1个结点。

    一棵深度为k,且有2^k-1个节点的二叉树称之为** 满二叉树 **;

    深度为k,有n个节点的二叉树,当且仅当其每一个节点都与深度为k的满二叉树中,序号为1至n的节点对应时,称之为** 完全二叉树 **。

    • 三种遍历方法

    在二叉树的一些应用中,常常要求在树中查找具有某种特征的节点,或者对树中全部节点进行某种处理,这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成,根节点、左子树和右子树。如果限定先左后右,那么根据这三个部分遍历的顺序不同,可以分为先序遍历、中序遍历和后续遍历三种。

    (1) 先序遍历 若二叉树为空,则空操作,否则先访问根节点,再先序遍历左子树,最后先序遍历右子树。 (2) 中序遍历 若二叉树为空,则空操作,否则先中序遍历左子树,再访问根节点,最后中序遍历右子树。(3) 后序遍历 若二叉树为空,则空操作,否则先后序遍历左子树访问根节点,再后序遍历右子树,最后访问根节点。

    给定二叉树写出三种遍历结果

    • 树和二叉树的区别

    (1) 二叉树每个节点最多有2个子节点,树则无限制。 (2) 二叉树中节点的子树分为左子树和右子树,即使某节点只有一棵子树,也要指明该子树是左子树还是右子树,即二叉树是有序的。 (3) 树决不能为空,它至少有一个节点,而一棵二叉树可以是空的。

    上面我们主要对二叉树的相关概念进行了介绍,下面我们将从二叉查找树开始,介绍二叉树的几种常见类型,同时将之前的理论部分用代码实现出来。

    二叉查找树

    • 定义

    二叉查找树就是二叉排序树,也叫二叉搜索树。二叉查找树或者是一棵空树,或者是具有下列性质的二叉树: (1) 若左子树不空,则左子树上所有结点的值均小于它的根结点的值;(2) 若右子树不空,则右子树上所有结点的值均大于它的根结点的值;(3) 左、右子树也分别为二叉排序树;(4) 没有键值相等的结点。

    典型的二叉查找树的构建过程

    • 性能分析

    对于二叉查找树来说,当给定值相同但顺序不同时,所构建的二叉查找树形态是不同的,下面看一个例子。

    不同形态平衡二叉树的ASL不同

    可以看到,含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下,当先后插入的关键字有序时,构成的二叉查找树蜕变为单支树,树的深度为n,其平均查找长度(n+1)/2(和顺序查找相同),最好的情况是二叉查找树的形态和折半查找的判定树相同,其平均查找长度和log2(n)成正比。平均情况下,二叉查找树的平均查找长度和logn是等数量级的,所以为了获得更好的性能,通常在二叉查找树的构建过程需要进行“平衡化处理”,之后我们将介绍平衡二叉树和红黑树,这些均可以使查找树的高度为O(log(n))。

    • 代码10 二叉树的节点
    
    class TreeNode<E> {
    
        E element;
        TreeNode<E> left;
        TreeNode<E> right;
    
        public TreeNode(E e) {
            element = e;
        }
    }
    

    二叉查找树的三种遍历都可以直接用递归的方法来实现:

    • 代码12 先序遍历
    protected void preorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        System.out.println(root.element + " ");
    
        preorder(root.left);
    
        preorder(root.right);
    }
    
    • 代码13 中序遍历
    protected void inorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        inorder(root.left);
    
        System.out.println(root.element + " ");
    
        inorder(root.right);
    }
    
    • 代码14 后序遍历
    protected void postorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        postorder(root.left);
    
        postorder(root.right);
    
        System.out.println(root.element + " ");
    }
    
    • 代码15 二叉查找树的简单实现
    /**
     * @author JackalTsc
     */
    public class MyBinSearchTree<E extends Comparable<E>> {
    
        // 根
        private TreeNode<E> root;
    
        // 默认构造函数
        public MyBinSearchTree() {
        }
    
        // 二叉查找树的搜索
        public boolean search(E e) {
    
            TreeNode<E> current = root;
    
            while (current != null) {
    
                if (e.compareTo(current.element) < 0) {
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    current = current.right;
                } else {
                    return true;
                }
            }
    
            return false;
        }
    
        // 二叉查找树的插入
        public boolean insert(E e) {
    
            // 如果之前是空二叉树 插入的元素就作为根节点
            if (root == null) {
                root = createNewNode(e);
            } else {
                // 否则就从根节点开始遍历 直到找到合适的父节点
                TreeNode<E> parent = null;
                TreeNode<E> current = root;
                while (current != null) {
                    if (e.compareTo(current.element) < 0) {
                        parent = current;
                        current = current.left;
                    } else if (e.compareTo(current.element) > 0) {
                        parent = current;
                        current = current.right;
                    } else {
                        return false;
                    }
                }
                // 插入
                if (e.compareTo(parent.element) < 0) {
                    parent.left = createNewNode(e);
                } else {
                    parent.right = createNewNode(e);
                }
            }
            return true;
        }
    
        // 创建新的节点
        protected TreeNode<E> createNewNode(E e) {
            return new TreeNode(e);
        }
    
    }
    
    // 二叉树的节点
    class TreeNode<E extends Comparable<E>> {
    
        E element;
        TreeNode<E> left;
        TreeNode<E> right;
    
        public TreeNode(E e) {
            element = e;
        }
    }
    
    

    上面的代码15主要展示了一个自己实现的简单的二叉查找树,其中包括了几个常见的操作,当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂,所以下面我详细介绍一下这里。

    • 二叉查找树中删除节点分析

    要在二叉查找树中删除一个元素,首先需要定位包含该元素的节点,以及它的父节点。假设current指向二叉查找树中包含该元素的节点,而parent指向current节点的父节点,current节点可能是parent节点的左孩子,也可能是右孩子。这里需要考虑两种情况:

    1. current节点没有左孩子,那么只需要将patent节点和current节点的右孩子相连。
    2. current节点有一个左孩子,假设rightMost指向包含current节点的左子树中最大元素的节点,而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值,将parentOfRightMost节点和rightMost节点的左孩子相连,然后删除rightMost节点。
        // 二叉搜索树删除节点
        public boolean delete(E e) {
    
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
    
            // 找到要删除的节点的位置
            while (current != null) {
                if (e.compareTo(current.element) < 0) {
                    parent = current;
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    parent = current;
                    current = current.right;
                } else {
                    break;
                }
            }
    
            // 没找到要删除的节点
            if (current == null) {
                return false;
            }
    
            // 考虑第一种情况
            if (current.left == null) {
                if (parent == null) {
                    root = current.right;
                } else {
                    if (e.compareTo(parent.element) < 0) {
                        parent.left = current.right;
                    } else {
                        parent.right = current.right;
                    }
                }
            } else { // 考虑第二种情况
                TreeNode<E> parentOfRightMost = current;
                TreeNode<E> rightMost = current.left;
                // 找到左子树中最大的元素节点
                while (rightMost.right != null) {
                    parentOfRightMost = rightMost;
                    rightMost = rightMost.right;
                }
    
                // 替换
                current.element = rightMost.element;
    
                // parentOfRightMost和rightMost左孩子相连
                if (parentOfRightMost.right == rightMost) {
                    parentOfRightMost.right = rightMost.left;
                } else {
                    parentOfRightMost.left = rightMost.left;
                }
            }
    
            return true;
        }
    

    平衡二叉树

    平衡二叉树又称AVL树,它或者是一棵空树,或者是具有下列性质的二叉树:它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度之差的绝对值不超过1。

    平衡二叉树

    AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1,所以它也被称为高度平衡树,n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

    红黑树

    红黑树是平衡二叉树的一种,它保证在最坏情况下基本动态集合操作的事件复杂度为O(log n)。红黑树和平衡二叉树区别如下:(1) 红黑树放弃了追求完全平衡,追求大致平衡,在与平衡二叉树的时间复杂度相差不大的情况下,保证每次插入最多只需要三次旋转就能达到平衡,实现起来也更为简单。(2) 平衡二叉树追求绝对平衡,条件比较苛刻,实现起来比较麻烦,每次插入新节点之后需要旋转的次数不能预知。点击查看更多

    四、图

    • 简介

    图是一种较线性表和树更为复杂的数据结构,在线性表中,数据元素之间仅有线性关系,在树形结构中,数据元素之间有着明显的层次关系,而在图形结构中,节点之间的关系可以是任意的,图中任意两个数据元素之间都可能相关。图的应用相当广泛,特别是近年来的迅速发展,已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

    • 相关阅读

    因为图这部分的内容还是比较多的,这里就不详细介绍了,有需要的可以自己搜索相关资料。

    (1) 《百度百科对图的介绍》
    (2) 《数据结构之图(存储结构、遍历)》

    这篇文章是常见数据结构与算法整理总结的下篇,上一篇主要是对常见的数据结构进行集中总结,这篇主要是总结一些常见的算法相关内容,文章中如有错误,欢迎指出。

    一、概述
    二、查找算法
    三、排序算法
    四、其它算法
    五、常见算法题
    六、总结
    

    一、概述

    以前看到这样一句话,语言只是工具,算法才是程序设计的灵魂。的确,算法在计算机科学中的地位真的很重要,在很多大公司的笔试面试中,算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升,花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。

    算法简介

    算法是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决,可能会存在着不同的算法,为了衡量一个算法的优劣,提出了空间复杂度与时间复杂度这两个概念。

    时间复杂度

    一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数f(n),算法的时间度量记为 ** T(n) = O(f(n)) **,它表示随问题规模n的增大,算法执行时间的增长率和f(n)的增长率相同,称作算法的渐近时间复杂度,简称时间复杂度。这里需要重点理解这个增长率。

    举个例子,看下面3个代码:
    
    1、{++x;}
    
    2、for(i = 1; i <= n; i++) { ++x; }
    
    3、for(j = 1; j <= n; j++) 
            for(j = 1; j <= n; j++) 
                 { ++x; }
    
    上述含有 ++x 操作的语句的频度分别为1 、n 、n^2,
    
    假设问题的规模扩大了n倍,3个代码的增长率分别是1 、n 、n^2
    
    它们的时间复杂度分别为O(1)、O(n )、O(n^2)
    

    空间复杂度

    空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度,记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

    二、查找算法

    查找和排序是最基础也是最重要的两类算法,熟练地掌握这两类算法,并能对这些算法的性能进行分析很重要,这两类算法中主要包括二分查找、快速排序、归并排序等等。

    顺序查找

    顺序查找又称线性查找。它的过程为:从查找表的最后一个元素开始逐个与给定关键字比较,若某个记录的关键字和给定值比较相等,则查找成功,否则,若直至第一个记录,其关键字和给定值比较都不等,则表明表中没有所查记录查找不成功,它的缺点是效率低下。

    二分查找

    • 简介

    二分查找又称折半查找,对于有序表来说,它的优点是比较次数少,查找速度快,平均性能好。

    二分查找的基本思想是将n个元素分成大致相等的两部分,取a[n/2]与x做比较,如果x=a[n/2],则找到x,算法中止;如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x。

    二分查找的时间复杂度为O(logn)

    • 实现
    //给定有序查找表array 二分查找给定的值data
    //查找成功返回下标 查找失败返回-1
    
    static int funBinSearch(int[] array, int data) {
    
        int low = 0;
        int high = array.length - 1;
    
        while (low <= high) {
    
            int mid = (low + high) / 2;
    
            if (data == array[mid]) {
                return mid;
            } else if (data < array[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }
    

    三、排序算法

    排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列。下面主要对一些常见的排序算法做介绍,并分析它们的时空复杂度。

    常见排序算法

    常见排序算法性能比较:

    图片来自网络

    上面这张表中有稳定性这一项,排序的稳定性是指如果在排序的序列中,存在前后相同的两个元素的话,排序前和排序后他们的相对位置不发生变化。

    下面从冒泡排序开始逐一介绍。

    冒泡排序

    • 简介

    冒泡排序的基本思想是:设排序序列的记录个数为n,进行n-1次遍历,每次遍历从开始位置依次往后比较前后相邻元素,这样较大的元素往后移,n-1次遍历结束后,序列有序。

    例如,对序列(3,2,1,5)进行排序的过程是:共进行3次遍历,第1次遍历时先比较3和2,交换,继续比较3和1,交换,再比较3和5,不交换,这样第1次遍历结束,最大值5在最后的位置,得到序列(2,1,3,5)。第2次遍历时先比较2和1,交换,继续比较2和3,不交换,第2次遍历结束时次大值3在倒数第2的位置,得到序列(1,2,3,5),第3次遍历时,先比较1和2,不交换,得到最终有序序列(1,2,3,5)。

    需要注意的是,如果在某次遍历中没有发生交换,那么就不必进行下次遍历,因为序列已经有序。

    • 实现
    // 冒泡排序 注意 flag 的作用
    static void funBubbleSort(int[] array) {
    
        boolean flag = true;
    
        for (int i = 0; i < array.length - 1 && flag; i++) {
    
            flag = false;
    
            for (int j = 0; j < array.length - 1 - i; j++) {
    
                if (array[j] > array[j + 1]) {
    
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
    
                    flag = true;
                }
            }
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
    
    • 分析

    最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序,不需要进行下一次遍历,所以最佳情况下,时间复杂度为** O(n) **。

    最坏情况下冒泡排序需要n-1次遍历,第一次遍历需要比较n-1次,第二次遍历需要n-2次,...,最后一次需要比较1次,最差情况下时间复杂度为** O(n^2) **。

    简单选择排序

    • 简介

    简单选择排序的思想是:设排序序列的记录个数为n,进行n-1次选择,每次在n-i+1(i = 1,2,...,n-1)个记录中选择关键字最小的记录作为有效序列中的第i个记录。

    例如,排序序列(3,2,1,5)的过程是,进行3次选择,第1次选择在4个记录中选择最小的值为1,放在第1个位置,得到序列(1,3,2,5),第2次选择从位置1开始的3个元素中选择最小的值2放在第2个位置,得到有序序列(1,2,3,5),第3次选择因为最小的值3已经在第3个位置不需要操作,最后得到有序序列(1,2,3,5)。

    • 实现
    static void funSelectionSort(int[] array) {
    
        for (int i = 0; i < array.length - 1; i++) {
    
            int mink = i;
    
                // 每次从未排序数组中找到最小值的坐标
            for (int j = i + 1; j < array.length; j++) {
    
                if (array[j] < array[mink]) {
                    mink = j;
                }
            }
    
            // 将最小值放在最前面
            if (mink != i) {
                int temp = array[mink];
                array[mink] = array[i];
                array[i] = temp;
            }
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    
    • 分析

    简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时,需进行n-1次比较;当i=2时,需进行n-2次比较;依次类推,共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2,即进行比较操作的时间复杂度为 O(n^2) ,进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。

    最好情况下,即待排序记录初始状态就已经是正序排列了,则不需要移动记录。最坏情况下,即待排序记录初始状态是按第一条记录最大,之后的记录从小到大顺序排列,则需要移动记录的次数最多为3(n-1)。

    简单选择排序是不稳定排序。

    直接插入排序

    • 简介

    直接插入的思想是:是将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增1的有序表。

    例如,排序序列(3,2,1,5)的过程是,初始时有序序列为(3),然后从位置1开始,先访问到2,将2插入到3前面,得到有序序列(2,3),之后访问1,找到合适的插入位置后得到有序序列(1,2,3),最后访问5,得到最终有序序列(1,2,3,5).

    • 实现
    static void funDInsertSort(int[] array) {
    
        int j;
    
        for (int i = 1; i < array.length; i++) {
    
            int temp = array[i];
    
            j = i - 1;
    
            while (j > -1 && temp < array[j]) {
    
                array[j + 1] = array[j];
    
                j--;
            }
    
            array[j + 1] = temp;
    
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    
    • 分析

    最好情况下,当待排序序列中记录已经有序时,则需要n-1次比较,不需要移动,时间复杂度为** O(n) 。最差情况下,当待排序序列中所有记录正好逆序时,则比较次数和移动次数都达到最大值,时间复杂度为 O(n^2) 。平均情况下,时间复杂度为 O(n^2) **。

    希尔排序

    希尔排序又称“缩小增量排序”,它是基于直接插入排序的以下两点性质而提出的一种改进:(1) 直接插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。点击查看更多关于希尔排序的内容

    归并排序

    • 简介

    归并排序是分治法的一个典型应用,它的主要思想是:将待排序序列分为两部分,对每部分递归地应用归并排序,在两部分都排好序后进行合并。

    例如,排序序列(3,2,8,6,7,9,1,5)的过程是,先将序列分为两部分,(3,2,8,6)和(7,9,1,5),然后对两部分分别应用归并排序,第1部分(3,2,8,6),第2部分(7,9,1,5),对两个部分分别进行归并排序,第1部分继续分为(3,2)和(8,6),(3,2)继续分为(3)和(2),(8,6)继续分为(8)和(6),之后进行合并得到(2,3),(6,8),再合并得到(2,3,6,8),第2部分进行归并排序得到(1,5,7,9),最后合并两部分得到(1,2,3,5,6,7,8,9)。

    • 实现
        //归并排序
        static void funMergeSort(int[] array) {
    
            if (array.length > 1) {
    
                int length1 = array.length / 2;
                int[] array1 = new int[length1];
                System.arraycopy(array, 0, array1, 0, length1);
                funMergeSort(array1);
    
                int length2 = array.length - length1;
                int[] array2 = new int[length2];
                System.arraycopy(array, length1, array2, 0, length2);
                funMergeSort(array2);
    
                int[] datas = merge(array1, array2);
                System.arraycopy(datas, 0, array, 0, array.length);
            }
    
        }
    
        //合并两个数组
        static int[] merge(int[] list1, int[] list2) {
    
            int[] list3 = new int[list1.length + list2.length];
    
            int count1 = 0;
            int count2 = 0;
            int count3 = 0;
    
            while (count1 < list1.length && count2 < list2.length) {
    
                if (list1[count1] < list2[count2]) {
                    list3[count3++] = list1[count1++];
                } else {
                    list3[count3++] = list2[count2++];
                }
            }
    
            while (count1 < list1.length) {
                list3[count3++] = list1[count1++];
            }
    
            while (count2 < list2.length) {
                list3[count3++] = list2[count2++];
            }
    
            return list3;
        }
    
    • 分析

    归并排序的时间复杂度为O(nlogn),它是一种稳定的排序,java.util.Arrays类中的sort方法就是使用归并排序的变体来实现的。

    快速排序

    • 简介

    快速排序的主要思想是:在待排序的序列中选择一个称为主元的元素,将数组分为两部分,使得第一部分中的所有元素都小于或等于主元,而第二部分中的所有元素都大于主元,然后对两部分递归地应用快速排序算法。

    • 实现
    // 快速排序
    static void funQuickSort(int[] mdata, int start, int end) {
        if (end > start) {
            int pivotIndex = quickSortPartition(mdata, start, end);
            funQuickSort(mdata, start, pivotIndex - 1);
            funQuickSort(mdata, pivotIndex + 1, end);
        }
    }
    
    // 快速排序前的划分
    static int quickSortPartition(int[] list, int first, int last) {
    
        int pivot = list[first];
        int low = first + 1;
        int high = last;
    
        while (high > low) {
    
            while (low <= high && list[low] <= pivot) {
                low++;
            }
    
            while (low <= high && list[high] > pivot) {
                high--;
            }
    
            if (high > low) {
                int temp = list[high];
                list[high] = list[low];
                list[low] = temp;
            }
        }
    
        while (high > first && list[high] >= pivot) {
            high--;
        }
    
        if (pivot > list[high]) {
            list[first] = list[high];
            list[high] = pivot;
            return high;
        } else {
            return first;
        }
    }
    
    • 分析

    在快速排序算法中,比较关键的一个部分是主元的选择。在最差情况下,划分由n个元素构成的数组需要进行n次比较和n次移动,因此划分需要的时间是O(n)。在最差情况下,每次主元会将数组划分为一个大的子数组和一个空数组,这个大的子数组的规模是在上次划分的子数组的规模上减1,这样在最差情况下算法需要(n-1)+(n-2)+...+1= ** O(n^2) **时间。

    最佳情况下,每次主元将数组划分为规模大致相等的两部分,时间复杂度为** O(nlogn) **。

    堆排序

    • 简介

    在介绍堆排序之前首先需要了解堆的定义,n个关键字序列K1,K2,…,Kn称为堆,当且仅当该序列满足如下性质(简称为堆性质):(1) ki <= k(2i)且 ki <= k(2i+1) (1 ≤ i≤ n/2),当然,这是小根堆,大根堆则换成>=号。

    如果将上面满足堆性质的序列看成是一个完全二叉树,则堆的含义表明,完全二叉树中所有的非终端节点的值均不大于(或不小于)其左右孩子节点的值。

    堆排序的主要思想是:给定一个待排序序列,首先经过一次调整,将序列构建成一个大顶堆,此时第一个元素是最大的元素,将其和序列的最后一个元素交换,然后对前n-1个元素调整为大顶堆,再将其第一个元素和末尾元素交换,这样最后即可得到有序序列。

    • 实现
    //堆排序
    public class TestHeapSort {
    
        public static void main(String[] args) {
            int arr[] = { 5, 6, 1, 0, 2, 9 };
            heapsort(arr, 6);
            System.out.println(Arrays.toString(arr));
        }
    
        static void heapsort(int arr[], int n) {
    
            // 先建大顶堆
            for (int i = n / 2 - 1; i >= 0; i--) {
                heapAdjust(arr, i, n);
            }
    
            for (int i = 0; i < n - 1; i++) {
                swap(arr, 0, n - i - 1);
                heapAdjust(arr, 0, n - i - 1);
            }
        }
    
        // 交换两个数
        static void swap(int arr[], int low, int high) {
            int temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
        }
    
        // 调整堆
        static void heapAdjust(int arr[], int index, int n) {
    
            int temp = arr[index];
    
            int child = 0;
    
            while (index * 2 + 1 < n) {
                            
                child = index * 2 + 1;
                            
                // child为左右孩子中较大的那个
                if (child != n - 1 && arr[child] < arr[child + 1]) {
                    child++;
                }
                // 如果指定节点大于较大的孩子 不需要调整
                if (temp > arr[child]) {
                    break;
                } else {
                    // 否则继续往下判断孩子的孩子 直到找到合适的位置
                    arr[index] = arr[child];
                    index = child;
                }
            }
    
            arr[index] = temp;
        }
    }
    
    
    • 分析

    由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn),空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比,堆排序在最差情况下的时间复杂度优于快排,空间效率高于归并排序。

    四、其它算法

    在上面的篇幅中,主要是对查找和常见的几种排序算法作了介绍,这些内容都是基础的但是必须掌握的内容,尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。(这里不禁想起百度一面的时候让我写二分查找和堆排序,二分查找还行,然而堆排序当时一脸懵逼...)下面主要是介绍一些常见的其它算法。

    递归

    • 简介

    在平常解决一些编程或者做一些算法题的时候,经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。

    • 经典例子

    斐波那契数列,又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入,故又称为“兔子数列”,指的是这样一个数列:0、1、1、2、3、5、8、13、21、34、……在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2,n∈N*)。

    //斐波那契数列 递归实现
    static long funFib(long index) {
    
        if (index == 0) {
            return 0;
        } else if (index == 1) {
            return 1;
        } else {
            return funFib(index - 1) + funFib(index - 2);
        }
    }
    

    上面代码是斐波那契数列的递归实现,然而我们不难得到它的时间复杂度是O(2^n),递归有时候可以很方便地解决一些问题,但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式,效率比递归方法的效率高。

    static long funFib2(long index) {
    
        long f0 = 0;
        long f1 = 1;
        long f2 = 1;
    
        if (index == 0) {
            return f0;
        } else if (index == 1) {
            return f1;
        } else if (index == 2) {
            return f2;
        }
    
        for (int i = 3; i <= index; i++) {
            f0 = f1;
            f1 = f2;
            f2 = f0 + f1;
        }
    
        return f2;
    }
    

    分治算法

    分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题,递归地求解这些子问题,然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。查看更多关于分治算法的内容

    动态规划

    动态规划与分治方法相似,都是通过组合子问题的解来求解待解决的问题。但是,分治算法将问题划分为互不相交的子问题,递归地求解子问题,再将它们的解组合起来,而动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容

    动态规划典型的一个例子是最长公共子序列问题。

    常见的算法还有很多,比如贪心算法,回溯算法等等,这里都不再详细介绍,想要熟练掌握,还是要靠刷题,刷题,刷题,然后总结。

    五、常见算法题

    下面是一些常见的算法题汇总。

    不使用临时变量交换两个数

    static void funSwapTwo(int a, int b) {
    
        a = a ^ b;
        b = b ^ a;
        a = a ^ b;
    
        System.out.println(a + " " + b);
    }
    

    判断一个数是否为素数

    static boolean funIsPrime(int m) {
    
        boolean flag = true;
    
        if (m == 1) {
            flag = false;
        } else {
    
            for (int i = 2; i <= Math.sqrt(m); i++) {
                if (m % i == 0) {
                    flag = false;
                    break;
                }
            }
        }
    
        return flag;
    }
    

    其它算法题

    1、15道使用频率极高的基础算法题
    2、二叉树相关算法题
    3、链表相关算法题
    4、字符串相关算法问题

     

    点击下方链接即可查看相关资料

    Java 技术书籍大全本文档目前已收录 277本 Java相关领域经典技术书籍,从初级开发者到资深架构师,涵盖 Java 从业者的各个阶段,并持续更新。涵盖领域:Java入门书籍,Java基础及进阶书籍,框架与中间件,架构设计,设计模式,数学与算法,JVM周边语言,项目管理&领导力&流程,职业素养与个人成长

     

    数据结构与算法原文出自简书尘语凡心常见数据结构与算法整理总结

    当然作为后端也要掌握一些架构师技术图谱

    阿里云学生机1年114元限时活动(24岁以下都可以购买)https://promotion.aliyun.com/ntms/act/campus2018.html?userCode=a6violqw阿里云1888元红包:https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=a6violqw

    最后可以关注我的个人网站了解更多

    展开全文
  • 从入门到精通,Java学习路线导航

    万次阅读 多人点赞 2019-09-09 11:00:25
    当然,这里我只是说Java学习路线,因为自己就是学Java的,对Java理当很熟悉,对于其它方面,我也不是很了解。 基础阶段 首先是基础阶段,在基础阶段,我们必须掌握Java基础,Mysql数据库,Ora...

    引言

    最近也有很多人来向我"请教",他们大都是一些刚入门的新手,还不了解这个行业,也不知道从何学起,开始的时候非常迷茫,实在是每天回复很多人也很麻烦,所以在这里统一作个回复吧。

    Java学习路线

    当然,这里我只是说Java学习路线,因为自己就是学Java的,对Java理当很熟悉,对于其它方面,我也不是很了解。

    基础阶段

    首先是基础阶段,在基础阶段,我们必须掌握Java基础,Mysql数据库,Oracle数据库,JDBC,Linux基础,Java8新特性,数据结构和算法,设计模式。
    对于基础阶段,我们所要掌握的就是基础,虽然是基础,但学起来也够呛。因为是初学者,所以基础阶段会有一点难度,但只要肯坚持,这些也没什么难的。对于Linux、数据结构、算法和设计模式我们掌握一些基础就行了,也没必要学得非常透彻。

    Web基础

    基础阶段过后,我们还必须要掌握一些Web方面的知识,Html,JavaScript,JQuery和AJax,同样的,对于这些知识,我们只需掌握基础,而不需要深究,否则,你将耗费大量的时间。

    JavaWeb

    Web阶段过后,当然就是JavaWeb了,对于JavaWeb,我们需要掌握的知识有:Servlet,JSP,MVC设计模式,Cookie,Session,JavBean组件技术,EL表达式,JSTL表达式,过滤器Filter,监听器Listener,文件的上传下载,国际化。

    JavaEE

    最后是JavaEE阶段,当你学到这个阶段,你对Java的程序开发已经了如指掌。然而,自己开发的过程是艰难而复杂的,所以JavaEE阶段我们需要去学习一些非常优秀的框架,来帮助我们进行程序开发。
    对于框架,我们需要学习Struts2,Hibernate,Spring,SpringMVC,JPA,SpringData,MyBatis,Spring Boot,Spring Cloud,Dubbo。要学习的框架其实非常多,有些框架也十分有难度,我们在学习阶段只要能够熟练使用它们即可,有能力的话可以研究一下源码,看看框架的底层实现。当然,除了框架,我们还需要学习Maven,Git,Github,ActiveMQ,Jenkins等。
    在JavaEE阶段学习的东西是最多的,但如果你经历了JavaEE阶段的学习,你的编程水平将会有质的飞跃。

    其它

    这里是我在写了这篇文章几天后才加上的,有人向我反映,说数据结构和算法不学好就只能当个码农,说我在文章中指出"只需学习数据结构和算法的基础即可"是误导别人。确实,这句话是没说错,我在之前的文章中也强调过数据结构和算法的重要性,它们是程序的灵魂。然而,数据结构和算法是具有一定难度的,对于新手可能非常地不友好,新手要想彻底掌握它们是很困难的,所以我只是说在基础阶段掌握基础即可,而不需要去深究。而随着学习的深入,你的知识体系将会越来越庞大,这个时候,对于数据结构和算法可不能仅仅停留在表面了,我们应该去更加深入地研究这些东西。
    在这里也感谢大家给我提出的意见,只要大家说的在理,说的是对的,我都会去及时改正。金无足赤,人无完人,在写文章的过程中,难免会有一些不太严谨的地方,这里也欢迎大家批评指正。

    学习资源

    我知道,对于有些名词,你们可能都没有听过。没关系,按照这个路线一点一点地往下学,相信你会感受到编程的魅力所在。
    下面对整条知识路线进行一个梳理,并附上对应的学习资源,需要的小伙伴们下载就好了。

    1. 基础阶段
      Java基础——链接:链接:https://pan.baidu.com/s/17yh-M7LYSRsXmFeQKSrAww 提取码:mqf4

      Mysql数据库——链接:https://pan.baidu.com/s/1NfS6Q9fb_OMna608w9GYeg 提取码:94ns

      Oracle数据库——链接:https://pan.baidu.com/s/12uVSvaY4pbXRWy2DtIIf8w 提取码:5r8p

      JDBC——链接:https://pan.baidu.com/s/1QF9S_GpucFvoLSrQqV6d0Q 提取码:ltnh

      Linux基础——链接:https://pan.baidu.com/s/1e0ekEVjmtfNWAEO0123wDw 提取码:pwxz

      Java8新特性——链接:https://pan.baidu.com/s/103nPGgEEjbxzuy1rHRJepg 提取码:6omt

      Java数据结构和算法——链接:https://pan.baidu.com/s/1LQ__Hp7i-TR7gRa4YJQXJg 提取码:zwwd

      Java设计模式——链接:https://pan.baidu.com/s/1ik7PRwlAVgJzhSCdthdu1A 提取码:nr5e
    2. Web阶段
      JavaScript DOM——链接:https://pan.baidu.com/s/1_HtKFXeRm5xF7p2vYk_c7w 提取码:ks6g

      JQuery——链接:https://pan.baidu.com/s/1IPPNu2qsJ-MgLX7mGcVYbQ 提取码:umdr
      AJAX——链接:https://pan.baidu.com/s/1MC1iryOq9_SSV1qWYk5P5Q 提取码:78hu
    3. JavaWeb
      JavaWeb阶段——链接:https://pan.baidu.com/s/1EJYIgAuAHhaJLv8Pp-QjgA 提取码:584f
    4. JavaEE
      JavaEE阶段全套视频——链接:https://pan.baidu.com/s/1rJ5MyvFMuN_cbDVbw-2B3A 提取码:mdlf

    课件及源代码

    文章发布过后,有很多人来问我有没有源码和课件,这里当然是有的,为了方便大家,我就把源码和课件链接放在这里,也不用劳烦大家一直问了。
    链接:https://pan.baidu.com/s/18fr2-Hy-0aoRr9wDIl1zbg 提取码:2zxp

    关于Java学习路线上的所有资源都在这里了,欢迎大家下载!

    马上就要到中秋佳节了,在这里也提前祝贺各位中秋节快乐,身体健康,阖家欢乐!

    2021年01月06日更新

    因为百度网盘自身的一些原因,导致这些资源经常出现失效的现象,而且资源数目比较多,维护起来比较麻烦,所以我特地将所有资源进行了一个整合,上面的所有学习资源都在这个链接里面:

    链接:https://pan.baidu.com/s/1TZMtgDjxoNPa5SZm5Q6c9g
    提取码:h0dm

    展开全文
  • 爬虫微课5小时 Python学习路线

    万人学习 2018-07-10 13:28:05
    Python爬虫技术视频教程,该课程每堂课都有一个作业,包含的项目案例有家长帮142600条数据爬取与分析,全球天气数据抓取与分析,淘宝商品信息数据众数分析,12306余票查询,python软件打包exe与发布。...
  • Python学习路线

    万次阅读 多人点赞 2019-03-02 21:44:52
    经历长达近一个月的资源筛选过程终于结束,总共1.5T的资源经过:去重、筛选、整理、归档之后一份粗略的Python学习曲线资源已经成型,虽然中间经历了很多坎坷,不过最终还是完成,猪哥也是第一时间与大家分享出来。...

    此视频资源收集于网络,如有侵权请联系删除!!!
    此视频资源仅用作个人学习,请勿用于商业获利,造成后果自负!!!

    经历长达近一个月的资源筛选过程终于结束,总共1.5T百度网盘的资源经过:去重、筛选、整理、归档之后一份粗略的Python学习曲线资源已经成型,虽然中间经历了很多坎坷,不过最终还是完成,猪哥也是第一时间与大家分享出来。
    在这里插入图片描述
    资料主要分为两部分:一、各个学习网站论坛等,二、百度云资料。网站论坛资源更新快,可以与大家互动;而百度云资源主要为视频,方便大家下载和在线观看,两种资源结合使用,学习和查找知识更方便!

    一、网站论坛学习资源

    名称 链接 说明
    实验楼 https://www.shiyanlou.com 提供免费的Linux实验环境
    Py资源中文大全 http://t.cn/Rq0C0ET 各种python包和管理工具
    PEP8 Py编码规范中文版 https://dwz.cn/30uIzs9W 代码规范与基础同样重要
    Py Code Examples https://dwz.cn/dawtruYk 精细到方法级别的代码案例
    Py Module of the Week https://pymotw.com 每篇介绍一个 Py标准库的使用
    菜鸟教程 http://t.cn/RLGeMuW 最经典的一个语言教程网站
    廖雪峰Py教程 https://dwz.cn/drygpxjk 大牛带你简单快速入门
    Py自动化测试博客 https://dwz.cn/raopItkV 一个自动化测试大佬的博客
    Py中文学习大本营 http://www.pythondoc.com 一个不错的Flask学习网站
    刘江的Django https://dwz.cn/udQayyZY 最适合入门的Django教程
    莫烦Py https://morvanzhou.github.io 机器学习方面有着不错的造诣
    吴恩达机器学习 https://dwz.cn/F8Aad3DY 网易云课堂(中/英字幕)
    几个Py练习题 https://dwz.cn/ExJnmwOJ 有几个不错的实用练习题
    CheckiO https://py.checkio.org/ 一个学习Py的有趣网站

    二、学习曲线

    这个学习曲线是我在某马论坛上看到的,觉得不错就推荐给大家,同时也感谢某马的开源免费精神,猪哥也是受益颇多!
    在这里插入图片描述
    在这里插入图片描述

    三、优质资源

    我把这些资源分为了七个不同的阶段,难度是依次递增,其实就是对应上面学习曲线图;

    本资源一共800G,永久保存,并且会持续更新,建议大家转发收藏,方便以后查找学习;
    在这里插入图片描述
    这是猪哥推荐的Python学习曲线,基本上是某马的视频教程,这个学习曲线适合零基础的同学:
    在这里插入图片描述

    四、获取方式

    1. 链接:https://pan.baidu.com/s/18gY3J5t2xZPU6zSDWP09RA 密码:j8wk
    2. 如果链接失效,微信扫描下方二维码,关注猪哥微信公众号,回复:学习曲线 即可获取新链接!
      在这里插入图片描述

    五、猪哥有话说

    昨天看到一则新闻“19岁少年培训被坑而自杀”,当时真的很愤怒!!!这也使得猪哥更加坚定的坚持免费分享的原则,如果你觉得此文章好请分享给你的每一位朋友:也许你一个不经意的善意之举,却是他人人生的一个转折点。

    在这里插入图片描述

    展开全文
  • Android学习路线指南

    万次阅读 多人点赞 2015-11-01 23:34:56
    前言 看到一篇文章中提到“最近几年国内的初级Android程序员已经很多了,但是中高级的Android技术人才仍然稀缺“,...这是一个问题,我不好回答,但是我想写一篇文章来描述下Android的学习路线,期望可以帮助更多的...

    前言

    看到一篇文章中提到“最近几年国内的初级Android程序员已经很多了,但是中高级的Android技术人才仍然稀缺“,这的确不假,从我在百度所进行的一些面试来看,找一个适合的高级Android工程师的确不容易,一般需要进行大量的面试才能挑选出一个比较满意的。为什么中高级Android程序员不多呢?这是一个问题,我不好回答,但是我想写一篇文章来描述下Android的学习路线,期望可以帮助更多的Android程序员提升自己。由于我也是从一个菜鸟过来的,所以我会结合我的个人经历以及我对Android学习过程的认识来写这篇文章,这会让这篇文章更加真实,而并非纸上谈兵。

    我的工作经历

    前面说到,我也是从一个Android菜鸟过来的。其实这句话放在任何人的身上都是适用的,即大家都是一步步过来的,因此作为初学者也不必因为技术差而郁闷,同理,高手也不要看不起一些所谓的菜鸟,因为这不公平,技术只有在同等的工作年限上才具有一定的可比性,也许你眼中的菜鸟只是个工作半年的新手,而你已经工作5年,可想而知,这根本不具有可比性,搞不好别人5年后可以达到比你更高的技术高度。

    我有若干个技术QQ群,群里(481798332)的小伙伴对我的工作经历比较感兴趣,刚好在这里我就做下介绍。我是硕士研究生毕业,我已经工作3年零3个月了,职位上从最开始的腾讯初级工程师变成了现在的百度Android资深工程师。最开始我并不是做Android的,先是做了半年的C++,接着做了3个月的Web前端,然后公司内部转岗做Android到至今,纯Android工作年限的话其实是2.5年。但是我认为我的Android工作经验(注:工作年限不等同于工作经验)不止2.5年,我投入大量的业余时间在Android开发上,并且我习惯去思考问题、总结问题并将其融会贯通,因此我的Android技术在短时间内有了很大的提升。

    在Android学习过程中,初学者踩过的坑我也都踩过,我也深深地知道大家在学习过程中最棘手的问题是什么。举个例子,在3年前,我想在SlidingMenu中放入一个ListView,发现二者总是不能很好地一起工作,这肯定是由于滑动冲突的问题,我也知道,但是不知道怎么解决。我就去学校图书馆翻遍了所有的Android书籍,无果。大家肯定都知道原因,为什么我无法从书中查找到问题的答案,因为入门书不讲滑动冲突,所谓的高级编程书也不讲。还有一个问题,我曾经以为view.post(runnable)可以让runnable的run方法在线程中执行,所以我就在run方法里面去做耗时的操作,现在想想我当时是多菜啊,因此我曾经也是菜鸟。

    直到若干年后的某一天,我终于琢磨透了滑动冲突的事,然后我就把解决问题的思想写在了CSDN博客上,但是好像看得人并不多,很多人并不能体会我的用心,后来我博客的访问量越来越大,这才慢慢地得到了一些人的关注。后来有一天我有了写书的契机,我想到了我最开始学习Android时所踩过的坑,想到滑动冲突对我的困扰,为了更好地传播我的技术经验,为了让更多的人少踩一些坑,为了让更多地人成为Android高级工程师,我毅然决定将Android开发中最重要的、最疑难的、最容易困扰大家的、成为高级工程师所必备的知识点和盘托出,这就是《Android开发艺术探索》存在的原因以及意义。书的反响怎么样呢?从目前读者的评价来看,内容基本无差评,我收到了很多读者的肯定以及感谢,这说明很多人能够理解我的用心。

    说了那么多,言归正传,下面说下Android学习路线的话题,本文打算从4个阶段来对Android的学习过程做一个全面的分析,分别为Android初级、中级、高级以及资深工程师,具体请看下面的分析。同理,本篇学习路线仍然只针对Android应用开发,不针对Rom开发和逆向工程等。这里虚拟一位“小明”的角色,在这里小明就是Android初学者的代表。

    初级工程师

    小明之前完全没接触过Android开发,是个应届生,他的待遇是13k,然后小明以校招的身份进入了百度,然后小明需要怎么学习才能成为初级工程师呢?这个时候,小明对编程基础、数据结构、C语言都有一定基础,Java语法什么的也都掌握的比较好,Android才有java语言,无奈的是小明并不会搞Android。

    小明首先需要购买一本Android入门的书籍,为了更快地学习Android,小明业余时间也都用来一边看书一边照着书中的例子敲代码,结果2周时间小明就把这本书学了一遍。看完这本书后,小明对Android的历史、结构、代码规范等都有了一个大概的了解,并且,小明已经可以写出一些简单的Activity了。这个时候在小明眼里,Android开发很简单很好玩,通过在xml中摆放一些按钮文本框什么的就可以做一些界面了。

    小明开始跟着他的技术导师做需求,一些简单的小需求小明自然是不在话下了。突然有一天来了一个需求,该需求要求小明在Activity中为一个button加一个动画效果,小明慌了:“完全没接触过,书上也没有讲,怎么办呢?”小明冷静了下,打开了百度搜索,输入“Android 动画”,打开前几个链接,小明恍然大悟,照着网上的例子把需求给实现了。后来导师告诉他:“学好Android,官方文档是必须看的,既全面又权威”。然后小明如获至宝,花了一年时间把上面的guide和training都看了一遍,并且他还动手抄了几个小例子。

    有一天,小明又需要做一个动画相关的需求,这可难不倒小明,它熟练地打开了www.baidu.com,输入“Android 动画”,突然他楞了一下:”总不能每次写动画都要百度一下吧!“,于是他在CSDN开了一个博客,把动画相关的知识点都写上去,为的是后面再写动画相关的代码就不用百度去搜了,事实如何呢?后面再写动画相关的代码,小明的确不用再去百度搜了,因为通过写一篇动画博客,他把动画相关的细节都已经记住了,这样他就可以不用再去参考任何文档了,后来小明还学会了把一些琐碎的不方便放在博客上的东西写到了印象笔记上面,什么时候忘了10秒钟以内都可以快速找回来,而不是花10分钟去再次搜索一遍。

    这里总结一下,Android入门的时候,需要有一本入门书,好好学习书中的内容,同时花一年时间把Android官方文档中的training和guide看一遍,同时通过写博客和记笔记的方式来做总结,建议让自己的每篇博客都有价值些。通过一年时间的学习,相信每个人都可以达到中级工程师的水平。

    技术要求:
    - 基本知识点
    比如四大组件如何使用、如何创建Service、如何进行布局、简单的自定义View、动画等常见技术
    - 书籍推荐
    《第一行代码 Android》、《疯狂Android》

    中级工程师

    小明经过一年的努力学习终于成为Android中级工程师了,月薪变成了17k。到了中级工程师,已经可以在公司里干很多体力活了,但是一些很重要的任务小明还不能一个人承担起来,这个时候小明需要学习的内容就很多了,如下所示:
    - AIDL:熟悉AIDL,理解其工作原理,懂transact和onTransact的区别;
    - Binder:从Java层大概理解Binder的工作原理,懂Parcel对象的使用;
    - 多进程:熟练掌握多进程的运行机制,懂Messenger、Socket等;
    - 事件分发:弹性滑动、滑动冲突等;
    - 玩转View:View的绘制原理、各种自定义View;
    - 动画系列:熟悉View动画和属性动画的不同点,懂属性动画的工作原理;
    - 懂性能优化、熟悉mat等工具
    - 懂点常见的设计模式

    学习方法

    阅读进阶书籍,阅读Android源码,阅读官方文档并尝试自己写相关的技术文章,需要有一定技术深度和自我思考。在这个阶段的学习过程中,有2个点是比较困扰大家的,一个是阅读源码,另一个是自定义View以及滑动冲突。

    如何阅读源码呢?这是个头疼的问题,但是源码必须要读。阅读源码的时候不要深入代码细节不可自拔,要关注代码的流程并尽量挖掘出对应用层开发有用的结论。另外仔细阅读源码中对一个类或者方法的注释,在看不懂源码时,源码中的注释可以帮你更好地了解源码中的工作原理,这个过程虽然艰苦,但是别无他法。

    如何玩转自定义View呢?我的建议是不要通过学习自定义view而学习自定义view。为什么这么说呢?因为自定义view的种类太多了,各式各样的绚丽的自定义效果,如何学的玩呢!我们要透过现象看本质,更多地去关注自定义view所需的知识点,这里做如下总结:
    - 搞懂view的滑动原理
    - 搞懂如何实现弹性滑动
    - 搞懂view的滑动冲突
    - 搞懂view的measure、layout和draw
    - 然后再学习几个已有的自定义view的例子
    - 最后就可以搞定自定义view了,所谓万变不离其宗

    大概再需要1-2年时间,即可达到高级工程师的技术水平。我个人认为通过《Android开发艺术探索》和《Android群英传》可以缩短这个过程为0.5-1年。注意,达到高级工程师的技术水平不代表就可以立刻成为高级工程师(受机遇、是否跳槽的影响),但是技术达到了,成为高级工程师只是很简单的事。

    技术要求:
    - 稍微深入的知识点
    AIDL、Messenger、Binder、多进程、动画、滑动冲突、自定义View、消息队列等
    - 书籍推荐
    《Android开发艺术探索》、《Android群英传》

    高级工程师

    小明成为了梦寐以求的高级工程师,月薪达到了20k,还拿到了一丢丢股票。这个时候小明的Android水平已经不错了,但是小明的目标是资深工程师,小明听说资深工程师月薪可以达到30k+。

    为了成为Android资深工程师,需要学习的东西就更多了,并且有些并不是那么具体了,如下所示:
    - 继续加深理解”稍微深入的知识点“中所定义的内容
    - 了解系统核心机制:
    1. 了解SystemServer的启动过程
    2. 了解主线程的消息循环模型
    3. 了解AMS和PMS的工作原理
    4. 能够回答问题”一个应用存在多少个Window?“
    5. 了解四大组件的大概工作流程
    6. …
    - 基本知识点的细节
    1. Activity的启动模式以及异常情况下不同Activity的表现
    2. Service的onBind和onReBind的关联
    3. onServiceDisconnected(ComponentName className)和binderDied()的区别
    4. AsyncTask在不同版本上的表现细节
    5. 线程池的细节和参数配置
    6. …
    - 熟悉设计模式,有架构意识

    学习方法

    这个时候已经没有太具体的学习方法了,无非就是看书、看源码和做项目,平时多种总结,尽量将知识融会贯通从而形成一种体系化的感觉。同时这个阶段对架构是有一定要求的,架构是抽象的,但是设计模式是具体的,所以一定要加强下设计模式的学习。关于设计模式的学习,最近一本新书推荐给大家《Android 源码设计模式解析与实战》,既可以学习设计模式,又可能体会到Android源码中的设计思想,我最近也在阅读此书。

    技术要求:
    - 稍微深入的知识点
    - 系统核心机制
    - 基本知识点的细节
    - 设计模式和架构
    - 书籍推荐
    《Android开发艺术探索》、《Android 源码设计模式解析与实战》、《Android内核剖析》

    资深工程师

    这个阶段的程序员也许并没有太具体的学习路线了。

    交流方式

    • QQ交流群:635778578
    • 欢迎关注我的公众号,会持续更新Android干货
      cover
    • 欢迎加入我的知识星球,一起学习交流
      cover
    展开全文
  • 说实话,对于学习路线这种文章我一般是不写的,大家看我的文章也知道,我是很少写建议别人怎么样怎么样的文章,更多的是,写自己的真实经历,然后供大家去参考,这样子,我内心也比较踏实,也不怕误导他人。...
  • 从入门到精通,Java学习路线导航(附学习资源)

    万次阅读 多人点赞 2019-09-16 17:34:06
    当然,这里我只是说Java学习路线,因为自己就是学Java的,对Java理当很熟悉,对于其它方面,我也不是很了解。 基础阶段 首先是基础阶段,在基础阶段,我们必须掌握Java基础,Mysql数据库,Ora...
  •         最近忙着做大数据的项目,故有一...突发奇想,想把当初自学python时收藏的关于python的14张思维导图和学习路线拿出来分享给许多同样处于"初级"阶段的各位攻城狮们。 ...
  • Java 学习路线

    万次阅读 多人点赞 2018-01-06 13:21:35
    对于入门java将近两年的时间,曾经迷惘过,一直想知道java的具体学习路线,看过了许许多多的java经验分享的帖子,评论,以及其他各种培训机构所谓的学习路线,发现没有一个符合我个人需求的学习路线,根据个人实际的...
  • Java学习路线(完整详细版)超详细

    万次阅读 多人点赞 2019-05-14 10:56:47
    一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • 前端学习路线

    万次阅读 多人点赞 2019-07-14 08:36:55
    前端综合体系 1. 知识技能类 前端技能汇总 ...2. 学习路线类 前端学习路线 —(阿里云大学) 一、初级篇 1. HTML学习 1.1 视频教程 初识HTML+CSS—(慕课网) ...
  • Java学习路线

    万次阅读 多人点赞 2019-07-11 22:17:33
    Java学习路线: Java基础 Java web Java框架 Java进阶 分布式
  • 软件开发者路线图:从学徒到高手

    千次下载 热门讨论 2014-01-27 11:01:44
    《软件开发者路线图:从学徒到高手》完整版,以前下载过6.3M那种,只有1、2章,此为完整版,旨在分享好东西
  • 大学四年,这个Java自习路线,让我现在进了阿里

    万次阅读 多人点赞 2020-02-28 00:23:49
    互联网浮沉多年,想给大家点干货,内附资源
  • JAVA学习路线(最全)

    万次阅读 多人点赞 2018-09-17 22:37:41
    JAVA学习路线
  • Android学习路线:如何成长为高级工程师

    万次阅读 多人点赞 2015-01-03 00:08:49
    点击给我投票前言之所以写这篇文章,是因为最近博客和我的开发群( 215680213 )中,不少小伙伴都让我讲讲android学习路线,所以我决定写一篇博客,来说明这个问题。既然有不少小伙伴来咨询这个问题,说明大家都...
  • C#学习路线

    万次阅读 多人点赞 2019-08-27 23:51:44
    C#学习路线 导读 有的初学者对于如何开始学习C#感到无从下手,不知看哪些书,或者是看什么视频,没有目的性,这样就会影响学习效率,也会影响学习的热情。最重要的是很多同学学之前问很多和学习无关的问题,比如:...
  • 大学四年零基础自学Java的路线

    万次阅读 多人点赞 2020-09-02 12:14:16
    屌丝逆袭,成神之路
  • 不少人对自己的学习路线表示迷茫,接下来教你使用GitHub来寻找自己的学习路线,不过有时候需要科学上网,不然大部分图片是无法显示的,这个是一个比较清晰的前后端学习路线,笔者转载在这, 那么如何查找自己的学习...
  • 2019全新Java学习路线图-分享

    万次阅读 多人点赞 2019-03-20 18:14:46
    2019年最新Java学习路线图,路线图的宗旨就是分享,专业,便利,让喜爱Java的人,都能平等的学习。从今天起不要再找借口,不要再说想学Java却没有资源,赶快行动起来,Java等你来探索,高薪距你只差一步! java...
  • Python最佳学习路线

    万次阅读 多人点赞 2019-01-17 16:46:45
    如何学习Python 最近开始整理python的资料,会陆续放到博客中存档。找了几个qq群,其中有一个群78486745。后面就没怎么加群了,还是需要看官方文档为主 python语言基础:(带你熟悉python语言的特性,学会使用...
  • Java入门学习路线目录索引(持续更新中)

    万次阅读 多人点赞 2019-10-08 16:33:09
    新增: 使用IDEA搭建SpringBoot框架整合Mybatis、MySQL、Thymeleaf实现用户查询、注册、登录 一、Java基础 Java基础-继承 Java基础-抽象 Java基础-接口 Java基础-多态 Java基础-重写 ... ...
  • BAT算法工程师的成长之路,超详细的学习路线

    千次阅读 多人点赞 2020-10-09 13:34:27
    算法的学习路线,主要分为 4 个部分:数学基础、编程能力、算法基础、实战。
  • Java学习路线从入门到入土

    万次阅读 多人点赞 2020-09-20 11:22:11
    Java学习路线从入门到入土 简介 一门永不过时的编程语言——Java 编程开发。Java编程语言占比:据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以900万的程序员数量位居首位。 而且很多软件的开发都离...
  • Linux C/C++ 学习路线

    万次阅读 多人点赞 2019-07-04 20:41:56
    一、秋招 Linux C/C++ offer 情况 ...Linux C/C++ 从零基础到大神的学习路线,自己的真实学习路线,干货很多,建议收藏,认真阅读。 在校期间,我一直走的都是 Linux C/C++ 学习路线,历经暑期实习、秋招决战、校...
  • 杭州最全登山路线

    万次阅读 2016-11-25 19:43:34
    以下十三条登山路线都是我亲自走过的路线。全部在百度地图上进行过标注。注意按照行进方向,所有都不需要买门票(半山灵隐寺后门下午4点半后没有查票的),反方向走有的景点收门票。 1.十里琅珰(龙井村–梅家坞)...
  • 经过这段时间的使用和研究,我发现点和点之间的最短路线并不是最优的。针对所有点的组合可能, 得到的最短路线才是最好的(也就是TSP方法),然后再结合点对点之间的距离进行比较,得到的才是相对最优方案。 举例...
  • Java后端学习路线图,你真的只需要这一张!

    万次阅读 多人点赞 2018-10-10 17:19:14
    学习路线图往往是学习一样技术的入门指南。网上搜到的Java学习路线图也是一抓一大把。 今天我只选一张图,仅此一图,足以包罗Java后端技术的知识点。所谓不求最好,但求最全,学习Java后端的同学完全可以参考这张图...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,098
精华内容 29,239
关键字:

路线