线程池的常用接口实现及执行流程

线程池

线程池接口

在这里插入图片描述

ExecutorService

访问操作线程池,继承Executor接口。

ThreadPoolExecutor及其子类

线程池的具体实现,实现了AbstractThreadPoolExecutor抽象类。

Executors工具类 (封装了常用线程池的创建)

根据设定参数的不同,可以分为下面四种常用的线程池对象:

动态数目线程池对象(ThreadPoolExecutor)

线程在存活时间内(60秒)可以重复使用

Executors.newCachedThreadPool();
固定数目线程池对象(ThreadPoolExecutor)
Executors.newFixedThreadPool(20);
单个线程池对象(ThreadPoolExecutor)
Executors.newSingleThreadExecutor();
任务调度线程池对象(ScheduledThreadPoolExecutor)
Executors.newScheduledThreadPool(20);

提交调度线程任务

  • schedule() 指定延迟时间后,执行线程任务1次
  • scheduleAtFixedRate() 固定的时间间隔,触发执行线程任务
  • scheduleWithFixedDelay() 上一次任务执行结束后,"延迟"时间后执行

线程池参数

1、corePoolSize:核心线程数,线程池中最少线程,核心线程不会被回收。

2、maximumPoolSize:最大线程数,线程池中最多线程,包含核心线程数,不能小于核心线程数。

3、keepAliveTime:非核心线程(除去核心线程之外的线程)存活时间,如果非核心线程的空闲时间大于此参数,将会被回收。

4、TimeUnit:时间单位,参数keepAliveTime的时间单位。

5、BlockingQueue:阻塞工作队列,当来一个新的线程任务时,如果当前没有空闲线程,此线程任务将会进入阻塞工作队列中进行等待。

6、ThreadFactory:线程工厂,用于创建线程,自定义线程的名称。(需要实现ThreadFactory接口,实现newThread()方法,在此方法中,新建Thread对象,通过调用setName()方法给线程定义名称。)

class MyThreadFactory implements ThreadFactory{
	
	public AtomicInteger threadNumber = new AtomicInteger();
	public String preFix;
	
	public MyThreadFactory(String preFix) {
		this.preFix = preFix;
	}

	@Override
	public Thread newThread(Runnable r) {
		Thread t =  new Thread(r,preFix + threadNumber.getAndIncrement());
		
		if(t.isDaemon()) {
			t.setDaemon(false);
			
		}
		if(t.getPriority() != Thread.NORM_PRIORITY) {
			t.setPriority(Thread.NORM_PRIORITY);
		}
		return t;
	}
}

7、RejectedExecutionHandler:拒绝策略,当线程池中没有空闲线程,且阻塞工作队列已满,且最大线程数也已超出,此时再来线程任务将执行拒绝策略。

四种拒绝策略

AbortPolicy :丢弃当前线程任务,并抛出异常

DiscardPolicy :丢弃当前线程任务,但不抛出异常

DiscardOldestPolicy : 丢弃工作队列中最“老”的线程任务

CallerRunsPolicy :直接由“当前调用线程”直接执行该线程任务

自定义拒绝策略 :实现RejectedExecutionHandler接口

线程池的执行流程

在这里插入图片描述

首先,通过execute()或者submit()提交线程任务到线程池中,然后由线程池判断是否可以执行,反之执行拒绝策略。

在这里插入图片描述

如上图所示,就是线程池的执行过程,可以分为五个主要步骤:

1.提交任务后会首先进行判断是否存在空闲线程,如果存在直接执行线程任务。

2.若果当前工作线程数与核心线程数的比较,如果当前工作线程数小于核心线程数,则直接调用 addWorker() 方法创建一个核心线程去执行任务;

3.如果工作线程数大于核心线程数,即线程池核心线程数已满,则新任务会被添加到阻塞队列中等待执行,当然,添加队列之前也会进行队列是否为空的判断;

4.如果线程池里面存活的线程数已经等于核心线程数了,且阻塞队列已经满了,再会去判断当前线程数是否已经达到最大线程数 maximumPoolSize,如果没有达到,则会调用 addWorker() 方法创建一个非核心线程去执行任务;

5.如果当前线程的数量已经达到了最大线程数时,当有新的任务提交过来时,会执行拒绝策略

总结来说就是优先核心线程、阻塞队列次之,最后非核心线程。

线程池的状态

RUNNING 运行状态

允许新任务,并处理工作队列中的任务

  • 调用shutdown()方法 ,进入关闭状态
  • 调用shutdownNow() /stop()方法,进入停止状态
SHUTDOWN 关闭状态

不接收新任务,但仍处理工作队列中的任务

STOP 停止状态

不接收新任务,也不处理工作队列中的任务,同时中断正在执行的任务

TIDYING 整理状态

所有任务已经结束,工作队列中的任务数量为0

TERMINATED 终止状态

线程池彻底关闭

在这里插入图片描述

线程池如何保存状态和线程数量

AtomicInteger ctl 变量 ,前3位保存“线程状态”,后29位保存“线程数量(线程池存活线程数)”

