java工作中学习_java程序员工作中如何学习 - CSDN
  • 1、务必要学好Java基础; 2、学习更多的知识。这些内容主要是Web开发相关的内容,包括HTML/CSS/JS(前端页面)、Servlet/JSP(J2EE)以及Mysql(数据库)相关的知识。它们的学习顺序应该是从前到后,因此最先学习的...

    1、务必要学好Java基础;
    2、学习更多的知识。这些内容主要是Web开发相关的内容,包括HTML/CSS/JS(前端页面)、Servlet/JSP(J2EE)以及Mysql(数据库)相关的知识。它们的学习顺序应该是从前到后,因此最先学习的应该是HTML/CSS/JS(前端页面);
    3、学会使用开发工具,一步一步去学习,一定要多动手;
    4、学会使用数据库,mysql是个不错的入门选择,而且Java领域里主流的关系型数据库就是mysql。这部分一般在你学习Servlet/Jsp的时候,就会接触到的,其中的JDBC部分就是数据库相关的部分。你不仅要学会使用JDBC操作数据库,还要学会使用数据库客户端工具,比如navicat,sqlyog,二选一即可。
    5、学习一些开发框架。目前比较主流的是SSM框架,即spring、springmvc、mybatis。你需要学会这三个框架的搭建,并用它们做出一个简单的增删改查的Web项目。你可以不理解那些配置都是什么含义,以及为什么要这么做,这些留着后面你去了解。
    6、工作的同时,不应该停止学习。上面这些内容只是囫囵吞枣的学会了使用,应逐步尝试着去了解更多的东西;
    7、参加工作一年以内的同学。恭喜你,这个时候,你已经拥有了一份Java的工作。这个阶段是你成长极快的阶段,而且你可能会经常加班。但是加班不代表你就可以松懈了,从你入行那一刻起,你就要不停的学习;这个阶段的核心学习思想就是,在工作中实践,并且更加深入的了解Java基础。
    8、在这一年里,你至少需要看完《Java编程思想》这本书。这本书的内容是帮助你对于Java有一个更加深入的了解,是Java基础的升级版;
    9、对于参加工作1年到2年的同学。这部分时间段的同学,已经对Java有了一个更加深入的了解。但是对于面向对象的体会可能还不够深刻,编程的时候还停留在完成功能的层次,很少会去考虑设计的问题。于是这个时候,设计模式就来了。
    10、学习的过程是环环相扣的,如果你任何一个阶段拉下来了,那么你就真的跟不上了,或者说是一步慢步步慢;
    11、工作过程中或多或少接触过一些其它的技术,比如大数据、分布式缓存、分布式消息服务、分布式计算、软负载均衡等等。这些技术,你能精通任何一项,都将是你未来面试时巨大的优势,因此如果你对某一项技术感兴趣的话,这个时候可以深入去研究一下。这项技术不一定是你工作所用到的,但一定是相关的。而且在研究一门新技术时,切忌朝三暮四;
    12、作为一个程序猿,平日里所接触的技术可能会很多,但是想要让一门技术成为你的优势,那么一定是你对这门技术的了解强过绝大多数人才行。
    13、基础是很枯燥无味的,学的太早不仅容易懵逼,而且懵逼的同时还容易产生心理阴影,以至于以后再不想去研究这些基础。但基础又是你深入研究一些领域时所必须掌握的,比如你去研究分布式计算,你不懂算法肯定不行;
    14、在同等代价的情况下获取最大的收获;
    15、有了基础,有了前面的工作经验,你就可以去开拓属于你的领域了。在这一年里,一定要规划好自己的领域,建立好自己的优势,制造出差异性。如果你对自己的领域不够清晰的话,随着你工作的时间日益增多,你接触的技术会越来越多,这个时候,你很容易被淹死在技术的海洋里,看似接触的技术越来越多,会用的也越来越多,但你毫无优势。
    16、每个人吸收知识的时候,都要有抽取精华,去除糟粕的能力;
    【java学习路线】
    在这里插入图片描述在这里插入图片描述

    展开全文
  • 在博主认为,对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结,前三者博主将淋漓尽致地挥毫于这篇博客文章,至于总结在于个人,实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是...

    在博主认为,对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结,前三者博主将淋漓尽致地挥毫于这篇博客文章中,至于总结在于个人,实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍,博客次之,这又是一个层次了,这里暂时不提后面再谈。博主将为各位入门java保驾护航,各位只管冲鸭!!!上天是公平的,只要不辜负时间,时间自然不会辜负你。

    何谓学习?博主所理解的学习,它是一个过程,是一个不断累积、不断沉淀、不断总结、善于传达自己的个人见解以及乐于分享的过程。

    一、Java基础

    1、Java基础教学视频

    Java零基础教程视频(适合Java 0基础,Java初学入门)【推荐】

    JavaSE进阶入门项目实战视频教程_动力节点【推荐】

    毕向东Java基础视频教程25天【相对老旧,但也是金典啊!】

    说句实在的,博主当年大一下学期就是看的毕老师Java基础25天的视频,可谓金典啊!现在看来算是比较老旧了,可谓画质感人,若不是老毕的风趣,博主有种怎会坚持看完说句实在的,主要是当时没有学习资源才莫得办法,相比之下其余二者都是比较新颖的视频教程了,都是近一两年的没有质量博主也不会推荐鸭,对吧这个时候就会有童鞋要说了,怎么都是bilibili上的鸭?博主认为B站可谓是最大的学习网站了最重要的是免费免费免费!!!是的!加油学吧!上天是公平的,只要不辜负时间,时间自然不会辜负你。

    2、Java基础博客文章目录

    这些是博主近半个月重新总结的一些javase基础方面的博客,当然,学习总结!学习后才有的总结!建议哪里不懂点哪里进行参考

    解惑真小白的苦恼 | 类的对象,对象引用,对象实例,引用变量

    深入理解static关键字

    深入理解抽象类与接口

    【java基础之继承】java继承从“我爸是李刚”讲起

    【java基础之多态】理解多态的向上向下转型从“妈妈我想吃烤山药”讲起

    【java基础之代码块】Static静态代码块以及各代码块之间的执行顺序

    【java基础之异常】死了都要try,不淋漓尽致地catch我不痛快!

    【java基础之匿名内部类】程序员你真的理解匿名内部类吗?

    【java基础之tostring】为什么重写toString()方法?

    【java基础之泛型】泛型

    【java基础之反射】程序员你真的理解反射机制吗?

    java中的transient关键字详解

    史上最骚最全最详细的IO流教程,没有之一!

    【java基础之测试】序员你确定这十个题你都会吗?

    java抽象类(abstract)与接口(Interface)

    java面试官:兄弟简单谈谈Static、final、Static final各种用法吧

    java中的重载与重写

    Java静态static详解

    Java中equals与“==”的区别详解

    java基础之 “==”和“ equals”以及instanceof的区别

    Object类、Date类、System类、StringBuilder类、包装类

    什么是浮点型?什么是单精度浮点数(float)以及双精度浮点数(double)?

    java数组定义、使用、以及数组内存分析详解

    Collection集合以及Iterator迭代器实现原理

    List、Set集合系列之剖析HashSet存储原理(HashMap底层)

    Collection和Collections之间的使用与区别(顺带讲解Comparable与Comparator区别)

    Java中的多线程你只要看这一篇就够了

    当然,于此同时学习的过程光是看这些博客文章是不够的不太系统,不太完整,自黑++i,为了各位能够系统性学习,下面我贴出一份300页的Java基础教程笔记,可适当掺杂阅读。啥?300页?我靠,博主牛皮,博主赖斯,博主我要嫁给你!!!哎哎哎…博主我不禁夸不禁夸害羞 当然博主没有这个耐心整理写作300页笔记,还得感谢我的老师吧这是博主的老师整理的哈哈 唉哎哎…别打…别打…别打脸…我靠,咋还有扔臭鸡蛋的
    300页的Java基础教程链接:https://pan.baidu.com/s/1awgcwhF_SwMetLYcw-7gpg&shfl=sharepset
    提取码:xfn3

    以为就完了吗?就能入门了吗???

    就举个例子从这些List, ArrayList, Set ,HashSet, Map ,HashSet 等等java基础的集合框架你都真的掌握了咩?啥?都学过了?那你能够写一个最简单的ArrayList代码实现吗?就从自己创建一个类开始,然后加方法去实现…对于Java集合框架, 不但要学会用, 还会尝试着去实现一遍!!!一定要多折腾,你才会创造出自己的东西,以后你才能出众

    3、Java基础书籍

    放心,博主深怕各位同学学的不够深不够好,所以博主准备了一打书籍给你。包括java编程思想、java核心技术卷一、二,慢慢啃吧…

    链接:https://pan.baidu.com/s/1oeQxwcN6x1r1lUVml0PeLQ&shfl=sharepset 提取码:st3f

    链接:https://pan.baidu.com/s/19Afs4hbMqZkgxZts9vjyzA&shfl=sharepset 提取码:8ep6

    二、关于JavaWeb基础

    来到Java EE了,博主不得不比比几句了, Java 不就是写服务器端的Web应用的吗?那就自己写个Web程序喽, 可以考虑做一个Web版项目, 用最基础的技术Servlet/jsp/jdbc 。然后自己写个简单mvc框架, 在自己的Web 程序中用起来, 这叫吃自己的狗粮,之后再研究框架 , 自己写个简单的OR mapping框架, 再吃一次自己的狗粮。最后读一下经典的书籍《J2EE development without EJB》 , 是spring 的作者Rod Johnson写的, 它颠覆了大家对于重量级EJB的认识, 开启了新的时代。有了这本书的铺垫, 自己写个简化的依赖注入也不是难事, 写好后还是在自己的Web程序中用起来, 最后一次吃自己的狗粮。

    唉唉唉…放开我…博主还能再哔哔几句…

    JavaWeb基础不牢固,学框架只会事倍功半!所以学servlet之前请远离框架…

    1、JavaWeb基础教程视频

    JavaWeb视频教程(JSP/Servlet/上传/下载/分页/MVC/三层架构/Ajax)

    黑马JavaWeb入门到精通(idea版)

    尚硅谷Java视频_JavaWEB基础视频教程

    同样的那句话:上天是公平的,只要不辜负时间,时间自然不会辜负你。

    2、关于JavaWeb博客文章

    我整理的比较少,比较乱,时间比较有限,写的不好,将就这看吧,选择性观看

    JavaWeb专栏

    三、关于数据库

    肯定要学一个啊,最起码MySQL或者Oracle要会,总不能SQL语句也敲不出吧…

    1、关系型数据库教学视频

    MySQL 基础+高级篇- 数据库 -sql -尚硅谷

    SQL数据库

    一天学会 MySQL 数据库

    Oracle从入门到精通教程(全套)_数据库实战精讲_动力节点

    2、非关系性数据库Redis视频

    非关系性数据库Redis了解一下?这个Redis非常重要,博主不多哔哔,怕各位嫌我比比叨叨然后跑到现实中来扎我QnQ,一句话,埋头学吧…

    千锋微服务2019最新Redis教程[千锋南京]

    2019最新Redis实战教程全套学习视频

    四、关于JDK新特性

    虽然现在jdk12、13的世道了,可现实却是jdk8还是新特性哈哈哈哈…哈哈…哈(原谅我差点笑嗝屁)

    但是必须要明白一点的是用的比较多的还是JDK8!因此JDK8最好要去了解~

    黑马IDEA版本2018Java教学视频—JDK8新特性

    Java 8/9/11 新特性视频教程全集(65P)| 15 小时从入门到精通

    五、关于并发编程

    并发编程其实接触的并不多,但是尤为重要,首当其冲的体现在面试上!现在由于学习软件的人越来越多,特别是Java语言这个行业,而且每年大学生都在毕业,不是我说的浮夸,就连土木工程的大学生都可能转IT这一行,IT行业工资高现在已经是妇孺皆知了,稍微毕业后加入某某培训机构半年,总之学IT的人只会越来越多,随便在大街上拉一个头发茂盛的大叔都可能就是搞软件的,现在有一股妖风,不管啥公司都慢慢像阿里这样的大公司靠近,面试不问点jvm、并发、分布式都不好意思,面试通过之后你的岗位可能仅仅是CURD,老是觉得问问这些显得逼格高点,不管处于什么原因很多公司的确都是这样的!

    这篇文章就是要让你入门java多线程【多线程入门】

    Java并发编程原理与实战

    六、关于NIO

    如果有时间有精力有耐心NIO也是不可或缺的一门知识!急着就业的朋友可以先学框架只后再尽量回头学,当然也只是建议!

    尚硅谷Java视频_NIO 视频教程

    七、关于ssm框架

    ssh建议就不要学了,呸,不能这么说,就是能不学就不学吧,用到再学吧!【只是建议】,总之多学一点也没坏事,看个人吧!反正博主是直接学ssm框架。。。

    1、spring框架视频

    传智spring框架

    Java进阶教程2018年spring框架深入浅出

    2、Mybatis 框架视频

    Mybatis 【黑马】 idea版本

    MyBatis视频教程

    3、SpringMVC框架视频

    【极客学院】一天学会SpringMVC框架

    4、SSM框架博客文章

    4.1、spring框架

    Spring框架学习总结(上)

    Spring框架AOP学习总结(下)

    谈谈Spring核心IOC和AOP

    Spring加载properties文件的两种方式

    4.2、Mybatis框架

    什么是Mybatis,为什么要学习Mybatis,mybatis与hibernate区别

    零基础Mybatis入门程序编写、测试

    MyBatis中SqlMapConfig.xml文件中重点配置:properties属性、typeAliases别名、mappers映射

    MyBatis开发Dao的原始Dao开发和Mapper动态代理开发

    Mybatis中#{}与${}的区别

    Mybatis分页插件PageHelper的学习与使用

    Mybatis整合spring详细教程(带思路)

    4.3、SpringMVC框架

    走进SpringMVC世界,从SpringMVC入门到SpringMVC架构

    手把手教你优雅的编写第一个SpringMVC程序

    SpringMVC参数绑定学习总结【前后端数据参数传递】

    【解决】SpringMVC前端到后端400错误

    SpringMVC常见面试题总结(超详细回答)

    4.5、SSM框架整合文章

    当然以上框架文章并不太全,凑合着看吧,尽量以后更新…当然了以上框架企业都不会单个单个的用而是三个框架整合在一起使用,下面这篇文章可就要我的dog命了,加上测试花了整整N个多小时写出来的…

    IDEA优雅整合Maven+SSM框架(详细思路+附带源码)

    八、关于数据结构与算法

    可能你不去了解这玩意,你可能永远用不上这玩意,当你用的上瘾了,在以后的开发中,你会被它的魅力所折服的!强烈建议学习!!!,博主也是自掏腰包在极客专栏上买的这个专栏PDF,顺道小结写出博客,也算是一种小成绩吧!

    1、数据结构与算法视频

    (严蔚敏)数据结构视频教程(C语言版48集)

    上古程序员严蔚敏老师了解一下?咳咳当然也有java版的了,如下

    数据结构与算法基础-java版

    尚硅谷图解Java数据结构和算法

    2、数据结构与算法博客文章

    数据结构与算法分析有多重要?

    完全透析数据结构与算法

    时间空间复杂度分析:如何分析、统计算法的执行效率和资源消耗

    如何教会女友递归算法?

    【数据结构01】浅谈数组

    【数据结构02】栈与队列

    【数据结构03】浅谈链表

    【算法04】树与二叉树(递归思想遍历)

    算法动图+原理代码轻松透析八大经典算法

    当然,依旧还在学习中…尽量抽空持续更新

    3、数据结构与算法书籍

    还有附带一本数据结构与算法书籍,够你折腾了…

    链接:https://pan.baidu.com/s/1c1BW4iHdYPCd1nbRW1kUSQ&shfl=sharepset 提取码:jcdw

    九、关于开发工具idea

    java开发工具必须要最好的鸭,强烈建议直接上手idea,如果你非要用eclipse,咋也不敢问啊…

    博主也有个idea专栏,只是写的不多而已,选择性观看吧,建议看视频,讲的绝对比博主我说的好…

    IDEA专栏

    尚硅谷Java视频教程_IDEA视频教程

    十、关于项目管理工具Maven、Git、SVN、Gradle…

    确实,这些肯定要学,不然就out了…

    Maven基础篇(IDEA版)

    尚硅谷Java视频教程_Maven视频

    【教程】学会Git玩转Github【全】

    尚硅谷_Git&GitHub视频

    黑马程序员SVN视频教程

    黑马程序员精品教程|Java进阶教程之Gradle入门到精通

    十一、关于计算机网络原理

    世界上最遥远的就是网络…呀这里断网了,请各位往下接着看暂时还没写这方面的博客,不过还是挺重要的一门

    韩老师讲高校《计算机网络原理》

    韩老师就不多说了,绝对金典…

    十二、关于设计模式

    这个太重要了,不过没有实际开发经验是学不好这一门课程的,所以它分几个阶段学习,并不可能一蹴而就的,如果你听说XXX花了几个月的时间,耗死XXX个脑细胞,专研设计模式这一门,最后他成仙了,看啥都能运用设计模式来解决…你就扯犊子吧…

    1、设计模式博客文章

    Java 大黑话讲解设计模式 – UML类图

    【设计模式】单例模式的八种写法分析

    待续…

    尽量抽空写…

    2、设计模式视频

    尚硅谷图解Java设计模式韩顺平老师2019力作

    23个设计模式

    十三、关于中间件Shiro、Lucene、Solr…

    1、啥是中间件?

    啥是中间件?这个问题对博主而言就跟啥是佩奇这问题是同一层次的,小猪…红色的… 咳咳,扯远了

    其实吧,对于中间件这个概念并没有特定的概念,大致的概念为非业务的技术类组件,是操作系统之上和业务逻辑之下的中间层也都可以称之为中间件,或者说是主要用于解耦底层逻辑和业务应用的组件,或者是一些可复用的后台组件。这些概念倒是麻溜溜滴…似乎有点道理但又没完全讲清楚这个概念,你说气人不气人?

    言而总之,总而言之,中间件其实也有两个层面不同理解:
    1、狭义上讲中间件如常见的远程服务框架、消息队列、缓存等;
    2、广义上讲中间件是操作系统之上业务逻辑之下的所有可复用的后台组件。

    2、Shiro

    尚硅谷Shiro视频教程

    Lucene&solr(2天学习)

    3、Lucene

    2018年黑马程序员就业班57期之【Lucene】

    4、Shiro

    SpringBoot与Shiro整合-权限管理实战视频

    5、Elasticsearch7.X

    2019年全新录制Elasticsearch7.X搜索引擎项目实战Java架构全套视频教程

    6、Dubbo

    尚硅谷Java视频教程_Dubbo

    (千锋教育)Java 微服务架构 Dubbo 篇 一款高性能 Java RPC 框架

    十四、关于JVM虚拟机

    1、JVM博客文章

    深入理解java虚拟机系列初篇(一):为什么要学习JVM?

    别翻了,这篇文章绝对让你深刻理解java类的加载机制【JVM篇二】

    持续写作中…

    2、JVM视频

    面试JVM,听这堂课就够了

    深入理解JVM

    3、JVM书籍

    博主不想bb啥并朝你丢了一本深入java虚拟机

    链接:https://pan.baidu.com/s/1C3bQOIdxdjHOwq6MT283yQ&shfl=sharepset
    提取码:zkww

    十五、关于消息中间件、RabbitMQ、RocketMQ、ActiveMQ

    单独讲下消息中间件,主要是中间件塔喵的太多惹…

    1、Kafka

    尚硅谷大数据课程之Kafka(2019新版)

    2、RabbitMQ

    MQ消息中间件RabbitMQ 入门到进阶+(牧码人/老王/)+(架构师系列)

    Java架构师带你90分钟快速搞定RabbitMQ消息中间件

    3、RocketMQ

    RocketMQ系统精讲,经受历年双十一狂欢节考验的分布式消息中间件

    2019年最新版Springboot+mybatis+RocketMQ+SpringCloud技术讲解

    4、ActiveMQ

    尚硅谷消息中间件之ActiveMQ

    2019尚硅谷谷粒商城微服务SpringBoot,Dubbo,MySql高级,Redis秒杀,ElasticSearch,ActiveMQ…

    十六、关于容器化技术docker、kubernetes

    尚硅谷_Docker核心技术(基础篇)

    【公开课】Docker入坑教程【33集】

    马哥运维进阶教程:Kubernetes(K8s)从入门到精通

    尚硅谷Kubernetes(k8s基于最新2019年8月发布的1.15.1)

    十七、关于微服务框架

    随着基于Spring之上的框架SpringBoot、Cloud的流行,基于注解式开发的热潮逐渐覆盖了基于XML纯配置的开发,Spring注解将显得格外重要…所以…所以…所以个锤子啊不关咋们什么事啊。。。开个玩笑哈哈,至于微服务框架的学习看个人吧,最好是在找工作前学习一下,现在IT门槛越来越高了,不会点分布式缓存真的不好找工作。

    1、SpringBoot视频

    SpringBoot视频教程(idea版)_2018_spring boot_springboot核心篇+springboot整合篇

    尚硅谷好评如潮【SpringBoot】视频

    2、SpringCloud视频

    尚硅谷_SpringCloud(全)

    千锋:2019Java微服务架构(SpringBoot+SpringCloud)

    答应博主,一定要坚持学完啊!!!

    十八、关于面试

    2019最新Java面试题集精讲全集(互联网大厂必问)

    Java面试题全集84集系列

    京东小米面经

    十九、关于另一层次的学习

    1、参阅官方文档

    另一级别的学习最好的方式就是参阅官方文档,亲生父母往往对孩子是最了解,Spring Boot Reference Guide就是对springboot最了解,怎么样使用springbootspringboot特性等等,springboot在你面前一览无遗;啥?英语不好???google百度翻译插件你值得拥有,咬咬牙也是能看的。如果有时间可以重新学英语,记住,世上无难事,只怕有心人,学什么都不会太晚。

    2、国内技术书籍

    官方文档其次就是书籍,国内的好书自成体系,帮助我们掌握的知识点不至于太散。

    3、参阅博客文章、闲逛github

    再次就是博客文章,不得不吐槽几句,网上的很大一部分文章都是非常浅显,再加上一些标题党的横行,简直不忍直视。这也是很多人抵制博客文章的原因,这里不得不提一下:每次百度或者谷歌一下知识点或者bug,我敢打包票出现最多的推荐靠前的都是CSDN,我相信很多人会认为CSDN很强大,实际上你错了,过段时间你就会慢慢抵制CSDN,看到简书或者博客园、知乎的文章你会优先去看。至于原因就是因为CSDN是国内最大的博客平台,同时一些“标题党.equal 烂人”随之衍生,为了所谓的点击量,博取眼球,自以为自己访问量高很nice?这里也不是说起博取眼球的标题是抵制,前提是你的这篇文章要有一定深度和见解,能够撑起整片文章知识点的架构,博取眼球的标题才是真正有意义的,当之无愧。

    总归来说,园子内还是有很多技术大牛,写的博客自然也是非常棒,非常具有学习价值。每次看都是一种享受,一种熏陶。当然还有github、社区、论坛、码云等等。这就是源码的朋友圈,我们从中也能获取到非常多关于源码的信息。但是针对某个知识点却特别的细,对彻底掌握非常有帮助。

    至于博主为啥要抽空整理出这样一篇博客文章,原因很简单…

    博主大一下学期的时候无尽的迷茫惆怅,博主何尝不期望有位“高人”指路,想学却又不知从何下手,那种无助那种孤独的滋味我懂…
    所以博主只希望生活能够不辜负每个少年的一腔热血,写作本文章的意义仅此而已…

    瓜皮群众皮皮甲: 呜呜呜…博主大一下学期原来这么孤独啊,看了这么久的文章还一直以为这位博主是个有趣、对生活充满阳光的,没想到这个博主“徒有其表”啊 QnQ

    瓜皮群众皮皮乙: 是啊是啊…

    博主: 咳咳…那啥…今天就先到这里了,博主有事,唉唉唉…看…又是那个该死的包工头来电话了,话说今天的砖头格外烫手。

    瓜皮群众皮皮丙: 博主怎么画风怎么又变了, 唉唉唉…博主别走鸭…上我家搬砖去啊,午饭外加一个鸡腿…

    如果有想要和博主一起交流的朋友,欢迎各位及时联系博主…那… 咋们有bing再见~

    持续更新…

    如果本文对你有一点点帮助,那么请点个赞呗,谢谢~

    最后,若有不足或者不正之处,欢迎指正批评,感激不尽!如果有疑问欢迎留言,绝对第一时间回复!

    欢迎各位关注我的公众号,公众号里有全套java电子书籍和学习资料喔,一起探讨技术,向往技术,追求技术,说好了来了就是盆友喔…

    在这里插入图片描述

    展开全文
  • 本文将告诉你学习Java需要达到的30个目标,学习过程可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条的多少条了呢? 路线 Java发展到现在,按应用来分主要分为三大...

     

     

    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

    展开全文
  • 2019年最新Java学习路线图,路线图的宗旨就是分享,专业,便利,让喜爱Java的人,都能平等的学习。从今天起不要再找借口,不要再说想学Java却没有资源,赶快行动起来,Java等你来探索,高薪距你只差一步! java...

     

    2019年最新Java学习路线图, 路线图的宗旨就是分享,专业,便利,让喜爱Java的人,都能平等的学习。从今天起不要再找借口,不要再说想学Java却没有资源,赶快行动起来,Java等你来探索,高薪距你只差一步!

     

    java学习基础

    针对Java零基础入门学习者,比较详细的知识点总结和学习路线

    数据库

     

    数据库是程序员必须要掌握中知识点,详细的学习思路和面试题,

    适用/适合人群:

    拥有Java语言并可以实现网站爬取数据并分析

    目标:

    掌握mysql,Oracle在各个平台上的安装及使用

    Mysql数据库基础

    1. mysql概述、优点、运行原理及内存结构
    2. mysql数据类型
    3. mysqlDDL语句的使用
    4. SQL语言的使用
    5. DML语句的介绍及使用
    6. SQL事务
    7. SQL查询机制、查询基础、技巧、查询优化;

    Mysql数据库高级

    1. mysql数据库引擎分类
    2. mysql事务
    3. mysql表
    4. mysql数据类型
    5. mysql视图
    6. mysql索引
    7. mysql分页
    8. SQL语句优化技巧

    Oracle实战

    1. Oracle安装与调试
    2. Oracle数据类型
    3. Oracle与MySQL对比
    4. Oracle数据结构概述
    5. Oracle运行原理
    6. Oracle内存结构
    7. Oracle表空间
    8. 用户,表,序列的创建及使用
    9. Oracle索引
    10. Oracle分区表的创建及使用

    PL/SQL实战

     

    1. PL/SQL基础知识
    2. 异常处理
    3. 游标
    4. 存储过程

    JDBC

     

    1. JDBC概述
    2. JDBC工作原理
    3. JDBC API
    4. JDBC访问数据库
    5. JDBC常用接口

    ●数据库连接池

    1. Java多线程开发
    2. 多线程与单线程比较
    3. 多线程应用
    4. 多线程使用注意事项
    5. 数据库连接池技术

     

    WEB前端技术

    目标:

    1. 掌握HTML,CSS,JavaScript等前端基本技术,并使用JSP,Servlet开发小型网站
    2. 使用框架技术开发大型网站

    HTML+CSS基础

     

    1. W3C标准
    2. HTML编辑工具
    3. HTML标签
    4. CSS的基本用法
    5. 在HTML中引入CSS样式

     

    CSS高级

    1. CSS编辑网页文本
    2. 列表样式
    3. 盒子模型
    4. 浮动
    5. 定位网页元素

    JS基础

    1. JavaScript核心语法
    2. 程序调试
    3. JavaScript对象

    JS高级

    1. 初识jQuery,jQuery选择器
    2. jQuery中的事件与动画
    3. jQuery操作DOM
    4. 表单校验

    JavaWEB

     

    web基础技(项目实战),初级的一般是用JSP(Java Server Pages)+servlet+Javabean来开发的,对大型的网站一般是使用框架来开发的,例如struts,hibernate,spring,典型的struts框架结构。

    JavaWEB项目

     

    EGOA项目、二手车电商平台项目都是JAVAWEB的项目

     

    Java高级框架

     

    设计模式

      设计原则 【单一职责、里氏替换、依赖倒置、接口隔离、迪米特法则、开闭原则】

      代理模式

      工厂模式

      策略模式

    Spring源码

     Spring核心组件

    IOC机制

     

    AOP实现原理【aop编辑思想、aop在spring中的使用、cglib和jdk动态代理】

    Transaction事务处理【事务隔离级别】

    SpringMVC【DispatcherServlet、请求映射、参数绑定与转换、页面渲染】

    Mybatis

    mydatis代码

    Sqlsession原理

    mybatis事务

    自带缓存机制与Spring结合实现缓存

    使用代码生成器快速开发

    互联分布式网架构体系

    1SpringBoot

    starter快速集成组件【缓存、数据库、消息队列、搜索引擎】

    AutoConfigure自动化配置

    Actuator系统监控【数据库、消息队列中间件、自定义监控】

    新注解特性分析

     

    工程化管理

    git管理

    maven

    Sonar代码质量检测平台

    jenkins持续集成

    Devops持续集成

    jenkins环境构建

    jenkins集成git/svn/tomcat/sonar

    jenkins插件机制

    微服务架构

    架构设计

    互联网架构【服务化架构】

    DDD领域驱动设计【建模、事件驱动】

    分布式系统架构

    微服务架构【服务拆分、服务治理】

    SpringCloud

    config分布式配置中心

    Eureka注册与发现机制

    Ribbon客户端负载均衡

    Hystrix服务熔断组件

    feign声明式服务调用

    Zuu网关服务

    docker

    decker【镜像、容器、常用命令】

    私有仓库

    docker swarm集群搭建

    docker compose部署脚本

    docker service服务编排

    docker stack分布式集群部署

    docker portainer容器可视化管理工具

    maven插件打包docker镜像

    docker部署运行java程序

    docker应用【搭建ELK、RabbitMQ、Mysql、部署高可用springCloud微服务实现动态扩容、、】

    分布式技术

    RPC模式【rmi,http,hessian】

    分布式系统指挥者Zookeeper【CAP理论、ZK、、】

    Dubbo框架【服务化思想、dubbo特性、dubbo原理】

    服务发现机制

    mock机制

    容错机制

    负载均衡机制

    序列化方式

    多协议支持

    配置加载机制

    数据绑定实现原理

    与spring的集成原理

    rpc-协议原理

    netty的使

    高并发开发技术

    java多线程【基础线程、线程池和Executor框架、线程安全、】

    java常用并发工具接口和类【ContDownLatch、CyclicBarrier、Semaphore、Exchange、ConcurrentHashMap、ConcurrentSkipListMap、Fork\Jion、HashMap、List】

    NIO【阻塞\非阻塞、高性能网络编辑框架-natty、】

    高并发-缓存【Redis、memcached、】

    高并发-消息队列【ActiveMq(JMS规范、ack机制)、RabbitMq(AMQP规范)】

    高并发-分流【DNS分流、CDN分流+加速、Nginx、LVS】

    高并发技术实战

    分布式锁定实现方案【redis、zookeeper】

    分布式事务解决方案【X/A协议、消息队列、TCC解决】

    分布式系统校验【分布式session、JWT方式、单点框架】

    互联网高可用框架【负载均衡技术分析、keepalive实现】

    分布式订单流水号生成策略【基于数据库、基于雪花算法、基于redis、】

    分布式系统数据存储【】

     

    传统数据库、

    NoSQL数据库、

    MYSQL高可用、

    MongoDB、

    大数据分库分表解决方案mycat

    性能优化

    JVM优化【参数调优、性能】

    WEB【java低能代码、Tomcat容器原理\手写简版Tomcat、Tomcat参数、Benchmark】

    SQL优化【数据库存储引擎、索引、Sql语句性能、SQL语句{业务层面、数据库层面、sql语句拆分}】

     

     

    展开全文
  • Java多线程学习(一)Java多线程入门 Java多线程学习(二)synchronized关键字(1) Java多线程学习(二)synchronized关键字(2) Java多线程学习(三)volatile关键字 Java多线程学习(...
  • 一门永不过时的编程语言——Java 软件开发。...而在以Java编程为核心的开发领域,javaEE程序员的需求量10年来一直居于首位! Java工程师就业: 1.通过各大招聘网站统计,全国海量公司都在招聘J...
  • 现在学习java的人很多,但是也有很多人对于学习java能干什么不是很清楚。只知道java开发薪资很高,比如千锋2017年2月就业榜出平均月薪10827元,Java工程师平均月薪12153元;深圳千锋JavaEE首期班毕业第一周就业率61.5...
  • Java学习书籍整理

    2020-05-26 18:02:31
    不知不觉,做Java开发已经四年了,趁着现在换了工作,还算比较闲,就整理一下自己学习的一些知识。 在学习过程,我喜欢找的一些电子书来系统化的学习,多数时候我都只是做一个大概的了解,没有深入学习,基本...
  • 不知不觉从初学Java到现在已经8年了,今天在这里给刚入门和入门不久的小伙伴们一些建议。可能总结的不是很详细,但给出了一个大概的学习路线。希望对大家有帮助哈~ 如何快速学Java 这里我以Java EE(Jakarta EE)/...
  • 这几天,近百名初学java粉丝咨询我如何自学java,因精力有限不能一一回复,现...目录:一、学习java的前提二、学习java的方法三、学习java时的坑 四、学习java的路线(画重点)我可以很明确的告诉你,学习java不难,...
  • 新的一年来临,突如其来的疫情打破了平静的生活! 在家的你是否很无聊,如果无聊就来学习吧! 世上只有一种投资只赚不赔,那就是学习!!! ...传智播客于2020年升级了Java学习...在Java基础板块有6个子模块的学...
  • 最近一直在重新学习java的基础,也写了一系列的博客(重新认识java系列)。很荣幸得到了许多同学的反馈。其中有许多人是初学者,来问我一些问题,也有一些是已经有过一定的基础,看了我的博客,也有了一些新的认知,...
  • 极简JAVA学习营充分考虑到这些问题,通过每日实战编程练习,分队pk,助教答疑,作业点评,作业讲解,项目答辩等诸多环节充分激发你的学习热情,解决你学习中碰到的问题,让你花十分之一的钱学到JAVA的精髓,开启你的...
  • Java学习网站,有了这些,成为大牛不在话下
  • 废话不多说,直接聊干货。 关键词“零基础”和“迅速”,针对这两个词,...首先,对于Java零基础的人应该去了解目前想要找到一份Java工作,应该具备哪些技能,当你符合这些企业的基本标准后,工作就不成问题。...
  • Java工程师学习指南 完结篇 先声明一点,文章里面不会详细到每一步怎么操作,只会提供大致的思路和方向,给大家以启发,如果真的要一步一步指导操作的话,那至少需要一本书的厚度啦。 因为笔者还只是一名在校生,...
  • Java工作流引擎学习----JBPM  一、简介 主动性编程: 方法 ---> 类 ---> jar ---> 类库  特性:已经封装好的功能,供我们去调用,通过组合这些功能来完成代码的开发。 被动型编程:框架- --> 引擎   ...
  • 还是已经步入开发的大牛,这套路线路你都值得拥有,小白看上面的视频可以成功学会Java并且顺利工作,大神看了上面的资源肯定会谆谆乐道,教程的宗旨就是分享,专业,便利,让喜爱Java的人,都能平等的学习。...
  • java学习路线图(2018年最新版)最近有些网友问我如何自学 Java 后端,还有些是想从别的方向想转过来,但都不太了解 Java 后端究竟需要学什么,究竟要从哪里学起,哪些是主流的 Java 后端技术等等,导致想学,但又很...
  • 在大学阶段,我们学习编程更多的是兴趣使然,但是临近毕业,当所学...Java学习到什么程度可以找第一份工作Java开发属于入门容易精深难的编程语言,尤其各种框架繁杂,很难一口气就达到很高的程度。其实面试官也明...
1 2 3 4 5 ... 20
收藏数 516,618
精华内容 206,647
关键字:

java工作中学习