在这里插入图片描述

  • 9
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面试题包括以下十九部分:Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。 目录: 一、Java 基础 1.JDK 和 JRE 有什么区别? 2.== 和 equals 的区别是什么? 3.两个对象的 hashCode()相同,则 equals()也一定为 true,对吗? 4.final 在 java 中有什么作用? 5.java 中的 Math.round(-1.5) 等于多少? 6.String 属于基础的数据类型吗? 7.java 中操作字符串都有哪些类?它们之间有什么区别? 8.String str="i"与 String str=new String(“i”)一样吗? 9.如何将字符串反转? 10.String 类的常用方法都有那些? 11.抽象类必须要有抽象方法吗? 12.普通类和抽象类有哪些区别? 13.抽象类能使用 final 修饰吗? 14.接口和抽象类有什么区别? 15.java 中 IO 流分为几种? 16.BIO、NIO、AIO 有什么区别? 17.Files的常用方法都有哪些? 二、容器 18.java 容器都有哪些? 19.Collection 和 Collections 有什么区别? 20.List、Set、Map 之间的区别是什么? 21.HashMap 和 Hashtable 有什么区别? 22.如何决定使用 HashMap 还是 TreeMap? 23.说一下 HashMap 的实现原理? 24.说一下 HashSet 的实现原理? 25.ArrayList 和 LinkedList 的区别是什么? 26.如何实现数组和 List 之间的转换? 27.ArrayList 和 Vector 的区别是什么? 28.Array 和 ArrayList 有何区别? 29.在 Queue 中 poll()和 remove()有什么区别? 30.哪些集合类是线程安全的? 31.迭代器 Iterator 是什么? 32.Iterator 怎么使用?有什么特点? 33.Iterator 和 ListIterator 有什么区别? 34.怎么确保一个集合不能被修改? 三、多线程 35.并行和并发有什么区别? 36.线程和进程的区别? 37.守护线程是什么? 38.创建线程有哪几种方式? 39.说一下 runnable 和 callable 有什么区别? 40.线程有哪些状态? 41.sleep() 和 wait() 有什么区别? 42.notify()和 notifyAll()有什么区别? 43.线程的 run()和 start()有什么区别? 44.创建线程池有哪几种方式? 45.线程池都有哪些状态? 46.线程池中 submit()和 execute()方法有什么区别? 47.在 java 程序中怎么保证多线程的运行安全? 48.多线程锁的升级原理是什么? 49.什么是死锁? 50.怎么防止死锁? 51.ThreadLocal 是什么?有哪些使用场景? 52.说一下 synchronized 底层实现原理? 53.synchronized 和 volatile 的区别是什么? 54.synchronized 和 Lock 有什么区别? 55.synchronized 和 ReentrantLock 区别是什么? 56.说一下 atomic 的原理? 四、反射 57.什么是反射? 58.什么是 java 序列化?什么情况下需要序列化? 59.动态代理是什么?有哪些应用? 60.怎么实现动态代理? 五、对象拷贝 61.为什么要使用克隆? 62.如何实现对象克隆? 63.深拷贝和浅拷贝区别是什么? 六、Java Web 64.jsp 和 servlet 有什么区别? 65.jsp 有哪些内置对象?作用分别是什么? 66.说一下 jsp 的 4 种作用域? 67.session 和 cookie 有什么区别? 68.说一下 session 的工作原理? 69.如果客户端禁止 cookie 能实现 session 还能用吗? 70.spring mvc 和 struts 的区别是什么? 71.如何避免 sql 注入? 72.什么是 XSS 攻击,如何避免? 73.什么是 CSRF 攻击,如何避免? 七、异常 74.throw 和 throws 的区别? 75.final、finally、finalize 有什么区别? 76.try-catch-finally 中哪个部分
JAVA线程基本学习, JAVA多线程的特性= 线程池: 本质上是一个对象池, 用来管理线程资源. 在任务执行前, 需要从线程池中拿出线程来执行. 在任务执行完成之后, 需要把线程放回线程池. 线程池好处: 降低资源的消耗, 线程本身是一种资源, 创建和销毁都会消耗CPU内存, 频繁的创建和销毁会浪内存. 提高任务执行的响应速度, 任务执行时, 可以不必等线程创建完成之后在执行,可以直接获取线程执行任务. 提高线程的可管理性, 线程不能无限制的创建, 需要进行统一的分配, 调优和监控. 不适用线程池坏处: 频繁的线程创建和销毁会占用更多的CPU和内积. 频繁的创建和销毁会对gc产生比较大的压力. 线程太多,线程切换带来的开销将不可忽视. 线程太少, 多核CPU得不到充分利用, 浪费资源. 线程池实现原理: 分为三部分: 核心线程池 线程池 队列 拒绝策略 主要流程: 1.判断核心线程池是否已满, 如果不是, 则创建线程执行任务 2.如果核心线程池满了, 判断队列是否满了, 如果队列没满, 将任务放在队列中 3.如果队列满了, 则判断线程池是否已满, 如果没满, 创建线程执行任务 4.如果线程池满了, 按照拒绝策略对任务进行处理 JDK中提供了一个线程池工厂: Executors ,很多工厂方法, 可以创建多种线程池 1.单一线程池 ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); 该线程池只有一个线程, 若多个任务被提交到此线程池, 那么会被缓冲到队列,当线程空闲时,按照FIFO的方式进行处理. 2.固定数量线程池 ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5); 和创建单一线程池类似, 不同的是线程池中有多个线程, 可以并行处理任务, 若多个线程任务被提交到此线程池, 会有以下执行过程: 如果线程的数量未达到指定数量, 则创建新线程执行任务. 如果线程池的数量达到了指定数量, 而且此时有线程是空闲的, 则取出空闲线程来执行任务. 如果没有线程是空闲的, 则将任务缓冲到队列, 当线程空闲的时候, 按照FIFO的方式进行处理. FIFO: 先进先出 3.带缓冲的线程池线程池中, 核心线程池长度为0, 线程池最大长度为Integer.MAX_VALUE.以SynchronousQueue作为等待队列, 从而每次往队列中插入一个元素, 必须等待另一个线程从这个队列删除一个元素. 定时调度 4.定时调度的线程池 ExecutorService newCachedThreadPool = Executors.newScheduledThreadPool(); ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5); ExecutorService newWorkStealingPool = Executors.newWorkStealingPool() 线程池家族 线程池的顶层接口是Executor, 这个接口定义了一个核心方法executor(Runnable command), 这个方法最后被ThreadPoolExecutor类实现, 这个方法用来传入任务, 并且该类是线程池的核心类, 构造方法如下 : public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueu, ThreadFactory threadFactory,RejectedExecutionHandler handler); 参数意义: CorePoolSize: 核心线程池大小, 如果核心线程池有空闲的位置, 新的任务就会被核心线程池新建一个线程执行, 执行完毕不会销毁线程, 线程会进入缓冲队列等待再次被运行 MaximunPoolSize: 线程池能创建最大的线程数量, 如果核心线程池和缓冲队列都已经满了, 新的任务就会进来创建新的线程来执行, 但是数量不能超过maximunPoolSize, 否则采取拒绝接受任务策略 KeepAliveTime: 非核心线程能够空闲的最长时间, 超过时间, 线程终止, 这个参数默认只有在线程数量超过核心线程池大小时, 才会起作用. Unit: 时间单位, 和keepAliveTime配合使用. WorkQueue: 缓冲队列, 用来存放等待被执行的任务 ThreadFactory: 线程工厂, 用来创建线程, 一般有三个选择 ArrayBlockingQueue LinkedBlockingQueue SynchronousQueue Handler :拒绝处理策略, 线程数量大于最大线程数量就会拒绝处理策略, 四种策略为 ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy:也是丢弃任务,但是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程) ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务 Executor接口有一个子接口ExecutorService, ExecutorService的实现类AbstracExecutorService, 而ThreadPoolExecutor正是AbstracExecutorService的子类. ThreadPoolExecutor还有两个常用的方法shutdown和submit,两者都用来关闭线程池, 但是submit有一个结果返回. 线程池任务执行 当执行executor(Runnable command)方法后, 传入一个任务, public void execute(Runnable command) { if (command == null) throw new NullPointerException(); if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { if (runState == RUNNING && workQueue.offer(command)) { if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); } } (传入的对象实现了Runnable接口, 这就解释了: 为什么实现多线程的方式中继承Thread类不能使用线程池了) 执行过程: 首先判断任务是否为空, 为空抛出空指针异常, 否则执行下一个判断: 当前线程数量是否小于核心线程池线程数量, 是,则执行addIfUbderCorePollSize(command)方法, 在核心线程池中创建新的线程, 并且执行这个任务 总结: 如果当前线程池中的数目小于corePollSize, 则每来一个任务, 就会创建一个新的线程去执行这个任务 如果当前线程池中的线程数目>=corePollSize, 则每来一个任务, 会尝试将其添加到缓冲队列中, 如果添加成功, 则该任务会等待空闲线程将其取出去执行, 如果添加失败(一般是以为任务队列已经满了), 则会尝试创建新的线程去执行这个任务. 如果当前线程池中的线程数目达到maximunPoolSize, 则会采取任务拒绝策略进行处理. 如果线程池中的线程数量大于corePoolSize时, 如果某线程空闲时间超过keepAliveTime, 线程将被终止, 直至线程池中的线程数目小于等于corePoolSize; 如果允许核心池中的线程设置存活时间, 那么核心池中的线程空闲时间超过keepAliveTime, 线程也会被终止.
第1部分概述 1 1 交易型系统设计的一些原则 2 1.1 高并发原则 3 1.1.1 无状态 3 1.1.2 拆分 3 1.1.3 服务化 4 1.1.4 消息队列 4 1.1.5 数据异构 6 1.1.6 缓存银弹 7 1.1.7 并发化 9 1.2 高可用原则 10 1.2.1 降级 10 1.2.2 限流 11 1.2.3 切流量 12 1.2.4 可回滚 12 1.3 业务设计原则 12 1.3.1 防重设计 13 1.3.2 幂等设计 13 1.3.3 流程可定义 13 1.3.4 状态与状态机 13 1.3.5 后台系统操作可反馈 14 1.3.6 后台系统审批化 14 1.3.7 文档和注释 14 1.3.8 备份 14 1.4 总结 14 第2部分高可用 17 2 负载均衡与反向代理 18 2.1 upstream配置 20 2.2 负载均衡算法 21 2.3 失败重试 23 2.4 健康检查 24 2.4.1 TCP心跳检查 24 2.4.2 HTTP心跳检查 25 2.5 其他配置 25 2.5.1 域名上游服务器 25 2.5.2 备份上游服务器 26 2.5.3 不可用上游服务器 26 2.6 长连接 26 2.7 HTTP反向代理示例 29 2.8 HTTP动态负载均衡 30 2.8.1 Consul+Consul-template 31 2.8.2 Consul+OpenResty 35 2.9 Nginx四层负载均衡 39 2.9.1 静态负载均衡 39 2.9.2 动态负载均衡 41 参考资料 42 3 隔离术 43 3.1 线程隔离 43 3.2 进程隔离 45 3.3 集群隔离 45 3.4 机房隔离 46 3.5 读写隔离 47 3.6 动静隔离 48 3.7 爬虫隔离 49 3.8 热点隔离 50 3.9 资源隔离 50 3.10 使用Hystrix实现隔离 51 3.10.1 Hystrix简介 51 3.10.2 隔离示例 52 3.11 基于Servlet 3实现请求隔离 56 3.11.1 请求解析和业务处理线程池分离 57 3.11.2 业务线程池隔离 58 3.11.3 业务线程池监控/运维/降级 58 3.11.4 如何使用Servlet 3异步化 59 3.11.5 一些Servlet 3异步化压测数据 64 4 限流详解 66 4.1 限流算法 67 4.1.1 令牌桶算法 67 4.1.2 漏桶算法 68 4.2 应用级限流 69 4.2.1 限流总并发/连接/请求数 69 4.2.2 限流总资源数 70 4.2.3 限流某个接口的总并发/请求数 70 4.2.4 限流某个接口的时间窗请求数 70 4.2.5 平滑限流某个接口的请求数 71 4.3 分布式限流 75 4.3.1 Redis+Lua实现 76 4.3.2 Nginx+Lua实现 77 4.4 接入层限流 78 4.4.1 ngx_http_limit_conn_module 78 4.4.2 ngx_http_limit_req_module 80 4.4.3 lua-resty-limit-traffic 88 4.5 节流 90 4.5.1 throttleFirst/throttleLast 90 4.5.2 throttleWithTimeout 91 参考资料 92 5 降级特技 93 5.1 降级预案 93 5.2 自动开关降级 95 5.2.1 超时降级 95 5.2.2 统计失败次数降级 95 5.2.3 故障降级 95 5.2.4 限流降级 95 5.3 人工开关降级 96 5.4 读服务降级 96 5.5 写服务降级 97 5.6 多级降级 98 5.7 配置中心 100 5.7.1 应用层API封装 100 5.7.2 配置文件实现开关配置 101 5.7.3 配置中心实现开关配置 102 5.8 使用Hystrix实现降级 106 5.9 使用Hystrix实现熔断 108 5.9.1 熔断机制实现 108 5.9.2 配置示例 112 5.9.3 采样统计 113 6 超时与重试机制 117 6.1 简介 117 6.2 代理层超时与重试 119 6.2.1 Nginx 119 6.2.2 Twemproxy 126 6.3 Web容器超时 127 6.4 中间件客户端超时与重试 127 6.5 数据库客户端超时 131 6.6 NoSQL客户端超时 134 6.7 业务超时 135 6.8 前端Ajax超时 135 6.9 总结 136 6.10 参考资料 137 7 回滚机制 139 7.1 事务回滚 139 7.2 代码库回滚 140 7.3 部署版本回滚 141 7.4 数据版本回滚 142 7.5 静态资源版本回滚 143 8 压测与预案 145 8.1 系统压测 145 8.1.1 线下压测 146 8.1.2 线上压测 146 8.2 系统优化和容灾 147 8.3 应急预案 148 第3部分高并发 153 9 应用级缓存 154 9.1 缓存简介 154 9.2 缓存命中率 155 9.3 缓存回收策略 155 9.3.1 基于空间 155 9.3.2 基于容量 155 9.3.3 基于时间 155 9.3.4 基于Java对象引用 156 9.3.5 回收算法 156 9.4 Java缓存类型 156 9.4.1 堆缓存 158 9.4.2 堆外缓存 162 9.4.3 磁盘缓存 162 9.4.4 分布式缓存 164 9.4.5 多级缓存 166 9.5 应用级缓存示例 167 9.5.1 多级缓存API封装 167 9.5.2 NULL Cache 170 9.5.3 强制获取最新数据 170 9.5.4 失败统计 171 9.5.5 延迟报警 171 9.6 缓存使用模式实践 172 9.6.1 Cache-Aside 173 9.6.2 Cache-As-SoR 174 9.6.3 Read-Through 174 9.6.4 Write-Through 176 9.6.5 Write-Behind 177 9.6.6 Copy Pattern 181 9.7 性能测试 181 9.8 参考资料 182 10 HTTP缓存 183 10.1 简介 183 10.2 HTTP缓存 184 10.2.1 Last-Modified 184 10.2.2 ETag 190 10.2.3 总结 192 10.3 HttpClient客户端缓存 192 10.3.1 主流程 195 10.3.2 清除无效缓存 195 10.3.3 查找缓存 196 10.3.4 缓存未命中 198 10.3.5 缓存命中 198 10.3.6 缓存内容陈旧需重新验证 202 10.3.7 缓存内容无效需重新执行请求 205 10.3.8 缓存响应 206 10.3.9 缓存头总结 207 10.4 Nginx HTTP缓存设置 208 10.4.1 expires 208 10.4.2 if-modified-since 209 10.4.3 nginx proxy_pass 209 10.5 Nginx代理层缓存 212 10.5.1 Nginx代理层缓存配置 212 10.5.2 清理缓存 215 10.6 一些经验 216 参考资料 217 11 多级缓存 218 11.1 多级缓存介绍 218 11.2 如何缓存数据 220 11.2.1 过期与不过期 220 11.2.2 维度化缓存与增量缓存 221 11.2.3 大Value缓存 221 11.2.4 热点缓存 221 11.3 分布式缓存与应用负载均衡 222 11.3.1 缓存分布式 222 11.3.2 应用负载均衡 222 11.4 热点数据与更新缓存 223 11.4.1 单机全量缓存+主从 223 11.4.2 分布式缓存+应用本地热点 224 11.5 更新缓存与原子性 225 11.6 缓存崩溃与快速修复 226 11.6.1 取模 226 11.6.2 一致性哈希 226 11.6.3 快速恢复 226 12 连接池线程池详解 227 12.1 数据库连接池 227 12.1.1 DBCP连接池配置 228 12.1.2 DBCP配置建议 233 12.1.3 数据库驱动超时实现 234 12.1.4 连接池使用的一些建议 235 12.2 HttpClient连接池 236 12.2.1 HttpClient 4.5.2配置 236 12.2.2 HttpClient连接池源码分析 240 12.2.3 HttpClient 4.2.3配置 241 12.2.4 问题示例 243 12.3 线程池 244 12.3.1 Java线程池 245 12.3.2 Tomcat线程池配置 248 13 异步并发实战 250 13.1 同步阻塞调用 251 13.2 异步Future 252 13.3 异步Callback 253 13.4 异步编排CompletableFuture 254 13.5 异步Web服务实现 257 13.6 请求缓存 259 13.7 请求合并 261 14 如何扩容 266 14.1 单体应用垂直扩容 267 14.2 单体应用水平扩容 267 14.3 应用拆分 268 14.4 数据库拆分 271 14.5 数据库分库分表示例 275 14.5.1 应用层还是中间件层 275 14.5.2 分库分表策略 277 14.5.3 使用sharding-jdbc分库分表 279 14.5.4 sharding-jdbc分库分表配置 279 14.5.5 使用sharding-jdbc读写分离 283 14.6 数据异构 284 14.6.1 查询维度异构 284 14.6.2 聚合数据异构 285 14.7 任务系统扩容 285 14.7.1 简单任务 285 14.7.2 分布式任务 287 14.7.3 Elastic-Job简介 287 14.7.4 Elastic-Job-Lite功能与架构 287 14.7.5 Elastic-Job-Lite示例 288 15 队列术 295 15.1 应用场景 295 15.2 缓冲队列 296 15.3 任务队列 297 15.4 消息队列 297 15.5 请求队列 299 15.6 数据总线队列 300 15.7 混合队列 301 15.8 其他队列 302 15.9 Disruptor+Redis队列 303 15.9.1 简介 303 15.9.2 XML配置 304 15.9.3 EventWorker 305 15.9.4 EventPublishThread 307 15.9.5 EventHandler 308 15.9.6 EventQueue 308 15.10 下单系统水平可扩展架构 311 15.10.1 下单服务 313 15.10.2 同步Worker 313 15.11 基于Canal实现数据异构 314 15.11.1 Mysql主从复制 315 15.11.2 Canal简介 316 15.11.3 Canal示例 318 第4部分案例 323 16 构建需求响应式亿级商品详情页 324 16.1 商品详情页是什么 324 16.2 商品详情页前端结构 325 16.3 我们的性能数据 327 16.4 单品页流量特点 327 16.5 单品页技术架构发展 327 16.5.1 架构1.0 328 16.5.2 架构2.0 328 16.5.3 架构3.0 330 16.6 详情页架构设计原则 332 16.6.1 数据闭环 332 16.6.2 数据维度化 333 16.6.3 拆分系统 334 16.6.4 Worker无状态化+任务化 334 16.6.5 异步化+并发化 335 16.6.6 多级缓存化 335 16.6.7 动态化 336 16.6.8 弹性化 336 16.6.9 降级开关 336 16.6.10 多机房多活 337 16.6.11 多种压测方案 338 16.7 遇到的一些坑和问题 339 16.7.1 SSD性能差 339 16.7.2 键值存储选型压测 340 16.7.3 数据量大时JIMDB同步不动 342 16.7.4 切换主从 342 16.7.5 分片配置 342 16.7.6 模板元数据存储HTML 342 16.7.7 库存接口访问量600w/分钟 343 16.7.8 微信接口调用量暴增 344 16.7.9 开启Nginx Proxy Cache性能不升反降 344 16.7.10 配送至读服务因依赖太多,响应时间偏慢 344 16.7.11 网络抖动时,返回502错误 346 16.7.12 机器流量太大 346 16.8 其他 347 17 京东商品详情页服务闭环实践 348 17.1 为什么需要统一服务 348 17.2 整体架构 349 17.3 一些架构思路和总结 350 17.3.1 两种读服务架构模式 351 17.3.2 本地缓存 352 17.3.3 多级缓存 353 17.3.4 统一入口/服务闭环 354 17.4 引入Nginx接入层 354 17.4.1 数据校验/过滤逻辑前置 354 17.4.2 缓存前置 355 17.4.3 业务逻辑前置 355 17.4.4 降级开关前置 355 17.4.5 AB测试 356 17.4.6 灰度发布/流量切换 356 17.4.7 监控服务质量 356 17.4.8 限流 356 17.5 前端业务逻辑后置 356 17.6 前端接口服务端聚合 357 17.7 服务隔离 359 18 使用OpenResty开发高性能Web应用 360 18.1 OpenResty简介 361 18.1.1 Nginx优点 361 18.1.2 Lua的优点 361 18.1.3 什么是ngx_lua 361 18.1.4 开发环境 362 18.1.5 OpenResty生态 362 18.1.6 场景 362 18.2 基于OpenResty的常用架构模式 363 18.2.1 负载均衡 363 18.2.2 单机闭环 364 18.2.3 分布式闭环 367 18.2.4 接入网关 368 18.2.5 核心接入Nginx功能 369 18.2.6 业务Nginx功能 369 18.2.7 Web应用 370 18.3 如何使用OpenResty开发Web应用 371 18.3.1 项目搭建 371 18.3.2 启停脚本 372 18.3.3 配置文件 372 18.3.4 nginx.conf配置文件 373 18.3.5 Nginx项目配置文件 373 18.3.6 业务代码 374 18.3.7 模板 374 18.3.8 公共Lua库 375 18.3.9 功能开发 375 18.4 基于OpenResty的常用功能总结 375 18.5 一些问题 376 19 应用数据静态化架构高性能单页Web应用 377 19.1 整体架构 378 19.1.1 CMS系统 379 19.1.2 前端展示系统 380 19.1.3 控制系统 380 19.2 数据和模板动态化 381 19.3 多版本机制 381 19.4 异常问题 382 20 使用OpenResty开发Web服务 383 20.1 架构 383 20.2 单DB架构 384 20.2.1 DB+Cache/数据库读写分离架构 384 20.2.2 OpenResty+Local Redis+Mysql集群架构 385 20.2.3 OpenResty+Redis集群+Mysql集群架构 386 20.3 实现 387 20.3.1 后台逻辑 388 20.3.2 前台逻辑 388 20.3.3 项目搭建 389 20.3.4 Redis+Twemproxy配置 389 20.3.5 Mysql+Atlas配置 390 20.3.6 Java+Tomcat安装 394 20.3.7 Java+Tomcat逻辑开发 395 20.3.8 Nginx+Lua逻辑开发 401 21 使用OpenResty开发商品详情页 405 21.1 技术选型 407 21.2 核心流程 408 21.3 项目搭建 408 21.4 数据存储实现 410 21.4.1 商品基本信息SSDB集群配置 410 21.4.2 商品介绍SSDB集群配置 413 21.4.3 其他信息Redis配置 417 21.4.4 集群测试 418 21.4.5 Twemproxy配置 419 21.5 动态服务实现 422 21.5.1 项目搭建 422 21.5.2 项目依赖 422 21.5.3 核心代码 423 21.5.4 基本信息服务 424 21.5.5 商品介绍服务 426 21.5.6 其他信息服务 426 21.5.7 辅助工具 427 21.5.8 web.xml配置 428 21.5.9 打WAR包 428 21.5.10 配置Tomcat 428 21.5.11 测试 429 21.5.12 Nginx配置 429 21.5.13 绑定hosts测试 430 21.6 前端展示实现 430 21.6.1 基础组件 430 21.6.2 商品介绍 432 21.6.4 前端展示 434 21.6.5 测试 442
## 项目功能 1. 架构潮流:系统采用SpringBoot+VUE前后端分离,前端单独部署,Nginx负载均衡 2. 接口友好:同时支持swagger2、knife4j两种可视化接口API调试,支持离线接口文档; 3. 任务管理:支持通过Web页面对任务进行CRUD操作,可视化界面,快速上手; 4. 执行记录:支持通过web页面在线查看调度结果、执行结果、下次执行时间; 5. 实时日志:支持通过web页面实时查看执行器输出的完整的执行日志; 6. 唯一搜索:支持通过web界面根据jobname或jobgroup进行全局唯一查询 7. 强自定义:支持在线配置定时任务请求类型、请求路径、请求参数、Cron表达式,即时生效; 8. 动态控制:支持动态修改任务状态、启动/停止任务,以及终止运行中任务,即时生效; 9. 执行策略:支持丰富的执行策略,包括:Get请求、PostJson请求、PostFrom表单请求; 10. 自动注册:周期性自动注册任务, 同时,也支持手动录入定时任务地址; 11. 自动执行:系统会自动发现注册的任务并触发执行,同时,也支持手动触发-立即执行; 12. 用户管理:支持在线管理系统用户、角色、菜单,默认管理员、开发者、普通用户三种角色; 13. 权限控制:支持在线权限控制,管理员拥有全量权限,开发者拥有除角色管理外的所有权限,普通用户仅支持任务管理相关权限; 14. 集群部署:支持分布式执行,系统支持集群部署,可保证任务执行的高可用; 15. 弹性调度:一旦有任务机器上线或者下线,下次调度时将会重新分配任务; 16. 路由策略:系统集群部署时提供丰富的路由策略,包括:轮询、随机、故障转移、忙碌转移等常用策略; 17. 故障转移:任务路由策略选择"故障转移"情况下,如果集群中某一台机器故障,将会自动切换到一台正常的执行器发送调度请求; 18. 阻塞策略:调度过于密集执行器来不及处理时的处理策略,策略包括:单机串行(默认)、丢弃后续调度、覆盖之前调度; 19. 超时控制:支持自定义任务超时时间,任务运行超时将会主动中断任务; 20. 重试机制:支持自定义任务重试次数,当任务失败时将会按照预设的失败重试次数主动进行重试; 21. 消息工厂:默认提供邮件工厂的方式推送消息,同时预留扩展接口,可方便的扩展短信、钉钉等消息方式; 22. 邮件告警:任务失败时支持邮件报警,支持配置多邮件地址群发报警邮件; 23. 运行报表:支持实时查看运行数据,以及调度报表,如调度日期分布图,任务组执行比例比例分布图等; 24. 事件触发:除了"Cron方式"和"任务依赖方式"触发任务执行之外,提供触发任务单次执行的API服务; 25. 脚本任务:支持以GLUE分布式平台开发和运行脚本任务,包括Shell、Python、NodeJS等类型脚本; 26. 多线并发:系统支持多线程触发调度运行,确保调度精确执行,不被堵塞; 27. 降级隔离:调度线程池进行隔离拆分,慢任务自动降级进入"Slow"线程池,避免耗尽调度线程,提高系统稳定性; 28. Gradle: 将会把最新稳定版推送到gradle中央仓库, 方便用户接入和使用; 29. Maven: 将会把最新稳定版推送到maven中央仓库, 方便用户接入和使用; 30. 一致性:基于Redis分布式锁保证集群分布式调度的最终一致性, 一次任务调度只会触发一次执行; 31. 全异步:任务调度流程全异步化设计实现,如异步调度、异步运行、异步回调等,有效对密集调度进行流量削峰,理论上支持任意时长任务的运行; 32. 跨语言:系统提供语言无关的 RESTFUL API 服务,第三方任意语言可据此对接Task Manage; 33. 国际化:后管系统支持国际化设置,提供中文、英文两种可选语言,默认为中文; 34. 容器化:提供官方docker镜像,并实时更新推送dockerhub,进一步实现产品开箱即用; ## 项目备注 1、该资源内项目代码都经过测试运行成功,功能ok的情况下才上传的,请放心下载使用! 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习,也适合小白学习进阶,当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行,也可在此代码基础上进行修改,以实现其他功能,也可用于毕设、课设、作业等。 下载后请首先打开README.md文件(如有),仅供学习参考, 切勿用于商业用途。
1.andbase中包含了大量的开发常用手段。 如网络下载,多线程与线程池的管理,数据库ORM,图片缓存管理,图片文件下载上传,Http请求工具,SOAP工具类,异步Task,常用工具类(字符串,日期,文件处理,图片处理工具) 开发工具在软件开发生命周期中扮演着至关重要的角色,它们旨在简化和加速从概念设计到产品部署的各个环节。以下是开发工具的主要作用: 代码编写与编辑: 提供集成开发环境(IDE),如Visual Studio、Eclipse、Android Studio和Sublime Text等,这些工具集成了文本编辑器,支持语法高亮、自动补全、代码片段管理和版本控制等功能,有助于开发者高效编写和维护代码。 项目管理: 支持项目创建、组织、构建自动化以及依赖管理,确保不同模块和组件之间的协调一致。 编译与构建: 包括编译器、构建工具(如Make、Gradle、Maven)等,用于将源代码转换为可执行文件或库,并进行资源打包、优化等处理。 调试与测试: 集成调试器允许开发者逐行执行代码,设置断点、查看变量值、跟踪调用堆栈等,帮助定位并修复代码中的错误。 测试框架和工具则协助开发者编写和运行单元测试、集成测试及性能测试,确保软件质量。 版本控制与协作: 通过集成Git、SVN等版本控制系统,支持团队成员间的代码共享、分支管理、合并请求和冲突解决。 可视化设计与原型制作: 对于UI/UX设计,有界面设计工具,如Sketch、Adobe XD,可以帮助设计师快速构建应用程序界面模型,并生成规范的设计稿供开发人员参考实现。 跨平台支持: 跨平台开发工具如Xamarin、React Native和Flutter,让开发者使用一种语言或框架编写可以在多个操作系统上运行的应用程序。 文档编写与API管理: 文档生成工具可以自动生成代码注释文档,便于团队内外理解和使用项目代码。 API管理工具则方便开发者创建、测试、发布和维护API接口。 持续集成与持续部署(CI/CD): Jenkins、Travis CI、GitHub Actions等工具负责自动化构建、测试和部署流程,提高交付效率和可靠性。 数据库管理与ORM工具: 数据库客户端工具用于连接、查询、更新数据库,ORM(对象关系映射)工具简化了数据操作和持久化层的开发工作。 总之,开发工具极大地提升了软件工程师的工作效率,保证了开发过程中的准确性与一致性,同时也促进了团队合作,使得软件开发更系统化、规范化和工业化。
第一篇 起步篇 第1章 初识Java 3 1.1 Java简介 3 1.1.1 Java的不同平台 3 1.1.2 Java发展的历程 3 1.1.3 Java的特点 4 1.2 安装开发工具包 5 1.2.1 下载JDK 5 1.2.2 安装JDK 6 1.2.3 安装后Java目录的解读 7 1.3 学会使用API 7 1.4 第一个Java程序 8 1.4.1 开发源代码 8 1.4.2 编译运行 9 1.5 小结 11 第2章 基本数据类型——构建Java 大厦的基础 12 2.1 源代码注释 12 2.1.1 单行注释 12 2.1.2 区域注释 12 2.1.3 文档注释 13 2.2 基本数据类型 14 2.2.1 整型 15 2.2.2 浮点型 17 2.2.3 char型 17 2.2.4 boolean型 18 2.3 基本数据类型值间的转换 18 2.3.1 自动转换 18 2.3.2 手动强制转换 19 2.3.3 隐含强制转换 19 2.4 标识符命名规范 20 2.4.1 正确的命名标识符 20 2.4.2 提倡的命名习惯 21 2.5 小结 21 第3章 表达式——描述行为的元素 22 3.1 不简单的算术运算符 22 3.1.1 “+”运算符 22 3.1.2 “-”运算符 24 3.1.3 “*”运算符 25 3.1.4 “/”运算符 25 3.1.5 “%”运算符 26 3.2 自增自减运算 27 3.3 关系运算 28 3.3.1 等于/不等于运算 28 3.3.2 比较大小运算 29 3.4 逻辑运算 30 3.4.1 “与”运算 30 3.4.2 “或”运算 31 3.4.3 “非”运算 32 3.5 三元运算符 32 3.6 位运算 33 3.7 移位运算 34 3.7.1 “”左移 35 3.7.2 “”右移 35 3.7.3 “”无符号右移 36 3.7.4 令人困扰的例子 37 3.8 赋值运算 37 3.8.1 普通赋值运算 37 3.8.2 运算赋值运算 38 3.9 括号及运算符间的优先级关系 38 3.10 常用数学工具包——java.lang.Math类 39 3.10.1 数学常量 39 3.10.2 常用数学函数 40 3.11 小结 41 第4章 流程控制——Java世界的航行舵手 42 4.1 if条件语句 42 4.1.1 简略形式 42 4.1.2 完全形式 43 4.1.3 语句的嵌套 43 4.2 switch多分支语句 45 4.2.1 基本语法 45 4.2.2 合法的判断表达式 46 4.2.3 合法的case表达式 47 4.2.4 详细执行流程 49 4.3 while循环语句 50 4.4 do-while循环语句 52 4.5 for循环语句 53 4.5.1 基本语法 53 4.5.2 声明的三大组成部分 54 4.5.3 复杂的for循环案例 55 4.5.4 用for实现其他循环 55 4.6 break中断语句 56 4.7 continue继续语句 57 4.8 小结 58 第5章 数组——以不变应万变的哲学 59 5.1 数组的声明及创建 59 5.1.1 声明数组引用 59 5.1.2 创建数组对象 60 5.2 Java中数组的实现机制 61 5.3 数组的初始化 63 5.3.1 默认初始化 63 5.3.2 利用循环初始化 64 5.3.3 枚举初始化 66 5.4 数组的相互赋值 67 5.4.1 基本类型数组赋值规则 67 5.4.2 引用型数组赋值规则 68 5.5 数组的常用操作 69 5.5.1 数组复制 69 5.5.2 数组排序 71 5.5.3 搜索指定元素 72 5.5.4 比较数组中的元素 73 5.6 关于args[] 73 5.7 小结 74 第二篇 基础篇 第6章 对象和类——Java世界的细胞 77 6.1 面向对象概述 77 6.1.1 面向对象程序设计思想的诞生 77 6.1.2 面向过程与面向对象思想的对比 78 6.1.3 面向对象技术的背景和特点 79 6.2 类的定义与对象的创建 80 6.3 成员变量 81 6.3.1 成员变量的开发与使用 81 6.3.2 成员变量的初始值 82 6.3.3 对象引用变量的比较 84 6.4 方法 85 6.5 变长参数 86 6.6 引用问题 87 6.6.1 调用不存在的方法或成员变量 87 6.6.2 用空引用进行调用 88 6.6.3 数组的空引用问题 89 6.7 局部变量 89 6.7.1 局部变量的作用域 89 6.7.2 局部变量的初始化 90 6.8 this预定义对象引用 92 6.9 擅用系统已有的类 94 6.9.1 Java中的Date类 94 6.9.2 Java中的GregorianCalendar类 96 6.9.3 擅用系统已有类的思想 98 6.10 小结 99 第7章 访问控制——Java世界的卫兵 100 7.1 包的使用 100 7.1.1 声明创建包 100 7.1.2 引入包内的资源 102 7.1.3 静态引入 104 7.2 类的访问控制 105 7.2.1 公有访问级别 105 7.2.2 默认访问级别 106 7.2.3 类与源代码文件的搭配 106 7.3 成员的访问控制 107 7.3.1 公共类型 107 7.3.2 私有类型 108 7.3.3 默认类型 109 7.3.4 保护类型 109 7.3.5 Java中封装的实现 110 7.4 final的变量 112 7.4.1 final的成员变量 113 7.4.2 final的局部变量 115 7.5 static关键字的使用 116 7.5.1 静态成员 116 7.5.2 静态成员的访问 117 7.5.3 静态最终成员变量 119 7.6 小结 121 第8章 继承——多态的支柱 122 8.1 继承概述 122 8.1.1 类之间的关系 122 8.1.2 面向对象中的继承性 124 8.2 类的继承 125 8.3 成员变量的继承与隐藏 126 8.3.1 成员变量的继承规则 126 8.3.2 成员变量的隐藏 129 8.4 对象引用的使用 130 8.4.1 对象引用能指向的对象类型 130 8.4.2 对象引用的强制类型转换 131 8.4.3 对象引用所能调用的成员 132 8.4.4 对象引用的赋值与比较 133 8.5 方法的继承与重写 135 8.5.1 方法的继承规则 135 8.5.2 方法重写的基本知识 136 8.5.3 构成重写的条件 137 8.5.4 返回类型的规则 138 8.5.5 访问级别的要求 140 8.5.6 重写基于继承 141 8.5.7 静态方法没有重写 141 8.5.8 通过重写扩展父类方法的功能 143 8.5.9 替代性原理 144 8.6 方法的重载 145 8.6.1 方法重载的规则 145 8.6.2 重载方法的匹配 145 8.6.3 重写与重载的区别 149 8.7 final与继承 149 8.7.1 最终的类 149 8.7.2 最终的方法 150 8.8 abstract与继承 151 8.8.1 抽象的类 151 8.8.2 抽象的方法 152 8.9 基于继承的多态 154 8.10 小结 155 第9章 接口——灵活性的基石 156 9.1 概述及其特性 156 9.2 成员变量在接口中的使用 157 9.2.1 语法规则 157 9.2.2 接口中成员变量的作用 158 9.3 方法在接口中的使用 159 9.3.1 语法规则 159 9.3.2 如何实现接口 160 9.3.3 接口引用的使用 162 9.3.4 接口中方法无法使用的修饰符 165 9.4 接口与抽象类 166 9.4.1 语法上的不同 167 9.4.2 具体含义的不同 167 9.5 基于接口的多态 169 9.6 接口与回调 170 9.7 instanceof的使用 172 9.7.1 基本语法与使用 172 9.7.2 不允许进行测试的情况 174 9.8 小结 175 第10章 构造器——对象制造的工厂 176 10.1 基础知识 176 10.1.1 编写构造器的语法规则 176 10.1.2 访问限制修饰符与构造器 176 10.1.3 构造器与返回类型 179 10.2 创建对象 180 10.3 重载构造器 181 10.4 级联调用的构造器 182 10.4.1 构造器的调用流程及默认构造器 182 10.4.2 自定义构造器需要注意的问题 185 10.4.3 不能继承构造器 186 10.4.4 调用兄弟构造器 187 10.5 单列模式 189 10.6 Java程序的加载过程 190 10.7 小结 192 第三篇 高级基础篇 第11章 异常处理——Java世界的医生 195 11.1 异常处理的基本知识 195 11.1.1 try和catch捕获异常 195 11.1.2 异常的传播过程 198 11.1.3 finally语句块的使用 199 11.1.4 try、catch及finally语句块之间需要注意的问题 201 11.2 异常的层次结构 203 11.2.1 捕获异常 203 11.2.2 未捕获异常 205 11.3 再次抛出异常 206 11.3.1 什么是异常的再抛出 206 11.3.2 显性再抛出 207 11.3.3 隐性再抛出 209 11.3.4 方法重写对抛出异常声明的约束 210 11.4 定义自己的异常 212 11.4.1 创建自己的异常类 212 11.4.2 使用自定义的异常类 213 11.4.3 显性再抛出作用的体现 215 11.5 异常的匹配 217 11.5.1 同时捕获多种异常 217 11.5.2 多个catch语句的先后顺序 218 11.6 断言 219 11.6.1 什么是断言 219 11.6.2 如何启用/关闭断言 220 11.6.3 防止滥用断言 222 11.7 小结 222 第12章 封装类——鸿沟之上的桥梁 223 12.1 封装类的基本知识 223 12.1.1 封装类概述 223 12.1.2 创建封装类对象 223 12.1.3 封装类对象的其他知识 225 12.2 数据转换功能 226 12.2.1 基本数据类型值转换为字符串 226 12.2.2 字符串转换为基本数据类型值 229 12.3 其他常用方法 231 12.3.1 静态工厂方法 231 12.3.2 isNaN方法 232 12.3.3 equals方法 233 12.4 自动打包/解包 -235 12.4.1 自动打包 235 12.4.2 自动解包 236 12.5 特殊的数值计算 237 12.5.1 特大整数的计算 237 12.5.2 浮点数的精确计算 239 12.6 小结 242 第13章 字符串——优异的内存组织机制 243 13.1 String类的基础知识 243 13.1.1 对象的创建 243 13.1.2 巧用构造器 244 13.1.3 String类的重要方法 245 13.2 String对象的内存机制 248 13.2.1 一段令人困惑的字符串程序 248 13.2.2 “一次投入,终身回报”的String内存机制 249 13.2.3 String对象特殊机制付出的代价 252 13.3 StringBuffer类 253 13.3.1 弥补String不足的StringBuffer类 253 13.3.2 编写方法链以及StringBuffer类的重要方法 255 13.4 StringBuilder类 258 13.5 正则表达式 259 13.5.1 正则表达式的基本语法 259 13.5.2 Pattern类简介 262 13.5.3 Matcher类简介 263 13.5.4 Pattern与Matcher类的综合应用 264 13.6 String类中正则式的应用 266 13.6.1 模式匹配检查 266 13.6.2 利用正则式进行查找替换 267 13.6.3 利用正则式对字符串进行分析 268 13.7 小结 269 第14章 集合框架——强大的对象管理器 270 14.1 Object类——所有类的超类 270 14.1.1 toString方法的重写 270 14.1.2 equals方法的意义 271 14.1.3 hashCode方法的意义 272 14.2 重写equals与hashCode方法 273 14.2.1 重写equals方法 273 14.2.2 重写hashCode方法 275 14.3 集合框架的层次结构 -277 14.4 Ordered与Sorted的接口 278 14.4.1 Ordered的排序 278 14.4.2 Sorted的排序 279 14.5 列表 279 14.5.1 列表接口——st 279 14.5.2 列表的数组实现 281 14.5.3 历史悠久的向量 282 14.5.4 列表的链接实现 284 14.5.5 依赖性倒置原理 285 14.5.6 将数组转换为列表 285 14.6 集合 286 14.6.1 Set接口及含义 286 14.6.2 HashSet类的使用 287 14.6.3 equals与hashCode方法重写规定的作用 288 14.6.4 LinkedHashSet类的使用 291 14.6.5 SortedSet接口与TreeSet类 292 14.6.6 自定义满足Sorted集合的类 293 14.6.7 定制SortedSet的排序规则 296 14.6.8 集合的遍历 298 14.6.9 使用for-each循环遍历集合 300 14.7 映射集 301 14.7.1 Map接口及含义 301 14.7.2 HashMap类的使用 302 14.7.3 Hashtable类的使用 303 14.7.4 LinkedHashMap类的使用 304 14.7.5 SortedMap接口与TreeMap类 305 14.7.6 映射的遍历 308 14.8 栈在Java中的实现 309 14.8.1 Stack类的使用 309 14.8.2 Deque接口的使用 310 14.8.3 利用栈计算数学表达式 311 14.9 集合元素的常用操作 314 14.9.1 元素排序 315 14.9.2 搜索特定元素 316 14.9.3 任意打乱元素顺序 317 14.9.4 其他的简单操作 318 14.10 小结 320 第15章 内部类——Java世界的多面手 321 15.1 非静态内部类 321 15.1.1 语法规则 321 15.1.2 外部类之内创建内部类对象 322 15.1.3 外部类之外创建内部类对象 323 15.1.4 内部类与外部类之间的成员互访 324 15.1.5 内部类与外部类的预定义对象引用this 327 15.2 局部内部类 328 15.2.1 局部内部类的定义及创建 328 15.2.2 局部变量与局部内部类 329 15.2.3 静态方法中的局部内部类 331 15.3 静态内部类 332 15.3.1 语法规则 332 15.3.2 创建静态内部类的对象 332 15.3.3 静态/非静态内部类的区别 333 15.4 匿名内部类 334 15.4.1 基于继承的匿名内部类 334 15.4.2 基于接口实现的匿名内部类 335 15.4.3 匿名内部类的初始化 337 15.4.4 匿名内部类作用的体现 337 15.5 理解内部类 339 15.6 内部接口 340 15.6.1 定义在类中的内部接口 340 15.6.2 定义在接口中的内部接口 341 15.7 小结 342 第16章 多线程——Java中的并发协作 343 16.1 线程的基本知识 343 16.1.1 多线程编程的意义 343 16.1.2 定义自己的线程 344 16.1.3 创建线程对象 345 16.1.4 启动线程 347 16.1.5 同时使用多个线程 348 16.2 线程的状态 350 16.3 线程的调度 351 16.3.1 睡眠 351 16.3.2 线程的优先级 353 16.3.3 线程的让步 355 16.3.4 守护线程 357 16.4 线程的同步 359 16.4.1 同步方法简介 359 16.4.2 简单使用同步方法 360 16.4.3 线程同步调度的方法 362 16.4.4 “生产者-消费者”案例的框架 362 16.4.5 “生产者-消费者”案例的实际运行 365 16.4.6 notify方法的使用 366 16.4.7 同步的语句块 367 16.4.8 线程的死锁 369 16.4.9 防止错误的使用wait、notify、notifyAll方法 371 16.5 获取当前正在运行的线程 372 16.6 volatile关键字的含义与使用 372 16.7 小结 373 第17章 高级线程开发 374 17.1 线程池的使用 374 17.1.1 线程池的基本思想 374 17.1.2 JavaSE 5.0中固定尺寸线程池的基本知识 374 17.1.3 自定义尺寸固定线程池的使用 375 17.1.4 单任务线程池的使用 377 17.1.5 可变尺寸线程池的使用 378 17.1.6 延迟线程池的使用 380 17.1.7 使用自定义参数的线程池 381 17.2 有返回值的线程调用 384 17.2.1 Callable接口简介 384 17.2.2 Future接口简介 384 17.2.3 Callable与Future接口的具体使用 385 17.3 资源的封锁 386 17.3.1 Lock接口与ReentrantLock类简介 386 17.3.2 ReentrantLock锁的具体使用 387 17.3.3 ReadWriteLock接口与ReentrantReadWriteLock类简介 390 17.3.4 ReentrantReadWriteLock读/写锁的具体使用 391 17.4 信号量的使用 393 17.4.1 Semaphore类简介 393 17.4.2 Semaphore类的具体使用 394 17.5 队列 396 17.5.1 Queue接口介绍 396 17.5.2 PriorityQueue类的知识与使用 397 17.5.3 BlockingQueue接口介绍 399 17.6 阻塞的栈操作 401 17.6.1 BlockingDeque接口与LinkedBlockingDeque类简介 401 17.6.2 LinkedBlockingDeque类的具体使用 402 17.7 线程安全的单变量操作 403 17.7.1 atomic包简介 403 17.7.2 atomic包中类的具体使用 404 17.8 障碍器 406 17.8.1 CyclicBarrier类简介 406 17.8.2 CyclicBarrier类的具体使用 407 17.9 小结 408 第18章 内存管理与垃圾收集——自动化的典范 409 18.1 什么是“垃圾” 409 18.1.1 对象成为“垃圾”的条件 409 18.1.2 符合条件的几种情况 409 18.2 垃圾收集器 411 18.2.1 垃圾收集器的基本介绍 411 18.2.2 申请垃圾收集器运行 412 18.3 垃圾收集前的处理工作 413 18.3.1 finalize方法的重写 414 18.3.2 finalize方法的安全问题 415 18.3.3 最终守护者模式 417 18.3.4 再谈非线程“垃圾” 418 18.3.5 再谈线程“垃圾” 419 18.4 3种特殊的引用 420 18.4.1 弱引用 421 18.4.2 软引用 422 18.4.3 幻影引用 424 18.5 小结 424 第四篇 Swing GUI篇 第19章 初识Swing 427 19.1 Swing概述 427 19.2 一个简单的Swing程序 428 19.3 Swing的过人之处 429 19.3.1 完全轻量级的控件 430 19.3.2 可插拔的感观风格 430 19.3.3 更多的控件扩展 430 19.4 Swing和AWT的对比 432 19.4.1 Swing与AWT之间的关系 432 19.4.2 Swing与AWT的控件的混用建议 432 19.5 小结 433 第20章 开始创建Swing应用程序 434 20.1 窗体——JFrame类 434 20.1.1 JFrame类简介 434 20.1.2 创建简单窗体 436 20.2 AWT1.1事件处理模型 438 20.2.1 事件的处理模型简介 438 20.2.2 事件的层次结构 439 20.2.3 窗体事件 440 20.2.4 事件适配器 442 20.3 面板——JPanel类 444 20.3.1 容器的基本知识 444 20.3.2 JPanel类简介 445 20.3.3 JPanel的简单使用 445 20.4 标签——JLabel类 446 20.4.1 JLabel类简介 446 20.4.2 使用JLabel类 448 20.5 按钮——JButton类 449 20.5.1 JButton类简介 449 20.5.2 动作事件 450 20.5.3 监听器与事件源对应关系的研究 451 20.6 小结 454 第21章 布局管理器——界面设计的利器 455 21.1 布局管理器设计思想概述 455 21.2 常用布局管理器简介 455 21.3 流布局 456 21.3.1 流布局简介 456 21.3.2 使用流布局 458 21.4 网格布局 459 21.4.1 网格布局简介 459 21.4.2 使用网格布局 460 21.5 边框布局 462 21.5.1 边框布局简介 462 21.5.2 使用边框布局 464 21.6 空布局 465 21.6.1 空布局简介 465 21.6.2 使用空布局 466 21.7 卡片布局 467 21.7.1 卡片布局简介 467 21.7.2 使用卡片布局 468 21.8 箱式布局 470 21.8.1 箱式布局简介 471 21.8.2 Box容器简介 472 21.8.3 Box容器与BoxLayout布局管理器的使用 473 21.9 弹簧布局 475 21.9.1 弹簧布局的基本思想 475 21.9.2 SpringLayout类简介 478 21.9.3 SpringLayoutConstraints内部类简介 479 21.9.4 Spring类简介 480 21.9.5 弹簧布局的简单使用 480 21.9.6 描述法弹簧布局的具体使用 482 21.10 小结 483 第22章 Swing常用基本控件 484 22.1 控件类概述 484 22.2 文本框与密码框 487 22.2.1 JTextField类简介 487 22.2.2 JPasswordField类简介 488 22.2.3 登录窗口的案例 489 22.3 Swing中的文本区 491 22.3.1 JTextArea类简介 491 22.3.2 JScrollPane类详细介绍 493 22.3.3 文本区与滚动窗口的组合使用 494 22.4 可以记录状态的开关按钮 496 22.4.1 JToggleButton类简介 496 22.4.2 开关按钮的使用 497 22.5 单选按钮与复选框 499 22.5.1 JRadioButton类简介 499 22.5.2 ButtonGroup类简介 500 22.5.3 JCheckBox类简介 500 22.5.4 ItemEvent事件 501 22.5.5 一个关于ItemEvent事件的例子 502 22.5.6 单选按钮与复选框的综合案例 504 22.6 小结 506 第23章 Swing常用高级控件 507 23.1 选项卡的相关知识与使用 507 23.1.1 JTabbedPane类简介 507 23.1.2 ChangeEvent事件 509 23.1.3 JTabbedPane实现选项卡的例子 509 23.2 分割窗格 511 23.2.1 JSplitPane类简介 511 23.2.2 分割窗格的嵌套使用 513 23.3 滑块与进度条 514 23.3.1 JSlider类简介 514 23.3.2 JProgressBar类简介 516 23.3.3 滑块与进度条的使用 518 23.4 格式化文本框 519 23.4.1 JFormattedTextField类简介 520 23.4.2 JFormattedTextField中的格式器 521 23.4.3 格式化文本框的具体使用 523 23.5 编辑器面板 525 23.5.1 JEditorPane类简介 525 23.5.2 HyperlinkEvent事件 527 23.5.3 使用JEditorPane实现简单的浏览器 527 23.6 列表框的知识与使用 529 23.6.1 JList类简介 530 23.6.2 ListSelectionEvent事件 531 23.6.3 控件MVC设计模式简介 532 23.6.4 JList类的使用 533 23.7 下拉列表框 534 23.7.1 JComboBox类简介 534 23.7.2 下拉列表框的具体使用 536 23.8 微调控制器 538 23.8.1 JSpinner类简介 538 23.8.2 微调控制器模型简介 539 23.8.3 微调控制器的具体使用 542 23.9 小结 543 第24章 菜单、工具栏与对话框 544 24.1 Swing中的菜单 544 24.1.1 Swing菜单的基本知识 544 24.1.2 JMenuBar类简介 545 24.1.3 JMenuItem类简介 546 24.1.4 JMenu类简介 549 24.1.5 JRadioButtonMenuItem类简介 550 24.1.6 JCheckBoxMenuItem类简介 551 24.1.7 菜单使用综合案例 551 24.2 Swing中的弹出式菜单 554 24.2.1 JPopupMenu类简介 554 24.2.2 弹出式菜单的显示 555 24.3 鼠标事件 555 24.3.1 鼠标事件简介 555 24.3.2 弹出式菜单的具体使用 557 24.4 工具栏的开发 559 24.4.1 JToolBar类简介 559 24.4.2 工具栏的具体使用 560 24.5 Swing中的对话框 562 24.5.1 JDialog类简介 562 24.5.2 JOptionPane类简介 563 24.5.3 JOptionPane对话框的具体使用 566 24.5.4 文件选择器 568 24.5.5 颜色选择器 571 24.5.6 文件、颜色对话框综合案例 572 24.6 小结 574 第25章 Swing中的树状列表 575 25.1 与树有关的专有名词 575 25.2 JTree类简介 576 25.2.1 JTree类构造器简介 576 25.2.2 JTree类的常用方法说明 577 25.2.3 一个简单JTree的实例 579 25.3 树模型 580 25.3.1 TreeModel接口简介 580 25.3.2 默认树模型DefaultTreeModel类 581 25.4 树的节点 582 25.4.1 TreeNode接口简介 582 25.4.2 MutableTreeNode接口简介 583 25.4.3 DefaultMutableTreeNode类简介 583 25.5 树的路径 586 25.6 树的相关事件 587 25.6.1 TreeSelectionEvent事件 587 25.6.2 TreeExpansionEvent事件 589 25.6.3 TreeModelEvent事件 589 25.7 树节点的绘制 590 25.7.1 TreeCellRenderer接口简介 590 25.7.2 DefaultTreeCellRenderer类简介 590 25.7.3 自定义绘制器案例 592 25.8 树状列表的综合案例 593 25.8.1 案例概述 593 25.8.2 搭建界面 594 25.8.3 添加信息提示功能 595 25.8.4 开发节点增删功能 597 25.8.5 添加图标更改功能 600 25.9 小结 602 第26章 Swing中的表格 603 26.1 初识表格 603 26.2 JTable类 604 26.2.1 JTable类简介 604 26.2.2 使用JTable的简单案例 606 26.3 表格的数据模型 608 26.3.1 TableModel接口简介 608 26.3.2 AbstractTableModel类简介 608 26.3.3 DefaultTableModel类简介 609 26.3.4 使用表格模型的简单案例 611 26.4 表格列 612 26.5 表格列模型 613 26.5.1 TableColumnModel接口简介 614 26.5.2 DefaultTableColumnModel类简介 614 26.6 表格的相关事件 616 26.6.1 表格相关事件简介 616 26.6.2 表格事件的示例程序 618 26.7 表格绘制器与编辑器 620 26.7.1 表格绘制器简介 620 26.7.2 表格编辑器简介 622 26.8 自定义表格编辑器与绘制器的综合案例 624 26.8.1 案例概述 624 26.8.2 界面框架的搭建 624 26.8.3 自定义表格模型的开发以及表格控件的添加 625 26.8.4 自定义绘制器的开发 627 26.8.5 添加自定义编辑器 628 26.9 表格中的排序与过滤 630 26.9.1 RowSorter类简介 631 26.9.2 DefaultRowSorter类简介 631 26.9.3 TableRowSorter类简介 632 26.9.4 RowFilter类简介 633 26.10 表格排序与过滤的综合案例 635 26.10.1 案例概述 635 26.10.2 搭建界面框架 636 26.10.3 添加表格 637 26.10.4 为表格添加排序器 638 26.10.5 添加设置过滤条件的控件 639 26.10.6 为表格设置过滤器 641 26.11 小结 643 第27章 高级Swing开发 644 27.1 Swing线程 644 27.1.1 事件分发线程简介 644 27.1.2 事件分发线程单线程模型带来的问题 644 27.1.3 解决不当使用事件分发线程引发的问题 645 27.2 Robot类的知识与应用 648 27.2.1 Robot类简介 648 27.2.2 利用Robot类实现自动演示功能 649 27.3 Desktop类的知识与应用 652 27.3.1 Desktop类简介 652 27.3.2 使用Desktop的综合案例 654 27.4 Swing应用程序的感观 656 27.4.1 UIManager类简介 657 27.4.2 MetalLookAndFeel类简介 658 27.4.3 动态切换外观风格的案例 658 27.5 系统托盘 661 27.5.1 SystemTray类简介 661 27.5.2 TrayIcon类简介 662 27.5.3 使用系统托盘的简单案例 663 27.6 应用程序的监控与管理 665 27.7 小结 666 第五篇 图形图像篇 第28章 图形绘制与动画 669 28.1 绘制简单图形 669 28.1.1 画布的相关知识 669 28.1.2 画笔的相关知识 670 28.1.3 颜色的调配 672 28.1.4 图形绘制的简单案例 673 28.2 绘制各种文本 674 28.2.1 drawString方法简介 675 28.2.2 字体的控制 675 28.2.3 文本绘制的简单案例 676 28.3 Java 2D 677 28.3.1 Graphics 2D类简介 677 28.3.2 控制线条的粗细 679 28.3.3 使用颜渐变色 680 28.3.4 图形变换 681 28.3.5 异或模式绘图 683 28.3.6 抗锯齿 685 28.4 动画的开发 685 28.4.1 动画实现的原理 685 28.4.2 Timer类简介 686 28.4.3 简单动画的案例 687 28.5 小结 689 第29章 图像处理 690 29.1 图像的加载与绘制 690 29.1.1 Image类简介 690 29.1.2 绘制Image图像 692 29.2 图标的使用 693 29.2.1 Icon接口简介 694 29.2.2 ImageIcon类简介 695 29.3 图像的编码处理 697 29.3.1 JPEG编码器简介 697 29.3.2 GifEncoder编码器简介 698 29.4 屏幕图像抓取 700 29.4.1 createScreenCapture方法简介 700 29.4.2 抓屏功能的案例 700 29.5 图像滤镜的开发 703 29.5.1 图像的灰度处理的基本知识 703 29.5.2 图像灰度处理的案例 705 29.5.3 RGB色彩通道过滤的基本知识 707 29.5.4 RGB色彩通道过滤的案例 708 29.5.5 卷积滤镜的基本知识 711 29.5.6 卷积滤镜的案例 712 29.6 小结 714 第六篇 高级应用篇 第30章 JDBC数据库开发 717 30.1 数据库应用的两种架构模型 717 30.1.1 两层结构数据库应用的架构模型 717 30.1.2 三层结构数据库应用的架构模型 718 30.2 JDBC的层次结构 718 30.3 JDBC编程基础 719 30.3.1 创建数据库 720 30.3.2 JDBC-ODBC连接桥 721 30.3.3 加载JDBC驱动 722 30.3.4 建立数据库连接 723 30.3.5 执行SQL命令 725 30.3.6 结果集 725 30.3.7 连接数据库的简单案例 726 30.3.8 预编译语句 728 30.4 访问其他数据库 730 30.4.1 访问MySQL数据库 730 30.4.2 访问Oracle数据库 732 30.5 事务 733 30.5.1 编写事务 734 30.5.2 批处理 736 30.6 可滚动结果集 738 30.6.1 获得可滚动的结果集 738 30.6.2 可滚动与不可滚动结果集的比较 739 30.6.3 控制游标移动 739 30.7 元数据 742 30.7.1 数据库元数据 742 30.7.2 结果集元数据 744 30.8 数据库综合案例——DBManager 746 30.8.1 案例概述 746 30.8.2 搭建主界面 747 30.8.3 开发输入数据库连接信息的对话框 749 30.8.4 初始化树状列表根节点 751 30.8.5 初始化树状列表表节点 753 30.8.6 初始化树状列表列节点 754 30.8.7 添加显示表数据的功能 756 30.8.8 添加显示列信息的功能 758 30.8.9 自定义树节点图标 759 30.8.10 连接其他类型数据库 761 30.8.11 案例小结 761 30.9 小结 761 第31章 Derby数据库的应用 762 31.1 Derby数据库简介 762 31.1.1 Derby的发展史及特性概述 762 31.1.2 JavaSE 6.0中Derby的目录结构 762 31.2 管理工具ij 763 31.2.1 准备工作 763 31.2.2 简单使用 764 31.3 Derby数据库的嵌入式应用 767 31.3.1 嵌入式Derby的工作原理 767 31.3.2 嵌入式Derby应用的开发步骤 767 31.3.3 使用嵌入式Derby的简单案例 768 31.4 Derby数据库的网络模式应用 770 31.4.1 网络模式Derby的工作原理 771 31.4.2 操作网络模式的Derby 771 31.4.3 开发启动Derby网络服务的程序 772 31.4.4 使用网络模式Derby的简单案例 774 31.5 小结 775 第32章 I/O流 776 32.1 I/O流的基本原理与分类 776 32.1.1 流的概念 776 32.1.2 节点流与处理流 776 32.1.3 字节流与字符流 777 32.2 节点流 780 32.2.1 常用节点流简介 780 32.2.2 使用节点流的简单案例 782 32.3 处理流 783 32.3.1 常用处理流简介 783 32.3.2 使用处理流的简单案例 785 32.4 系统输入输出 786 32.4.1 系统输入流 787 32.4.2 系统输出流 788 32.4.3 格式化输出的简单案例 790 32.4.4 系统错误流 791 32.4.5 系统输入输出重定向 792 32.5 进程控制 793 32.5.1 Process类简介 793 32.5.2 控制进程的简单案例 794 32.6 目录文件管理 795 32.6.1 File类简介 796 32.6.2 使用File的简单案例 797 32.7 I/O流综合案例——数据库图片查看器 798 32.7.1 案例概述 798 32.7.2 主界面与程序框架的搭建 799 32.7.3 添加图片功能的开发 801 32.7.4 查看图片功能的开发 804 32.7.5 删除图片功能的开发 806 32.7.6 案例小结 806 32.8 小结 806 第33章 套接字网络开发 807 33.1 TCP/IP协议简介 807 33.2 网络开发中的常用工具类 808 33.2.1 URL简介 808 33.2.2 URL类简介与使用 809 33.2.3 InetAddress类简介与使用 811 33.3 Socket编程 812 33.3.1 Socket编程简介 813 33.3.2 ServerSocket类简介 813 33.3.3 Socket类简介 814 33.3.4 C/S架构程序的简单案例 815 33.4 小结 817 第34章 反射与注解 818 34.1 反射 818 34.1.1 Class类简介 818 34.1.2 Class类的简单使用 820 34.1.3 数组与Class类 822 34.1.4 精确判断对象类型 823 34.1.5 Field类的知识与使用 824 34.1.6 Method类的知识与使用 826 34.1.7 Constructor类的知识与使用 828 34.1.8 反射与修饰符 830 34.1.9 取消访问限制 833 34.1.10 利用反射动态创建数组对象 835 34.2 程序注解 836 34.2.1 声明自己的注解 837 34.2.2 确定注解的使用目标 837 34.2.3 确定注解的使用时效 838 34.2.4 通过反射提取注解信息 839 34.2.5 标注性注解的使用 840 34.2.6 常用的系统注解 842 34.2.7 利用注解方便开发Web服务 844 34.2.8 注解与代码自动生成 845 34.3 小结 845 第35章 泛型程序设计 846 35.1 泛型简介 846 35.1.1 没有泛型的烦恼 846 35.1.2 泛型技术的好处 846 35.2 简单泛型程序的开发 847 35.2.1 泛型类或接口的声明 847 35.2.2 泛型方法的开发 849 35.2.3 类型变量的限制 850 35.3 泛型参数的继承以及通配符 851 35.3.1 泛型参数的继承问题 852 35.3.2 泛型通配符 852 35.3.3 泛型通配符使用的特殊注意 854 35.3.4 有限制的通配符 855 35.4 泛型的擦除 857 35.4.1 擦除的基本概念与规则 857 35.4.2 擦除引出的约束与局限性 858 35.5 系统提供的泛型类 859 35.6 小结 859 第36章 安全类型枚举 860 36.1 JavaSE 5.0之前的枚举 860 36.1.1 传统枚举实现方式的案例 860 36.1.2 传统实现方式带来的问题 861 36.2 JavaSE 5.0中的安全类型枚举 862 36.2.1 基本语法与简单使用 862 36.2.2 复杂的枚举类型 864 36.2.3 枚举类 866 36.3 小结 867 第37章 嵌入式脚本开发 868 37.1 基本步骤与知识 868 37.1.1 ScriptEngineManager类简介 868 37.1.2 ScriptEngineFactory接口简介 869 37.1.3 ScriptEngine接口简介 870 37.1.4 基本步骤 870 37.1.5 执行外部的脚本文件 871 37.2 其他第三方脚本引擎 872 37.2.1 引擎支持jar包的下载与安装 872 37.2.2 Ruby脚本的简单案例 873 37.2.3 Groovy脚本的简单案例 874 37.3 小结 874
Java范例开发大全(全书源程序),目录如下: 第1篇  Java编程基础 第1章  Java开发环境的搭建(教学视频:9分钟) 2 1.1  理解Java 2 1.2  搭建Java所需环境 3 1.2.1  下载JDK 3 1.2.2  安装JDK 4 1.2.3  配置环境 5 1.2.4  测试JDK配置是否成功 7 实例1  开发第一个Java程序 7 第2章  Java基础类型与运算符 实例2  自动提升 9 实例3  自动转换 10 实例4  常用基础类型之强制转换 11 2.2  运算符 12 实例5  算术运算符 12 实例6  关系运算符 13 实例7  逻辑运算符 14 实例8  位运算符 15 实例9  移位运算符 16 实例10  转型运算符 17 2.3  其他形式 18 实例11  常量与变量 18 实例12  各种进制的转换 19 实例13  Java中的进制与移位运算符 22 第3章  条件控制语句(教学视频:75分钟) 26 3.1  if控制语句 26 实例14  判断输入的年份是否为闰年 26 实例15  抽奖活动 27 3.2  for语句 28 实例16  小九九乘法表 28 实例17  如何列出素数 29 实例18  Java中的递归 31 实例19  男生女生各多少人 32 实例20  求水仙花数 34 实例21  求任意一个正数的阶乘 35 实例22  求n的n次方 35 实例23  利用for循环输出几何图形 36 实例24  杨辉三角 38 3.3  while语句 39 实例25  求1到100之间的和 39 实例26  存上100元需要多少天 40 实例27  输出100之间的所有偶数 41 实例28  如何判断回文数字 42 3.4  do…while语句 43 实例29  输出100之间的所有奇数 44 实例30  求最大的随机数 44 3.5  switch语句 45 实例31  判断字母分类 46 实例32  优良及差 47 实例33  打印任意一年日历 48 实例34  一年四季的划分 51 第2篇  Java数据处理 第4章  异常处理(教学视频:62分钟) 54 4.1  编译时异常 54 实例35  除0发生的算术异常(ArithmeticException) 54 实例36  数组下标越界异常(ArrayIndexOutOfBoundsException) 55 实例37  数组元素类型不匹配异常(ArrayStoreException) 56 实例38  强制类型转换异常(ClassCastException) 56 实例39  索引越界异常(IndexOutOfBoundsException) 57 实例40  空指针异常(NullPointerException) 58 实例41  数字格式转换异常(NumberFornatException) 59 实例42  字符串索引越界异常(StringIndexOutBounds) 60 实例43  操作错误(UnsupportedOperationException) 60 4.2  运行时异常 61 实例44  找不到指定类时发生的异常(ClassNotFoundException) 62 实例45  请求的方法不存在(NoSuchMethodException) 63 4.3  try…catch捕获异常 65 实例46  try…catch捕获异常的实例 66 实例47  try…catch…finally捕获异常的实例 67 实例48  try…catch嵌套捕获异常的实例 68 4.4  throws声明异常 69 实例49  throws声明异常实例一 69 实例50  throws声明异常实例二 70 4.5  throw抛出异常 72 实例51  throw抛出异常实例一 72 实例52  throw抛出异常实例二 73 4.6  自定义异常 74 实例53  自定义异常实例一 74 实例54  自定义异常实例二 75 第5章  数组(教学视频:98分钟) 78 5.1  一维数组 78 实例55  一维数组的创建与使用 78 实例56  按相反的顺序输出 79 实例57  奇偶分组 80 实例58  找宝 81 实例59  寻找最小数 82 实例60  我的位置在哪里 83 实例61  复制数组 85 实例62  插入新元素 86 实例63  数组的合并 87 实例64  去除重复元素 88 实例65  数组求和计算 90 实例66  求最大值、最小值和平均值 91 5.2  二维数组 92 实例67  二维数组的创建与使用 92 实例68  矩阵转置 93 实例69  奇数阶幻
一、Java 基础 1 1. JDK 和 JRE 有什么区别? 1 2. == 和 equals 的区别是什么? 1 3. 两个对象的 hashCode()相同,则 equals()也一定为 true,对吗? 3 4. final 在 java 中有什么作用? 4 5. java 中的 Math.round(-1.5) 等于多少? 4 6. String 属于基础的数据类型吗? 4 7. java 中操作字符串都有哪些类?它们之间有什么区别? 4 8. String str="i"与 String str=new String("i")一样吗? 5 9. 如何将字符串反转? 5 10. String 类的常用方法都有那些? 5 11. 抽象类必须要有抽象方法吗? 6 12. 普通类和抽象类有哪些区别? 6 13. 抽象类能使用 final 修饰吗? 6 14. 接口和抽象类有什么区别? 7 15. java 中 IO 流分为几种? 7 16. BIO、NIO、AIO 有什么区别? 7 17. Files的常用方法都有哪些? 8 二、容器 8 18. java 容器都有哪些? 8 19. Collection 和 Collections 有什么区别? 9 20. List、Set、Map 之间的区别是什么? 9 21. HashMap 和 Hashtable 有什么区别? 10 22. 如何决定使用 HashMap 还是 TreeMap? 10 23. 说一下 HashMap 的实现原理? 10 24. 说一下 HashSet 的实现原理? 11 25. ArrayList 和 LinkedList 的区别是什么? 11 26. 如何实现数组和 List 之间的转换? 11 27. ArrayList 和 Vector 的区别是什么? 11 28. Array 和 ArrayList 有何区别? 12 29. 在 Queue 中 poll()和 remove()有什么区别? 12 30. 哪些集合类是线程安全的? 12 31. 迭代器 Iterator 是什么? 12 32. Iterator 怎么使用?有什么特点? 12 33. Iterator 和 ListIterator 有什么区别? 13 三、多线程 13 35. 并行和并发有什么区别? 13 36. 线程和进程的区别? 14 37. 守护线程是什么? 14 38. 创建线程有哪几种方式? 14 39. 说一下 runnable 和 callable 有什么区别? 15 40. 线程有哪些状态? 15 41. sleep() 和 wait() 有什么区别? 16 42. notify()和 notifyAll()有什么区别? 16 43. 线程的 run()和 start()有什么区别? 16 44. 创建线程池有哪几种方式? 17 45. 线程池都有哪些状态? 18 46. 线程池中 submit()和 execute()方法有什么区别? 18 49. 什么是死锁? 19 50. 怎么防止死锁? 19 51. ThreadLocal 是什么?有哪些使用场景? 20 52.说一下 synchronized 底层实现原理? 20 53. synchronized 和 volatile 的区别是什么? 21 54. synchronized 和 Lock 有什么区别? 21 55. synchronized 和 ReentrantLock 区别是什么? 22 56. 说一下 atomic 的原理? 22 四、反射 23 57. 什么是反射? 23 58. 什么是 java 序列化?什么情况下需要序列化? 23 59. 动态代理是什么?有哪些应用? 23 60. 怎么实现动态代理? 24 五、对象拷贝 24 61. 为什么要使用克隆? 24 62. 如何实现对象克隆? 24 63. 深拷贝和浅拷贝区别是什么? 28 六、Java Web 28 64. jsp 和 servlet 有什么区别? 28 65. jsp 有哪些内置对象?作用分别是什么? 29 66. 说一下 jsp 的 4 种作用域? 29 67. session 和 cookie 有什么区别? 30 68. 说一下 session 的工作原理? 31 69. 如果客户端禁止 cookie 能实现 session 还能用吗? 31 70. spring mvc 和 struts 的区别是什么? 31 71. 如何避免 sql 注入? 33 72. 什么是 XSS 攻击,如何避免? 33 73. 什么是 CSRF 攻击,如何避免? 33 七、异常 35 74. throw 和 throws 的区别? 35 75. final、finally、finalize 有什么区别? 35 76. try-catch-finally 中哪个部分可以省略? 35 77. try-catch-finally 中,如果 catch 中 return 了,finally 还会执行吗? 36 78. 常见的异常类有哪些? 38 八、网络 39 79. http 响应码 301 和 302 代表的是什么?有什么区别? 39 80. forward 和 redirect 的区别? 39 81. 简述 tcp 和 udp的区别? 40 82. tcp 为什么要三次握手,两次不行吗?为什么? 40 84. OSI 的七层模型都有哪些? 42 85. get 和 post 请求有哪些区别? 42 86. 如何实现跨域? 43 87.说一下 JSONP 实现原理? 49 九、设计模式 49 88. 说一下你熟悉的设计模式? 49 89. 简单工厂和抽象工厂有什么区别? 49 十、Spring / Spring MVC 52 90. 为什么要使用 spring? 52 91. 解释一下什么是 aop? 53 92. 解释一下什么是 ioc? 54 93. spring 有哪些主要模块? 56 94. spring 常用的注入方式有哪些? 57 95. spring 中的 bean 是线程安全的吗? 57 96. spring 支持几种 bean 的作用域? 58 97. spring 自动装配 bean 有哪些方式? 59 98. spring 事务实现方式有哪些? 59 99. 说一下 spring 的事务隔离? 59 100. 说一下 spring mvc 运行流程? 60 101. spring mvc 有哪些组件? 61 102. @RequestMapping 的作用是什么? 62 103. @Autowired 的作用是什么? 62

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值