java面试题大合集（开发者必看）

小鱼儿 2022-01-27 00:45 239阅读 0赞

原文:[https://blog.csdn.net/sihai12345/article/details/79465620][https_blog.csdn.net_sihai12345_article_details_79465620]

版权声明：本文为本人辛苦原创文章，如果需要转载，请注明出处，谢谢!!!          https://blog.csdn.net/sihai12345/article/details/79465620        </div>
            <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-f57960eb32.css">
                              <div id="content_views" class="markdown_views">
            
            <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
              <path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path>
            </svg>
            <h3 id="前言"><a name="t0"></a>前言</h3>

本文来自百度网络的一篇文章，由于没有答案，现在整理了一些比较好的回答和好的博客，可以自己扩展思路，如果大家有一下面试题的更好的答案，欢迎在评论区留言。以上全部来自网络！此外，我的微信公众号将每日分享下面面试题相关的知识点总结干货，欢迎关注微信公众号：`好好学java`！

**文章推荐**

*  [精选java等全套学习资源][java]
 *  [精选java电子图书资源][java 1]
 *  [精选大数据学习资源][Link 1]
 *  [java项目练习精选][java 2]

### 基本概念 ###

> 1、操作系统中 heap 和 stack 的区别

堆：堆空间一般由程序员来分配，可以由垃圾回收机制来回收。一般用来存放new创建的对象和数组。  
栈：栈是“后进先出”的存储空间，一般用来存储基本类型的数据和对象的引用。

> 2、什么是基于注解的切面实现

用注解的方式实现的面向切面编程（AOP），可以在某个方法的执行前或者执行后插入一些代码（例如日志功能的代码）。

> 3、什么是 对象/关系 映射集成模块

对象/关系映射(ORM)：是指将程序中的对象自动持久化到关系型数据库中

> 4、什么是 Java 的反射机制

反射机制：是指程序可以在运行时 访问 或 修改 它本身状态和方法的这种能力。

> 5、什么是 ACID

A：atom 原子性  
C：consistency 一致性  
I：isolation 隔离性  
D：durability 持久性

> 6、BS与CS的联系与区别

C/S（Client/Server）：是指需要安装的客户端应用程序。  
B/S（Brower/Server）：是指可以用浏览器直接访问的应用程序。

> 7、Cookie 和 Session 的区别

Cookie：是把数据保存在浏览器本地，并随着每一次请求发送到服务器。  
Session：是把用户数据保存在服务器端。

> 8、fail-fast 与 fail-safe 机制有什么区别

fail-fast（快速失败）：快速失败机制在遍历一个集合时，如果集合内容被修改，会抛出ConcurrentModificationException异常。  
fail-safe（安全失败）：安全失败机制对集合的任何修改都会在一个复制的集合上进行，因此不会抛出异常。

> 9、get 和 post请求的区别

get：  
1、请求的参数会附加在URL之后，多个参数用 & 连接。  
2、因为URL的长度限制，get 方式传输的数据大小有所限制。  
3、安全性低，因为传输的数据会显示在请求的URL中。  
post：  
1、将请求参数放置在 HTTP 数据包，发送给服务器。  
2、传送的数据量比较大  
3、安全性较高

> 10、Interface 与 abstract 类的区别

1、接口（Interface）需要被实现，抽象类（abstract类）需要被继承。  
2、一个类可以实现多个接口，但一个类只能继承一个抽象类。  
3、接口里面的方法全部是抽象的，抽象类里面可以有非抽象的方法。

> 11、IoC的优点是什么

IoC（控制反转）的优点是：我们需要使用一个对象的时候无需自己创建，可以从IoC容器中直接获取一个对象，然后直接使用。

> 12、IO 和 NIO 的区别，NIO的优点

1、IO是面向流的，NIO是面向缓冲区的。  
2、IO是阻塞的，NIO是非阻塞的。  
3、NIO有选择器机制，可以让一个线程来监视多个IO通道。  
NIO的优点：  
1、不需要使用 read() 或者 write() 就可以处理文件内容。  
2、NIO的处理效率很快。

> 13、Java 8 / Java 7 为我们提供了什么新功能

**Java7 新特性:**

> 1、switch里面的case条件可以使用字符串了  
> 2、运用 List\\

### 关键字finalize ###

> 1、什么是finalize() 方法

Java 可以使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做一些必要的清理工作。

> 2、finalize()方法什么时候被调用

这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

> 3、析构函数(finalization) 的目的是什么

析构函数的目的是：在清除对象前，完成一些清理工作，比如：释放内存等。

> 4、final 和 finalize 的区别

final关键字可以用于类、方法、变量前，用来表示该类、方法、变量具有不可变的特性。

finalize方法用于回收资源，可以为任何一个类添加finalize方法。该方法将在垃圾回收器清除对象之前调用。

## 注意： ##

**关于以下java基础、io、集合、多线程、虚拟机、设计模式等的文章和源码解析，可以到我的微信公众号获取，每日分享！**

### final ###

> 1、final关键字有哪些用法

2、final 与 static 关键字可以用于哪里？它们的作用是什么

3、final, finally, finalize的区别

4、final、finalize 和 finally 的不同之处？

5、能否在运行时向 static final 类型的赋值

6、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变

7、一个类被声明为final类型，表示了什么意思

8、throws, throw, try, catch, finally分别代表什么意义

9、Java 有几种修饰符？分别用来修饰什么

### volatile ###

> 1、volatile 修饰符有过什么实践

2、volatile 变量是什么？volatile 变量和 atomic 变量有什么不同

3、volatile 类型变量提供什么保证？能使得一个非原子操作变成原子操作吗

4、能创建 volatile 数组吗？

5、transient变量有什么特点

6、super什么时候使用

7、public static void 写成 static public void会怎样

8、说明一下public static void main(String args\[\])这段声明里每个关键字的作用

9、请说出作用域public, private, protected, 以及不写时的区别

10、sizeof 是Java 的关键字吗

### static ###

> 1、static class 与 non static class的区别

2、static 关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法

3、静态类型有什么特点

4、main() 方法为什么必须是静态的？能不能声明 main() 方法为非静态

5、是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用

6、静态变量在什么时候加载？编译期还是运行期？静态代码块加载的时机呢

7、成员方法是否可以访问静态变量？为什么静态方法不能访问成员变量

### switch ###

> 1、switch 语句中的表达式可以是什么类型数据

2、switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上

3、while 循环和 do 循环有什么不同

### 操作符 ###

> 1、&操作符和&&操作符有什么区别?

2、a = a + b 与 a += b 的区别？

3、逻辑操作符 (&,|,^)与条件操作符(&&,||)的区别

4、3\*0.1 == 0.3 将会返回什么？true 还是 false？

5、loat f=3.4; 是否正确？

6、short s1 = 1; s1 = s1 + 1;有什么错?

### 数据结构 ###

## 基础类型(Primitives) ##

> 1、基础类型(Primitives)与封装类型(Wrappers)的区别在哪里

2、简述九种基本数据类型的大小，以及他们的封装类

3、int 和 Integer 哪个会占用更多的内存？ int 和 Integer 有什么区别？parseInt()函数在什么时候使用到

4、float和double的默认值是多少

5、如何去小数四舍五入保留小数点后两位

6、char 型变量中能不能存贮一个中文汉字，为什么

### 类型转换 ###

> 1、怎样将 bytes 转换为 long 类型

2、怎么将 byte 转换为 String

3、如何将数值型字符转换为数字

4、我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象

5、能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗

6、类型向下转换是什么

### 数组 ###

> 1、如何权衡是使用无序的数组还是有序的数组

2、怎么判断数组是 null 还是为空

3、怎么打印数组？ 怎样打印数组中的重复元素

4、Array 和 ArrayList有什么区别？什么时候应该使用Array而不是ArrayList

5、数组和链表数据结构描述，各自的时间复杂度

6、数组有没有length()这个方法? String有没有length()这个方法

### 队列 ###

> 1、队列和栈是什么，列出它们的区别

2、BlockingQueue是什么

3、简述 ConcurrentLinkedQueue LinkedBlockingQueue 的用处和不同之处。

4、ArrayList、Vector、LinkedList 的存储性能和特性？

5、String 和 StringBuffer 的区别？

6、ByteBuffer 与 StringBuffer 有什么区别？

### HashMap ###

> 1、HashMap的工作原理是什么

2、内部的数据结构是什么

3、HashMap 的 table的容量如何确定？loadFactor 是什么？ 该容量如何变化？这种变化会带来什么问题？

4、HashMap 实现的数据结构是什么？如何实现

5、HashMap 和 HashTable、ConcurrentHashMap 的区别

6、HashMap的遍历方式及效率

7、HashMap、LinkedMap、TreeMap的区别

8、如何决定选用HashMap还是TreeMap

9、如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办

10、HashMap 是线程安全的吗？并发下使用的 Map 是什么，它们内部原理分别是什么，比如存储方式、 hashcode、扩容、 默认容量等

### HashSet ###

> 1、HashSet和TreeSet有什么区别

2、HashSet 内部是如何工作的

3、WeakHashMap 是怎么工作的？

### Set ###

> 1、Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢？是用 == 还是 equals()？ 它们有何区别?

2、TreeMap：TreeMap 是采用什么树实现的？TreeMap、HashMap、LindedHashMap的区别。TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？

3、TreeSet：一个已经构建好的 TreeSet，怎么完成倒排序。

4、EnumSet 是什么

### Hash算法 ###

> 1、Hashcode 的作用

2、简述一致性 Hash 算法

3、有没有可能 两个不相等的对象有相同的 hashcode？当两个对象 hashcode 相同怎么办？如何获取值对象

4、为什么在重写 equals 方法的时候需要重写 hashCode 方法？equals与 hashCode 的异同点在哪里

5、a.hashCode() 有什么用？与 a.equals(b) 有什么关系

6、hashCode() 和 equals() 方法的重要性体现在什么地方

7、Object：Object有哪些公用方法？Object类hashcode,equals 设计原则？ sun为什么这么设计？Object类的概述

8、如何在父类中为子类自动完成所有的 hashcode 和 equals 实现？这么做有何优劣。

9、可以在 hashcode() 中使用随机数字吗？

### LinkedHashMap ###

> 1、LinkedHashMap 和 PriorityQueue 的区别是什么  
> List

1、List, Set, Map三个接口，存取元素时各有什么特点

2、List, Set, Map 是否继承自 Collection 接口

3、遍历一个 List 有哪些不同的方式

### LinkedList ###

> 1、LinkedList 是单向链表还是双向链表

2、LinkedList 与 ArrayList 有什么区别

3、描述下 Java 中集合（Collections），接口（Interfaces），实现（Implementations）的概念。LinkedList 与 ArrayList 的区别是什么？

4、插入数据时，ArrayList, LinkedList, Vector谁速度较快？

### ArrayList ###

> 1、ArrayList 和 HashMap 的默认大小是多数

2、ArrayList 和 LinkedList 的区别，什么时候用 ArrayList？

3、ArrayList 和 Set 的区别？

4、ArrayList, LinkedList, Vector的区别

5、ArrayList是如何实现的，ArrayList 和 LinkedList 的区别

6、ArrayList如何实现扩容

7、Array 和 ArrayList 有何区别？什么时候更适合用Array

8、说出ArraList,Vector, LinkedList的存储性能和特性

### Map ###

> 1、Map, Set, List, Queue, Stack

2、Map 接口提供了哪些不同的集合视图

3、为什么 Map 接口不继承 Collection 接口

### Collections ###

> 1、介绍Java中的Collection FrameWork。集合类框架的基本接口有哪些

2、Collections类是什么？Collection 和 Collections的区别？Collection、Map的实现

3、集合类框架的最佳实践有哪些

4、为什么 Collection 不从 Cloneable 和 Serializable 接口继承

5、说出几点 Java 中使用 Collections 的最佳实践？

6、Collections 中 遗留类 (HashTable、Vector) 和 现有类的区别

7、什么是 B+树，B-树，列出实际的使用场景

### 接口 ###

> 1、Comparator 与 Comparable 接口是干什么的？列出它们的区别

### 对象拷贝(clone) ###

> 1、如何实现对象克隆

2、深拷贝和浅拷贝区别

3、深拷贝和浅拷贝如何实现激活机制

4、写clone()方法时，通常都有一行代码，是什么

### 比较 ###

> 1、在比较对象时，”==” 运算符和 equals 运算有何区别

2、如果要重写一个对象的equals方法，还要考虑什么

3、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对

### 构造器 ###

> 1、构造器链是什么

2、创建对象时构造器的调用顺序

### 不可变对象 ###

> 1、什么是不可变象（immutable object）

2、为什么 Java 中的 String 是不可变的（Immutable）

3、如何构建不可变的类结构？关键点在哪里

4、能创建一个包含可变对象的不可变对象吗

5、如何对一组对象进行排序

### 方法 ###

> 1、构造器（constructor）是否可被重写（override）

2、方法可以同时即是 static 又是 synchronized 的吗

3、abstract 的 method是否可同时是 static，是否可同时是 native，是否可同时是synchronized

4、Java支持哪种参数传递类型

5、一个对象被当作参数传递到一个方法，是值传递还是引用传递

6、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递

7、我们能否重载main()方法

8、如果main方法被声明为private会怎样  
GC

### 概念 ###

> 1、GC是什么？为什么要有GC

2、什么时候会导致垃圾回收

3、GC是怎么样运行的

4、新老以及永久区是什么

5、GC 有几种方式？怎么配置

6、什么时候一个对象会被GC？ 如何判断一个对象是否存活

7、System.gc() Runtime.gc()会做什么事情？ 能保证 GC 执行吗

8、垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

9、Minor GC 、Major GC、Young GC 与 Full GC分别在什么时候发生

10、垃圾回收算法的实现原理

11、如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？

12、垃圾回收的最佳做法是什么

### GC收集器有哪些 ###

> 1、垃圾回收器的基本原理是什么？

2、串行(serial)收集器和吞吐量(throughput)收集器的区别是什么

3、Serial 与 Parallel GC之间的不同之处

4、CMS 收集器 与 G1 收集器的特点与区别

5、CMS垃圾回收器的工作过程

6、JVM 中一次完整的 GC 流程是怎样的？ 对象如何晋升到老年代

7、吞吐量优先和响应优先的垃圾收集器选择

### GC策略 ###

> 1、举个实际的场景，选择一个GC策略

2、JVM的永久代中会发生垃圾回收吗

### 收集方法 ###

> 1、标记清除、标记整理、复制算法的原理与特点？分别用在什么地方

2、如果让你优化收集方法，有什么思路

### JVM参数 ###

> 1、说说你知道的几种主要的jvm 参数

2、-XX:+UseCompressedOops 有什么作用

### 类加载器(ClassLoader) ###

> 1、Java 类加载器都有哪些

2、JVM如何加载字节码文件

### 内存管理 ###

> 1、JVM内存分哪几个区，每个区的作用是什么

2、一个对象从创建到销毁都是怎么在这些部分里存活和转移的

3、解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法

4、JVM中哪个参数是用来控制线程的栈堆栈小

5、简述内存分配与回收策略

6、简述重排序，内存屏障，happen-before，主内存，工作内存

7、Java中存在内存泄漏问题吗？请举例说明

8、简述 Java 中软引用（SoftReferenc）、弱引用（WeakReference）和虚引用

9、内存映射缓存区是什么

10、jstack，jstat，jmap，jconsole怎么用

11、32 位 JVM 和 64 位 JVM 的最大堆内存分别是多数？32 位和 64 位的 JVM，int 类型变量的长度是多数？

12、怎样通过 Java 程序来判断 JVM 是 32 位 还是 64 位

13、JVM自身会维护缓存吗？是不是在堆中进行对象分配，操作系统的堆还是JVM自己管理堆

14、什么情况下会发生栈内存溢出

15、双亲委派模型是什么

### 多线程基本概念 ###

> 1、什么是线程

2、多线程的优点

3、多线程的几种实现方式

4、用 Runnable 还是 Thread

5、什么是线程安全

6、Vector, SimpleDateFormat 是线程安全类吗

7、什么 Java 原型不是线程安全的

8、哪些集合类是线程安全的

9、多线程中的忙循环是什么

10、如何创建一个线程

11、编写多线程程序有几种实现方式

12、什么是线程局部变量

13、线程和进程有什么区别？进程间如何通讯，线程间如何通讯

14、什么是多线程环境下的伪共享（false sharing）

15、同步和异步有何异同，在什么情况下分别使用他们？举例说明

### Current ###

> 1、ConcurrentHashMap 和 Hashtable的区别

2、ArrayBlockingQueue, CountDownLatch的用法

3、ConcurrentHashMap的并发度是什么

4、CyclicBarrier 和 CountDownLatch有什么不同？各自的内部原理和用法是什么

5、Semaphore的用法

### Thread ###

> 1、启动一个线程是调用 run() 还是 start() 方法？start() 和 run() 方法有什么区别

2、调用start()方法时会执行run()方法，为什么不能直接调用run()方法

3、sleep() 方法和对象的 wait() 方法都可以让线程暂停执行，它们有什么区别

4、yield方法有什么作用？sleep() 方法和 yield() 方法有什么区别

5、Java 中如何停止一个线程

6、stop() 和 suspend() 方法为何不推荐使用

7、如何在两个线程间共享数据

8、如何强制启动一个线程

9、如何让正在运行的线程暂停一段时间

10、什么是线程组，为什么在Java中不推荐使用

11、你是如何调用 wait（方法的）？使用 if 块还是循环？为什么

### 生命周期 ###

> 1、有哪些不同的线程生命周期

2、线程状态，BLOCKED 和 WAITING 有什么区别

3、画一个线程的生命周期状态图

4、ThreadLocal 用途是什么，原理是什么，用的时候要注意什么

### ThreadPool ###

> 1、线程池是什么？为什么要使用它

2、如何创建一个Java线程池

3、ThreadPool用法与优势

4、提交任务时，线程池队列已满时会发会生什么

5、newCache 和 newFixed 有什么区别？简述原理。构造函数的各个参数的含义是什么，比如 coreSize, maxsize 等

6、线程池的实现策略

7、线程池的关闭方式有几种，各自的区别是什么

8、线程池中submit() 和 execute()方法有什么区别？

### 线程调度 ###

> 1、Java中用到的线程调度算法是什么

2、什么是多线程中的上下文切换

3、你对线程优先级的理解是什么

4、什么是线程调度器 (Thread Scheduler) 和时间分片 (Time Slicing)

### 线程同步 ###

> 1、请说出你所知的线程同步的方法

2、synchronized 的原理是什么

3、synchronized 和 ReentrantLock 有什么不同

4、什么场景下可以使用 volatile 替换 synchronized

5、有T1，T2，T3三个线程，怎么确保它们按顺序执行？怎样保证T2在T1执行完后执行，T3在T2执行完后执行

6、同步块内的线程抛出异常会发生什么

7、当一个线程进入一个对象的 synchronized 方法A 之后，其它线程是否可进入此对象的 synchronized 方法B

8、使用 synchronized 修饰静态方法和非静态方法有什么区别

9、如何从给定集合那里创建一个 synchronized 的集合

### 锁 ###

> 1、Java Concurrency API 中 的 Lock 接口是什么？对比同步它有什么优势

2、Lock 与 Synchronized 的区别？Lock 接口比 synchronized 块的优势是什么

3、ReadWriteLock是什么？

4、锁机制有什么用

5、什么是乐观锁（Optimistic Locking）？如何实现乐观锁？如何避免ABA问题

6、解释以下名词：重排序，自旋锁，偏向锁，轻量级锁，可重入锁，公平锁，非公平锁，乐观锁，悲观锁

7、什么时候应该使用可重入锁

8、简述锁的等级方法锁、对象锁、类锁

9、Java中活锁和死锁有什么区别？

10、什么是死锁(Deadlock)？导致线程死锁的原因？如何确保 N 个线程可以访问 N 个资源同时又不导致死锁

11、死锁与活锁的区别，死锁与饥饿的区别

12、怎么检测一个线程是否拥有锁

13、如何实现分布式锁

14、有哪些无锁数据结构，他们实现的原理是什么

15、读写锁可以用于什么应用场景

16、Executors类是什么？ Executor和Executors的区别

17、什么是Java线程转储(Thread Dump)，如何得到它

18、如何在Java中获取线程堆栈

19、说出 3 条在 Java 中使用线程的最佳实践

20、在线程中你怎么处理不可捕捉异常

21、实际项目中使用多线程举例。你在多线程环境中遇到的常见的问题是什么？你是怎么解决它的

22、请说出与线程同步以及线程调度相关的方法

23、程序中有3个 socket，需要多少个线程来处理

24、假如有一个第三方接口，有很多个线程去调用获取数据，现在规定每秒钟最多有 10 个线程同时调用它，如何做到

25、如何在 Windows 和 Linux 上查找哪个线程使用的 CPU 时间最长

26、如何确保 main() 方法所在的线程是 Java 程序最后结束的线程

27、非常多个线程（可能是不同机器），相互之间需要等待协调才能完成某种工作，问怎么设计这种协调方案

28、你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它

### 异常 ###

## 基本概念 ##

> 1、Error 和 Exception有什么区别

2、UnsupportedOperationException是什么

3、NullPointerException 和 ArrayIndexOutOfBoundException 之间有什么相同之处

4、什么是受检查的异常，什么是运行时异常

5、运行时异常与一般异常有何异同

6、简述一个你最常见到的runtime exception(运行时异常)

## finally ##

> 1、finally关键词在异常处理中如何使用

2、如果执行finally代码块之前方法返回了结果，或者JVM退出了，finally块中的代码还会执行吗

3、try里有return，finally还执行么？那么紧跟在这个try后的finally \{\}里的code会不会被执行，什么时候被执行，在return前还是后

4、在什么情况下，finally语句不会执行

5、throw 和 throws 有什么区别？

6、OOM你遇到过哪些情况？你是怎么搞定的？

7、SOF你遇到过哪些情况？

8、既然我们可以用RuntimeException来处理错误，那么你认为为什么Java中还存在检查型异常

9、当自己创建异常类的时候应该注意什么

10、导致空指针异常的原因

11、异常处理 handle or declare 原则应该如何理解

12、怎么利用 JUnit 来测试一个方法的异常

13、catch块里别不写代码有什么问题

14、你曾经自定义实现过异常吗？怎么写的

15、什么是 异常链

16、在try块中可以抛出异常吗

### JDBC ###

> 1、通过 JDBC 连接数据库有哪几种方式

2、阐述 JDBC 操作数据库的基本步骤

3、JDBC 中如何进行事务处理

4、什么是 JdbcTemplate

5、什么是 DAO 模块

6、使用 JDBC 操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能

7、列出 5 个应该遵循的 JDBC 最佳实践

### IO ###

## File ##

> 1、File类型中定义了什么方法来创建一级目录

2、File类型中定义了什么方法来判断一个文件是否存在

## 流 ##

> 1、为了提高读写性能，可以采用什么流

2、Java中有几种类型的流

3、JDK 为每种类型的流提供了一些抽象类以供继承，分别是哪些类

4、对文本文件操作用什么I/O流

5、对各种基本数据类型和String类型的读写，采用什么流

6、能指定字符编码的 I/O 流类型是什么

## 序列化 ##

> 1、什么是序列化？如何实现 Java 序列化及注意事项

2、Serializable 与 Externalizable 的区别

### Socket ###

> 1、socket 选项 TCP NO DELAY 是指什么

2、Socket 工作在 TCP/IP 协议栈是哪一层

3、TCP、UDP 区别及 Java 实现方式

4、说几点 IO 的最佳实践

5、直接缓冲区与非直接缓冲器有什么区别？

6、怎么读写 ByteBuffer？ByteBuffer 中的字节序是什么

7、当用System.in.read(buffer)从键盘输入一行n个字符后，存储在缓冲区buffer中的字节数是多少

8、如何使用扫描器类（Scanner Class）令牌化

### 面向对象编程（OOP） ###

> 1、解释下多态性（polymorphism），封装性（encapsulation），内聚（cohesion）以及耦合（coupling）

2、多态的实现原理

3、封装、继承和多态是什么

4、对象封装的原则是什么?

### 类 ###

> 1、获得一个类的类对象有哪些方式

2、重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

3、说出几条 Java 中方法重载的最佳实践

## 抽象类 ##

> 1、抽象类和接口的区别

2、抽象类中是否可以有静态的main方法

3、抽象类是否可实现(implements)接口

4、抽象类是否可继承具体类(concrete class)

## 匿名类（Anonymous Inner Class） ##

> 1、匿名内部类是否可以继承其它类？是否可以实现接口

## 内部类 ##

> 1、内部类分为几种

2、内部类可以引用它的包含类（外部类）的成员吗

3、请说一下 Java 中为什么要引入内部类？还有匿名内部类

### 继承 ###

> 1、继承（Inheritance）与聚合（Aggregation）的区别在哪里

2、继承和组合之间有什么不同

3、为什么类只能单继承，接口可以多继承

4、存在两个类，B 继承 A，C 继承 B，能将 B 转换为 C 么？如 C = (C) B

5、如果类 a 继承类 b，实现接口c，而类 b 和接口 c 中定义了同名变量，请问会出现什么问题

### 接口 ###

> 1、接口是什么

2、接口是否可继承接口

3、为什么要使用接口而不是直接使用具体类？接口有什么优点

### 泛型 ###

> 1、泛型的存在是用来解决什么问题

2、泛型的常用特点

3、List能否转为List

### 工具类 ###

## 日历 ##

> 1、Calendar Class的用途

2、如何在Java中获取日历类的实例

3、解释一些日历类中的重要方法

4、GregorianCalendar 类是什么

5、SimpleTimeZone 类是什么

6、Locale类是什么

7、如何格式化日期对象

8、如何添加小时(hour)到一个日期对象(Date Objects)

9、如何将字符串 YYYYMMDD 转换为日期

## Math ##

> 1、Math.round()什么作用？Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？

## XML ##

> 1、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？DOM 和 SAX 解析器有什么不同？

2、Java解析XML的方式

3、用 jdom 解析 xml 文件时如何解决中文问题？如何解析

4、你在项目中用到了 XML 技术的哪些方面？如何实现

### 动态代理 ###

> 1、描述动态代理的几种实现方式，分别说出相应的优缺点

### 设计模式 ###

> 1、什么是设计模式（Design Patterns）？你用过哪种设计模式？用在什么场合

2、你知道哪些商业级设计模式？

3、哪些设计模式可以增加系统的可扩展性

## 单例模式 ##

> 1、除了单例模式，你在生产环境中还用过什么设计模式？

2、写 Singleton 单例模式

3、单例模式的双检锁是什么

4、如何创建线程安全的 Singleton

5、什么是类的单例模式

6、写出三种单例模式实现

## 适配器模式 ##

> 1、适配器模式是什么？什么时候使用

2、适配器模式和代理模式之前有什么不同

3、适配器模式和装饰器模式有什么区别

4、什么时候使用享元模式

5、什么时候使用组合模式

6、什么时候使用访问者模式

7、什么是模板方法模式

8、请给出1个符合开闭原则的设计模式的例子

## 注意： ##

**关于以上java基础、io、集合、多线程、虚拟机、设计模式等的文章和源码解析，可以到我的微信公众号获取，每日分享！**

### 开放问题（看你的了） ###

> 1、用一句话概括 Web 编程的特点

2、Google是如何在一秒内把搜索结果返回给用户

3、哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入

4、树（二叉或其他）形成许多普通数据结构的基础。请描述一些这样的数据结构以及何时可以使用它们

5、某一项功能如何设计

6、线上系统突然变得异常缓慢，你如何查找问题

7、什么样的项目不适合用框架

8、新浪微博是如何实现把微博推给订阅者

9、简要介绍下从浏览器输入 URL 开始到获取到请求界面之后 Java Web 应用中发生了什么

10、请你谈谈SSH整合

11、高并发下，如何做到安全的修改同一行数据

12、12306网站的订票系统如何实现，如何保证不会票不被超卖

13、网站性能优化如何优化的

14、聊了下曾经参与设计的服务器架构

15、请思考一个方案，实现分布式环境下的 countDownLatch

16、请思考一个方案，设计一个可以控制缓存总体大小的自动适应的本地缓存

17、在你的职业生涯中，算得上最困难的技术挑战是什么

18、如何写一篇设计文档，目录是什么

19、大写的O是什么？举几个例子

20、编程中自己都怎么考虑一些设计原则的，比如开闭原则，以及在工作中的应用

21、解释一下网络应用的模式及其特点

22、设计一个在线文档系统，文档可以被编辑，如何防止多人同时对同一份文档进行编辑更新

23、说出数据连接池的工作机制是什么

24、怎么获取一个文件中单词出现的最高频率

25、描述一下你最常用的编程风格

26、如果有机会重新设计你们的产品，你会怎么做

27、如何搭建一个高可用系统

28、如何启动时不需输入用户名与密码

29、如何在基于Java的Web项目中实现文件上传和下载

30、如何实现一个秒杀系统，保证只有几位用户能买到某件商品。

31、如何实现负载均衡，有哪些算法可以实现

32、如何设计一个购物车？想想淘宝的购物车如何实现的

33、如何设计一套高并发支付方案，架构如何设计

34、如何设计建立和保持 100w 的长连接

35、如何避免浏览器缓存。

36、如何防止缓存雪崩

37、如果AB两个系统互相依赖，如何解除依

38、如果有人恶意创建非法连接，怎么解决

39、如果有几十亿的白名单，每天白天需要高并发查询，晚上需要更新一次，如何设计这个功能

40、如果系统要使用超大整数（超过long长度范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数加法运算）

41、如果要设计一个图形系统，请你设计基本的图形元件(Point,Line,Rectangle,Triangle)的简单实现

42、如果让你实现一个并发安全的链表，你会怎么做

43、应用服务器与WEB 服务器的区别？应用服务器怎么监控性能，各种方式的区别？你使用过的应用服务器优化技术有哪些

44、大型网站在架构上应当考虑哪些问题

45、有没有处理过线上问题？出现内存泄露，CPU利用率标高，应用无响应时如何处理的

46、最近看什么书，印象最深刻的是什么

47、描述下常用的重构技巧

48、你使用什么版本管理工具？分支（Branch）与标签（Tag）之间的区别在哪里

49、你有了解过存在哪些反模式（Anti-Patterns）吗

50、你用过的网站前端优化的技术有哪些

51、如何分析Thread dump

52、你如何理解AOP中的连接点（Joinpoint）、切点（Pointcut）、增强（Advice）、引介（Introduction）、织入（Weaving）、切面（Aspect）这些概念

53、你是如何处理内存泄露或者栈溢出问题的

54、你们线上应用的 JVM 参数有哪些

55、怎么提升系统的QPS和吞吐量

### 知识面 ###

> 1、解释什么是 MESI 协议(缓存一致性)

参考：[http://blog.csdn.net/zxp\_cpinfo/article/details/53523697][http_blog.csdn.net_zxp_cpinfo_article_details_53523697]

> 2、谈谈 reactor 模型

参考：[https://www.jianshu.com/p/2461535c38f3][https_www.jianshu.com_p_2461535c38f3]

> 3、Java 9 带来了怎样的新功能

参考：[http://blog.csdn.net/u013322876/article/details/76610029][http_blog.csdn.net_u013322876_article_details_76610029]

> 4、Java 与 C++ 对比，C++ 或 Java 中的异常处理机制的简单原理和应用

参考：[http://blog.sina.com.cn/s/blog\_c065adec0101eu98.html][http_blog.sina.com.cn_s_blog_c065adec0101eu98.html]

> 5、简单讲讲 Tomcat 结构，以及其类加载器流程

参考：[http://blog.csdn.net/lai1365266/article/details/45271985][http_blog.csdn.net_lai1365266_article_details_45271985]

> 6、虚拟内存是什么

参考：[http://blog.csdn.net/guoweimelon/article/details/50849710][http_blog.csdn.net_guoweimelon_article_details_50849710]

> 7、阐述下 SOLID 原则

参考：[https://www.cnblogs.com/OceanEyes/p/overview-of-solid-principles.html][https_www.cnblogs.com_OceanEyes_p_overview-of-solid-principles.html]

> 8、请简要讲一下你对测试驱动开发（TDD）的认识

参考：[https://www.cnblogs.com/OlderBird/p/4322925.html][https_www.cnblogs.com_OlderBird_p_4322925.html]

> 9、CDN实现原理

参考：[https://www.cnblogs.com/losbyday/p/5843960.html][https_www.cnblogs.com_losbyday_p_5843960.html]

> 10、Maven 和 ANT 有什么区别

参考：[http://blog.csdn.net/yangkai\_hudong/article/details/12554983][http_blog.csdn.net_yangkai_hudong_article_details_12554983]

> 11、UML中有哪些常用的图

参考：[http://blog.csdn.net/suxinpingtao51/article/details/8011335][http_blog.csdn.net_suxinpingtao51_article_details_8011335]

### Linux ###

> 1、Linux 下 IO 模型有几种，各自的含义是什么。

参考：[http://www.jb51.net/article/94783.htm][http_www.jb51.net_article_94783.htm]

> 2、Linux 系统下你关注过哪些内核参数，说说你知道的

参考：[http://www.jb51.net/LINUXjishu/335549.html][http_www.jb51.net_LINUXjishu_335549.html]

> 3、Linux 下用一行命令查看文件的最后五行

cat filename | tail -n +3000 | head -n 1000
     
      
     
      
       1

> 4、平时用到哪些 Linux 命令

参考：[https://www.cnblogs.com/bugutian/p/4528650.html][https_www.cnblogs.com_bugutian_p_4528650.html]

> 5、用一行命令输出正在运行的 Java 进程

参考：[https://www.cnblogs.com/bugutian/p/4528650.html][https_www.cnblogs.com_bugutian_p_4528650.html]

> 6、使用什么命令来确定是否有 Tomcat 实例运行在机器上

7、什么是 N+1 难题

参考：[https://www.cnblogs.com/yzlpersonal/p/5077392.html][https_www.cnblogs.com_yzlpersonal_p_5077392.html]

> 8、什么是 paxos 算法

参考：[http://blog.csdn.net/21aspnet/article/details/50700123][http_blog.csdn.net_21aspnet_article_details_50700123]

9、什么是 restful，讲讲你理解的 restful

参考：[http://www.ruanyifeng.com/blog/2011/09/restful.html][http_www.ruanyifeng.com_blog_2011_09_restful.html]

> 10、什么是 zab 协议

参考：[https://www.cnblogs.com/jian-xiao/p/5821675.html][https_www.cnblogs.com_jian-xiao_p_5821675.html]

> 11、什么是领域模型(domain model)？贫血模型(anaemic domain model) 和充血模型(rich domain model)有什么区别

参考：[https://www.cnblogs.com/feng9exe/p/5611992.html][https_www.cnblogs.com_feng9exe_p_5611992.html]

> 12、什么是领域驱动开发（Domain Driven Development）

参考：[http://blog.csdn.net/johnstrive/article/details/16805121][http_blog.csdn.net_johnstrive_article_details_16805121]

> 13、介绍一下了解的 Java 领域的 Web Service 框架

参考：[http://blog.csdn.net/apicescn/article/details/42965785/][http_blog.csdn.net_apicescn_article_details_42965785]

> 14、Web Server、Web Container 与 Application Server 的区别是什么

参考：[https://www.cnblogs.com/vipyoumay/p/5853694.html][https_www.cnblogs.com_vipyoumay_p_5853694.html]

> 15、微服务（MicroServices）与巨石型应用（Monolithic Applications）之间的区别在哪里

16、描述 Cookie 和 Session 的作用，区别和各自的应用范围，Session工作原理

参考：[http://blog.csdn.net/yanghaitao\_1990/article/details/51723066][http_blog.csdn.net_yanghaitao_1990_article_details_51723066]

> 17、你常用的持续集成（Continuous Integration）、静态代码分析（Static Code Analysis）工具有哪些

18、简述下数据库正则化（Normalizations）

19、KISS,DRY,YAGNI 等原则是什么含义

参考：[http://blog.csdn.net/zj\_show/article/details/8078447][http_blog.csdn.net_zj_show_article_details_8078447]

> 20、分布式事务的原理，优缺点，如何使用分布式事务？

参考：[http://blog.csdn.net/a291382932/article/details/52567094][http_blog.csdn.net_a291382932_article_details_52567094]

> 21、布式集群下如何做到唯一序列号

参考：[https://www.cnblogs.com/yelongsan/p/6306418.html][https_www.cnblogs.com_yelongsan_p_6306418.html]

### 网络 ###

> 1、HTTPS 的加密方式是什么，讲讲整个加密解密流程

参考：[http://blog.csdn.net/shw372029857/article/details/52687906][http_blog.csdn.net_shw372029857_article_details_52687906]

> 2、HTTPS和HTTP的区别

参考：[https://www.cnblogs.com/wqhwe/p/5407468.html][https_www.cnblogs.com_wqhwe_p_5407468.html]

> 3、HTTP连接池实现原理

参考：[https://www.cnblogs.com/likaitai/p/5431246.html][https_www.cnblogs.com_likaitai_p_5431246.html]

> 4、HTTP集群方案

参考：[http://aokunsang.iteye.com/blog/2053719][http_aokunsang.iteye.com_blog_2053719]

> 5、Nginx、lighttpd、Apache三大主流 Web服务器的区别

参考：[http://blog.csdn.net/u013404872/article/details/70799420][http_blog.csdn.net_u013404872_article_details_70799420]

> 6、是否看过框架的一些代码

7、持久层设计要考虑的问题有哪些？你用过的持久层框架有哪些

所谓”持久”就是将数据保存到可掉电式存储设备中以便今后使用，简单的说，就是将内存中的数据保存到关系型数据库、文件系统、消息队列等提供持久化支持的设备中。持久层就是系统中专注于实现数据持久化的相对独立的层面。

持久层设计的目标包括：  
\- 数据存储逻辑的分离，提供抽象化的数据访问接口。  
\- 数据访问底层实现的分离，可以在不修改代码的情况下切换底层实现。  
\- 资源管理和调度的分离，在数据访问层实现统一的资源调度（如缓存机制）。  
\- 数据抽象，提供更面向对象的数据操作。

持久层框架有：  
\- Hibernate  
\- MyBatis  
\- TopLink  
\- Guzz  
\- jOOQ  
\- Spring Data  
\- ActiveJDBC

> 8、数值提升是什么

参考：[http://blog.csdn.net/yangcheng33/article/details/76408580][http_blog.csdn.net_yangcheng33_article_details_76408580]

> 9、你能解释一下里氏替换原则吗

参考：[http://blog.csdn.net/xingyunlost/article/details/53169283][http_blog.csdn.net_xingyunlost_article_details_53169283]

> 10、你是如何测试一个应用的？知道哪些测试框架

参考：[https://www.cnblogs.com/fnng/p/3653793.html][https_www.cnblogs.com_fnng_p_3653793.html]

> 11、传输层常见编程协议有哪些？并说出各自的特点

传输层位于OSI七层网络模型中的第四层，协议有TCP · UDP · TLS · DCCP · SCTP ·RSVP · PPTP。OSI（Open System Interconnection，开放系统互连）七层网络模型称为开放式系统互联参考模型 ，是一个逻辑上的定义，一个规范，它把网络从逻辑上分为了7层。每一层都有相关、相对应的物理设备，比如路由器，交换机。建立七层模型的主要目的是为解决异种网络互连时所遇到的兼容性问题，其最主要的功能就是帮助不同类型的主机实现数据传输。它的最大优点是将服务、接口和协议这三个概念明确地区分开来，通过七个层次化的结构模型使不同的系统不同的网络之间实现可靠的通讯。

### 编程题 ###

## 计算加班费 ##

加班10小时以下加班费是时薪的1.5倍。加班10小时或以上，按4元/时算。提示：（一个月工作26天，一天正常工作8小时）

> 1、计算1000月薪，加班9小时的加班费

2、计算2500月薪，加班11小时的加班费

3、计算1000月薪，加班15小时的加班费

## 卖东西 ##

一家商场有红苹果和青苹果出售。（红苹果5元/个，青苹果4元/个）。

> 1、模拟一个进货。红苹果跟青苹果各进200个。

2、模拟一个出售。红苹果跟青苹果各买出10个。每卖出一个苹果需要进行统计。

提示：一个苹果是一个单独的实体。

## 日期提取 ##

有这样一个时间字符串：2008-8-8 20:08:08 ， 请编写能够匹配它的正则表达式，并编写Java代码将日期后面的时分秒提取出来，即：20:08:08  
线程

> 1、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

2、用Java写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出

3、wait-notify 写一段代码来解决生产者-消费者问题

## 数字 ##

> 1、判断101-200之间有多少个素数，并输出所有素数

package C;
    
    public class Sushu {
    
        public static void main(String[] args) {
            int sum=0;
            for (int i = 101; i < 201; i++) 
            {
                for (int j = 2; j <=i; j++)
                {
                    if(j==i)
                    {
                        System.out.println(j);
                    }
                    else if(i%j==0)
                    {
                        sum++;
                        break;
                    }
    
                }
    
            }
            System.out.println("总共有"+(100-sum)+"个素数");
    
        }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28

> 2、用最有效率的方法算出2乘以17等于多少

17>>1
     
      
     
      
       1

> 3、有 1 亿个数字，其中有 2 个是重复的，快速找到它，时间和空间要最优

4、2 亿个随机生成的无序整数,找出中间大小的值

public class Test2
    {
    
    public static void main(String [] srgs)
    {
    int i=(int)(Math.random()*900)+100;
    //int i= new java.util.Random().nextInt(900)+100;也可以
    System.out.println(i);
    
    }
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

> 5、10 亿个数字里里面找最小的 10 个

package com.yuzhiyun;
    
    import java.util.Arrays;
    
    /** * 求一亿个数里面最小的10个数 * 首先建立节点个数为10的最大堆，然后考虑每一个新的值，让他和堆顶比较，比堆顶大的元素直接抛弃，如果比堆顶小的数字，让他替换堆顶，然后调整堆。 */
    public class MaxTenNumber { 
        public static void main(String[] args) {
            /**第一个元素0不参与，只是用于占位置,这样的话，只要array[k]>array[2k] && array[k]>array[2k+1]那就是最大堆了， * 此外，这里暂时用20个数代替1亿个 */
            int[] array={
       0,1,2,3,4,7,8,9,10,11,12,13,14,15,16,17,18,19,20,6,5};
            //建立建立节点个数为10的最大堆
            for(int i=10/2;i>=1;i--){
                adjustHeap(array, i, 10);
            }
            //System.out.println(Arrays.toString(array));
            for(int i=11;i<array.length;i++){
                //如果这个元素小于堆顶，和堆顶交换，然后重新调整堆
                if(array[i]<array[1]){
                    swap(array, i, 1);
                    adjustHeap(array, 1, 10);
                }
    
            }
            System.out.println(Arrays.toString(array));
            System.out.println("最小的10个数字为：");
            for(int i=1;i<=10;i++){
                System.out.print(array[i]+" ");
            }
        }
    
        /** * 交换 * @param array * @param i * @param j */
        private static void swap(int[] array, int i, int j) {
            int tem=array[i];
            array[i]=array[j];
            array[j]=tem;
        }
    
        /** * 在以array[head]为根的左右子树是最大堆的前提下把以array[head]为根的树调整为最大堆 * @param array * @param head * @param tail */
        static void adjustHeap(int[] array,int head,int tail){
            int root=array[head];
            int i=2*head;
            while(i<=tail){
                int max=array[i];
                if(i+1<=tail)
                    if(array[i+1]>array[i]){
                        max=array[i+1];
                        i++;
                    }
                if(root>max)
                    //别手抖写成了return;
                    break;
                else{
                    array[i/2]=array[i];        
                }
                i*=2;
            }
            array[i/2]=root;
        }
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73

> 6、1到1亿的自然数，求所有数的拆分后的数字之和，如286 拆分成2、8、6，如1到11拆分后的数字之和 => 1 + … + 9 + 1 + 0 + 1 + 1

7、一个数如果恰好等于它的因子之和，这个数就称为 “完数“。例如6=1＋2＋3.编程 找出1000以内的所有完数

package a;
    
    public class Wanshu {
    
        public static void main(String[] args) {
    
            for (int i = 1; i <= 1000; i++)
            {
                int sum=0;
                for (int j = 1; j < i; j++)
                {
                if(i%j==0)
                {
                    sum+=j;
                }
    
                }
                if(i==sum)
                {
                    System.out.println(i);
                }
            }
    
        }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26

> 8、一个数组中所有的元素都出现了三次，只有一个元素出现了一次找到这个元素

int singleNumber(int A[], int n) {  
            int result=0;  
            for(int i=0;i<32;i++){  
                int bit=0;  
                for(int j=0;j<n;j++){  
                    bit+=(A[j]>>i)&1;  
                }  
                result |= (bit%3)<<i;  
            }  
            return result;  
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

> 9、一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？

package lianxi;
    
    public class Qiu {
    
        public static void main(String[] args) {
            double sum1 = 0, sum2 = 0, hight = 100.0;
    
            for (int i = 0; i < 10; i++)
            {
                sum1 = sum1 + hight;
                // 显示了一下高度的变化
                // System.out.print(hight);
                hight = hight / 2;
                // System.out.print(" "+hight);
                //System.out.println();
                if (i < 9)
    
                {
                    sum2 = sum2 + hight;
                }
            }
            System.out.println("第10次落地时，共经过" + (sum1 + sum2) + "米");
            System.out.println("第十次反弹高度为" + hight + "米");
    
        }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27

> 10、求100－1000内质数的和

public class TestZhiShu { 
    
    public static void main(String[] args) {
    
        /** * 求100-1000之内的质数的数量 */
        int count=0;
         for (int i = 102; i <= 1000; i++) { // 质数
                for (int k = 2; k <= i; k++) { // 除数
                    // 排除所有在 i=k 之前 能被k整除(余数为0)的数
                    if (i % k == 0 && i != k) {
                        break;
                    }
                    // 输出所有在 i=k 且 i%k=0的数
                    if (i % k == 0 && i == k) {
                        //System.out.println(i);
                        count++;
                    }
                }
            }
         System.out.println(count);
        }
        }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24

> 11、求1到100的和的平均数

12、求s=a+a+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。 求出1到100的和

package com.liron.p1;
    
    import java.io.IOException;
    import java.util.Scanner;
    
    /** * 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。 * 例如2+22+222+2222+22222(此时共有5个数相加)，几个数相 * 加有键盘控制。 */
    public class Topic18 { 
        public static void main(String[] args) throws IOException  
        {  
            Scanner sc = new Scanner(System.in);
            System.out.println("用哪个数循环？：");
            int _temp = sc.nextInt();  
            System.out.println("循环相加多少次？：");
            int temp = sc.nextInt();
    
            int newNumber = 0; // 每次生成的新数 
            int total = 0; // 计算结果 
            for (int i = 0; i < temp; i++)  
            {  
                newNumber = newNumber * 10 + _temp;  
                System.out.println(newNumber);  
                total = total + newNumber;  
            }  
            System.out.println("计算结果:" + total);  
        }
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30

> 13、算出1到40的质数，放进数组里

① 显示放组里的数

② 找出第\[5\]个数

③ 删除第\[9\]个数，再显示删除后的第\[9\]个

> 14、有 3n+1 个数字，其中 3n 个中是重复的，只有 1 个是不重复的，怎么找出来。

15、有一组数1.1.2.3.5.8.13.21.34。写出程序随便输入一个数就能给出和前一组数字同规律的头5个数

16、计算指定数字的阶乘

public class CalculatingFactorial {
        public static void main(String args[]) {
            for (int counter = 0; counter <= 10; counter++) {
                System.out.printf("%d! = %d\n", counter, factorial(counter));
            }
        }
    
        public static long factorial(long number) {
            if (number <= 1)
                return 1;
            else
                return number * factorial(number - 1);
        }
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14

> 17、开发 Fizz Buzz

参考：[https://www.cnblogs.com/webary/p/6507413.html][https_www.cnblogs.com_webary_p_6507413.html]

> 18、给定一个包含 N 个整数的数组，找出丢失的整数

import java.util.*;  
    
        public class Finder {  
            public int findMissing(int[][] numbers, int n) {  
                // write code here 
                int i = 0;  
                for(i=0; i<n; ++i){  
                    if(i%2!=numbers[i][0]){  
                        break;  
                    }  
                }  
                return i;  
            }  
    
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15

> 19、一个排好序的数组，找出两数之和为m的所有组合

public static void main(String[] args) throws UnsupportedEncodingException {  
                int[] ints = { 1, 3, 10, 12 , 13, 18, 22 ,58 };  
                int find = 23;  
    
                int start = 0;  
                int end = ints.length - 1;  
    
                while (ints[start] >= find) { System.out.println("都比他-------------------------------大哦!");  
                    return;  
                }  
    
    
                while (end > start) { if (ints[start] + ints[end] == find) { System.out.println(ints[start] + " + " + ints[end] + " = " + find);  
                        end--;  
                        start++;  
    
                    } else if (ints[start] + ints[end] < find) { start++;  
                    } else if (ints[start] + ints[end] > find) { end--;  
                    }  
                    System.out.println(start +" "+end);  
                }  
    
            }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29

> 20、将一个正整数分解质因数。例如：输入90,打印出90=2\*3\*3\*5。

//【程序4】FenJie.java 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。 程序分析：对n进行分解质因数， 
        //应先找到一个最小的质数k，然后按下述步骤完成： (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。 
        //(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。 
        //(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。 
        //任何一个正整数都可以分解为其由多个质数相乘。。 
        import java.io.*;  
        import java.util.*;  
        public class FenJieApp {   
    
            /** * @param args */  
            public static void main(String[] args) {  
                // TODO Auto-generated method stub 
    
    
                  System.out.println("请输入数字：");  
                  Scanner scanner = new Scanner(System.in);  
                  int parm=scanner.nextInt();  
    
                  System.out.print(parm+"=");  
    
                  for(int i=2;i<=parm;i++)  
                  {  
                    while(parm!=i)  
                      {  
                          if(parm%i==0)  
                        {   
                            System.out.print(i+"*");  
                            parm=parm/i;  
                        }  
                         else  
                            break;  
                    }  
                  }  
                  System.out.print(parm);  
            }  
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38

> 21、打印出所有的 “水仙花数 “，所谓 “水仙花数 “是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 “水仙花数 “，因为153=1的三次方＋5的三次方＋3的三次方

package com.hanqi;
    
    public class Text4 {
    
        public static void main(String[] args) {
    
            for (int num=100;num<1000;num++)
            {
                int gw=num%10;
                int sw=num/10%10;
                int bw=num/100%10;
                if (gw*gw*gw+sw*sw*sw+bw*bw*bw==num)
                {
                    System.out.println(num);
                }
            }
        }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19

> 22、原地交换两个变量的值

参考：[https://www.cnblogs.com/Brad-Lee/p/5808299.html][https_www.cnblogs.com_Brad-Lee_p_5808299.html]

> 23、找出4字节整数的中位数

参考：[http://blog.csdn.net/randyjiawenjie/article/details/6968591][http_blog.csdn.net_randyjiawenjie_article_details_6968591]

> 24、找到整数的平方根

参考：[https://www.cnblogs.com/Matrix\_Yao/archive/2009/07/28/1532883.html][https_www.cnblogs.com_Matrix_Yao_archive_2009_07_28_1532883.html]

> 25、实现斐波那契

参考：[http://blog.csdn.net/duhacker/article/details/48295807][http_blog.csdn.net_duhacker_article_details_48295807]

### 网络 ###

> 1、用Java Socket编程，读服务器几个字符，再写入本地显示

### 反射 ###

> 1、反射机制提供了什么功能？

得到该对象所属的类：  
Class ownerClass = owner.getClass()  
在运行时构造一个类的对象：  
Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。cons.newInstance(args)：新建实例。  
在运行时判断一个类所具有的成员变量和方法：  
Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。  
在运行时调用一个对象的方法：  
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

> 2、反射是如何实现的

所谓反射，是指在运行时状态中，获取类中的属性和方法，以及调用其中的方法的一种机制。这种机制的作用在于获取运行时才知道的类（Class）及其中的属性（Field）、方法（Method）以及调用其中的方法，也可以设置其中的属性值。  
在Java中实现反射最重要的一步，也是第一步就是获取Class对象，得到Class对象后可以通过该对象调用相应的方法来获取该类中的属性、方法以及调用该类中的方法。  
Java中反射有如下几种实现方式：  
1、通过Class.forName()方法加载字符串，就可以得到该字符串做代表的Class对象。  
例如：Class

### 数据库 ###

> 1、写一段 JDBC 连Oracle的程序,并实现数据查询

package svn;  
    
        import java.sql.Connection;  
        import java.sql.DriverManager;  
        import java.sql.PreparedStatement;  
        import java.sql.ResultSet;  
    
    
        public class Main {   
            public static void main(String[] args) throws Exception {  
    
                // 1、加载驱动 
                Class.forName("com.mysql.jdbc.Driver");  
    
                // 2、创建数据库连接对象 
                Connection conn = null;  
    
                conn = DriverManager  
                        .getConnection(  
                                "jdbc:mysql://localhost:3306/db?useUnicode=true&characterEncoding=UTF-8",  
                                "root", "123456");  
    
                // 3、创建数据库命令执行对象 
    
                PreparedStatement psPreparedStatement = conn  
                        .prepareStatement("select * from t_user");  
                // Statement stmtStatement=conn.createStatement(); 
    
                // 4、执行数据库命令 
                ResultSet rSet = psPreparedStatement.executeQuery();  
                //ResultSet rs=stmtStatement.executeQuery("select * from t_user"); 
                //5、处理执行结果 
                while(rSet.next()){  
                    int id=rSet.getInt("id");  
                    String usernameString=rSet.getString("username");  
                    String passwordString=rSet.getString("password");  
                }  
                if(rSet!=null)  
                    rSet.close();  
                if(psPreparedStatement!=null)  
                    psPreparedStatement.close();  
                if(conn!=null)  
                    conn.close();  
            }  
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45

### 算法 ###

> 1、50个人围坐一圈，当数到三或者三的倍数出圈，问剩下的人是谁，原来的位置是多少

/*出圈算法是一类比较典型的算法面试题，它可以很好地考察求职者的编程功底。由于它是一种循环的逻辑，因此它比起一般的基础算法题会更难一些。本例在回答该问题的同时，详细地讲解出圈算法的实现思路。 对于出圈的问题，它有一个比较大的困难点，就是它总是重复循环的，它的头就是它的尾巴，所以，出圈问题的循环语句是比较难写的。 该题目的圈的元素个数是50个，每次数到3或3的倍数的时候，就把当前元素出圈，并且继续数数，直到再遇到3的倍数。这里，如果下标从0开始，一直到一圈完成以后，它就会接到圈的首部，这应该如何处理呢？其实，最好的办法就是使用取余的办法，就可以始终得到3个倍数，无论它的倍数是多少，也不管它的元素个数是多少。 由于每次去掉元素以后，元素的个数会少一个，因此下一个3的倍数其实只需要走两步，在为其下标赋值的时候，需要减一，保持每次去掉的元素都是3的倍数。 说明：如果使用从0开始的下标开始计算，那么初始化的时候应该使用-1，这样就可以模拟元素已经减少一个了。 至于元素的保存，可以使用数组，也可以使用链表。数组的元素去掉以后，它的下一个元素是不会自动往前移动的，不太好使用，但是也可以使用。这里，最好是使用java.util.List链表来表示，它既有下标，又可以很方便地获得元素的当前个数，尽管效率比数组要稍微低一些，不过已经足够了。*/
        import java.util.LinkedList;    
        import java.util.List;    
        //测试类 
        public class Cycle {      
            public static int cycle(int total, int k) {  //功能方法 
                List<Integer> dataList = new LinkedList<Integer>();//创建链表对象 
                for (int i = 0; i < total; i++)  //添加数据元素 
                    dataList.add(new Integer(i + 1));      
                int index = -1;  //定义下标，模拟已经去掉一个元素，因此从-1开始 
            while (dataList.size() > 1) { //一直循环去除数据，直到只剩下一个元素 
                    index = (index + k) % dataList.size();//得到应该出局的下标 
                    dataList.remove(index--);  //去除元素 
                }      
                return ((Integer) dataList.get(0)).intValue();//返回它的值 
            }      
          //主方法 
            public static void main(String[] args) {      
                System.out.println("该数字原来的位置是："+cycle(50, 3));     
            }      
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31

> 2、实现一个电梯模拟器用

基本思路：
    
    模拟电梯运行（为单一电梯，未考虑达到承载上限，最短等待时间等问题）
    
    基本条件：
    
    1、电梯有三种状态：静止，向上，向下。
    
    2、每层的指示灯有三种状态：向上、向下、到达（只开门）。
    
    3、开门上人1秒，每上或下一层用0.1秒。
    
    
    
    /*实现方案: 使用一个队列（可看做时间优先）将所有按钮事件依次入队。 当电梯静止时首先响应队头的按钮事件，并根据按钮楼层和当前楼层的位置确定移动方向； 当向上移动时，将移动到所有亮灯的按钮所在楼层的最高层，当按钮方向和电梯方向一致时或该楼层内部到达按钮亮起时开门；向下移动类似。 当队列中没有按钮事件时，电梯静止。有些类似LOOK算数，但没有按钮事件时不会来回扫描。 使用主线程来控制电梯上下，需要注意同步“设置和获取电梯按钮最高层或按钮最底层数的方法”。*/
    while(true){
                if(!ele.getPushedFloor().isEmpty()){
                    int nextFloor = ele.getPushedFloor().peek();
                    if(nextFloor > 0){
       //向上的按钮
                        if(ele.getCurFloor() - nextFloor <= 0){
                            ele.liftUp();
                        }else if(ele.getCurFloor() - nextFloor > 0){
                            ele.liftDown();
                        }
                    }else{
       //向下的按钮
                        if(ele.getCurFloor() + nextFloor < 0){
                            ele.liftUp();
                        }else if(ele.getCurFloor() + nextFloor >= 0){
                            ele.liftDown();
                        }
                    }
                }else{
                    ele.setStat(RunningStat.INIT);
                }
                Thread.sleep(100);
            }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42

> 3、写一个冒泡排序

package sort;
    
    public class BubbleSort { 
        //第一种方法完全就是按照冒泡排序的定义来写的
        //代码完全没有经过优化
        public void Bubble1(int[]a,int n){
            int i,j;
            for(i=0;i<n-1;i++){
                for(j=1;j<n-i;j++){
                    if(a[j-1]>a[j]){
                        swap(a,j-1,j);
                        //int k;
                        //k=a[j-1];
                        //a[j-1]=a[j];
                        //a[j]=k;
                }
            }
        }
       }
       //第二种方法代码优化一下 写一个标志位,如果一趟下来发生交换则标志为true，如果未发生交换，为false
        //则代表排序已完成
        public void Bubble2(int[]a,int n){
            int u,v;
            boolean flag;
            flag=true;
            while(flag){
                flag=false;
                for(u=0;u<n-1;u++){
                    for(v=1;v<n-u;v++){
                        if(a[v-1]>a[v])
                            swap(a,v-1,v);
                    }
                    flag=false;
                }
                }
    
        }
    //第三种方法，如果有一个50个数的数组，仅前面10个数是无序的，后面40个数是有序的，并且大于前面10个数，那么
        //第一次排序后，最后发生交换的位置必小于10，且这个位置之后的数据必定是有序的，记录下这个位置后，
        //以后遍历就从头到这个位置就可以了
        public void Bubble3(int[]a,int n){
            int p,q;
            int flag1=n;
            while(flag1>0){
                q=flag1;
                flag1=0;
                for(p=1;p<q;p++){
                    if(a[p-1]>a[p])
                        swap(a,p-1,p);
                    flag1=p;
                }
            }
        }
        public void swap(int a[],int p,int q ){
            int k;
            k=a[p];
         a[p]=a[q];
            a[q]=k;
    
        }  
    
       }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62

> 4、写一个折半查找

import java.util.Comparator;  
    
        public class MyUtil {  
    
           public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {  
              return binarySearch(x, 0, x.length- 1, key);  
           }  
    
           // 使用循环实现的二分查找 
           public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {  
              int low = 0;  
              int high = x.length - 1;  
              while (low <= high) {  
                  int mid = (low + high) >>> 1;  
                  int cmp = comp.compare(x[mid], key);  
                  if (cmp < 0) {  
                    low= mid + 1;  
                  }  
                  else if (cmp > 0) {  
                    high= mid - 1;  
                  }  
                  else {  
                    return mid;  
                  }  
              }  
              return -1;  
           }  
    
           // 使用递归实现的二分查找 
           private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {  
              if(low <= high) {  
                int mid = low + ((high -low) >> 1);  
                if(key.compareTo(x[mid])== 0) {  
                   return mid;  
                }  
                else if(key.compareTo(x[mid])< 0) {  
                   return binarySearch(x,low, mid - 1, key);  
                }  
                else {  
                   return binarySearch(x,mid + 1, high, key);  
                }  
              }  
              return -1;  
           }  
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45

> 5、随机产生20个不能重复的字符并排序

import java.util.HashSet;
    import java.util.Random;
    import java.util.Set;
    import java.util.TreeSet;
    
    
    public class bb { 
    
        public static void main(String[] args) {
    
            Set noreapeat  =new TreeSet();
    
    
             Random rdm = new Random();  
            while (noreapeat.size()<20){
    
                int  bb =Math.abs(rdm.nextInt())%26+97;
    
                 char cc =(char)bb;
                noreapeat.add(cc);
            }
            System.out.println(noreapeat);
    
    
    
    
    
        }
    
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31

> 6、写一个函数，传入 2 个有序的整数数组，返回一个有序的整数数组

7、写一段代码在遍历 ArrayList 时移除一个元素

8、古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少

9、约瑟芬环游戏

import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class No10 {
    //约瑟芬环 游戏：有n个人站成一个圈，标上号1-n：从第一个开始报数，数到m,就拖出去杀掉，下一位从一开始数，数到m杀掉，问最后一个人的标号是多少，
    //下面有两个方法
    //方法2是正确的，方法只能满足小数据，大一点的就异常了。求大神帮我改一下，看我的打印信息就知道我的思路了。
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    //经测试，输入： 6 3
    //12 4都成功，输入大了就不行了，比如54 12就报错了，求帮我修改一下
    Scanner scanner = new Scanner(System.in);
    
    System.out.print("请输入总人数：");
    
    int totalNum = scanner.nextInt();
    
    System.out.print("请输入报数的大小：");
    
    int cycleNum = scanner.nextInt();
    yuesefu1(totalNum, cycleNum);
    
    System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    yuesefu2(totalNum, cycleNum);
    
    }
    
    public static void yuesefu1(int t ,int p)
    {
        //首先我把这些人给放到数组里面，方便操作
    
        List l = new ArrayList();
        for(int i=1;i<=t;i++)
        { 
            l.add(i);
        }
        System.out.println(l.size());
    
        int wei =p;
        while(l.size()>1)
        {
            if(l.size()==p)
            {
                System.out.println("等于p");
                System.out.println("删掉"+l.get(p-1));
                l.remove(p-1);
            }if(l.size()<p)
            {
                System.out.println("小于p");
                System.out.println("删掉"+l.get(p-l.size()-1));
                l.remove(l.get(p-l.size()-1));
                System.out.println("---------------------------------");
                for(int k = 0;k<l.size();k++)
                {
                    System.out.print(l.get(k)+".");
                }
                System.out.println("---------------------------------");
    
            }
            else{
            //先删除一个p位置的
            l.remove(p-1);
            //---------------------------------
            System.out.println("---------------------------------");
            for(int k = 0;k<l.size();k++)
            {
                System.out.print(l.get(k)+".");
            }
            System.out.println("---------------------------------");
            //---------------------------------
            for(int j=0;j<p-1;j++)
            {
                l.add(l.get(j));
            }
            //---------------------------------
            System.out.println("---------------------------------");
            for(int k = 0;k<l.size();k++)
            {
                System.out.print(l.get(k)+".");
            }
            System.out.println();
            System.out.println("---------------------------------");
            //---------------------------------
            for(int j=0;j<p-1;j++)
            {
                l.remove(0);
            }
            //---------------------------------
            System.out.println("---------------------------------");
            for(int k = 0;k<l.size();k++)
            {
                System.out.print(l.get(k)+".");
            }System.out.println();
            System.out.println("---------------------------------");
            }
        }
    
        System.out.println("最后的："+l.get(0));
    }
    
    public static void yuesefu2(int t,int p)
    {
        List list = new ArrayList();
        for(int i=1;i<=t;i++)
        {
            list.add(i);
        }
        int k=0;
        while(list.size()>0)
        {
            k = k+p; 
            k= k%(list.size())-1;
             System.out.print("k="+k+"值为：");
            if(k<0)
            {
                System.out.println(list.get(list.size()-1));
                list.remove(list.size()-1);
                k=0;
            }else
            {
                System.out.println(list.get(k));
                list.remove(k);
            }
        }
    
    }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111
       112
       113
       114
       115
       116
       117
       118
       119
       120
       121
       122
       123
       124
       125
       126
       127
       128
       129

### 正则 ###

> 1、请编写一段匹配IP地址的正则表达式

之前一直不太会写正则表达式，很多要用到正则表达式的都直接百度，像上次要用正则表达式验证是否是合法的ip地址，然后就上网找，结果就是没找到一个对的，今天就为大家贡献一下，写个对的，并做一下解析。（建议大家还是去看书去规范的学一下，不要直接百度，不然都是坑）。
    
    iPv4的ip地址都是（1~255）.（0~255）.（0~255）.（0~255）的格式
    
    下面给出相对应的正则表达式：
    
    "^(1\\d{ 2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
    
    +"(1\\d{ 2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
    
    +"(1\\d{ 2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
    
    +"(1\\d{ 2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$" 上面的一个不漏就是正确的验证ip的正则表达式，简单的讲解一下 \\d表示0~9的任何一个数字 { 2}表示正好出现两次 [0-4]表示0~4的任何一个数字 | 的意思是或者 ( )上面的括号不能少，是为了提取匹配的字符串，表达式中有几个()就表示有几个相应的匹配字符串 1\\d{ 2}的意思就是100~199之间的任意一个数字 2[0-4]\\d的意思是200~249之间的任意一个数字 25[0-5]的意思是250~255之间的任意一个数字 [1-9]\\d的意思是10~99之间的任意一个数字 [1-9])的意思是1~9之间的任意一个数字 \\.的意思是.点要转义（特殊字符类似，@都要加\\转义） 说到这里应该已经很清楚的知道了上面的正则表达式的意思。
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39

> 2、写出一个正则表达式来判断一个字符串是否是一个数字

public boolean isNumeric(String str){   
       Pattern pattern = Pattern.compile("[0-9]*");   
       Matcher isNum = pattern.matcher(str);  
       if( !isNum.matches() ){  
           return false;   
       }   
       return true;   
    }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

### 字符串 ###

> 1、写一个方法，入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。

/** * 写入一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。 * @param fileName 文件名 * @param str 查找的字符串 * @return * @throws Exception */
        //方法一
        public static int funCount1(String fileName,String str) throws Exception {
            int count = 0;
            BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
            String line ;
            StringBuilder sb = new StringBuilder();
            while((line = bf.readLine() )!= null) {
                sb = sb.append(line);
            }
            int a = 0;
            while((a = sb.indexOf(str)) != -1) {
                sb = sb.delete(a, a + str.length());
                count++;
            }
            return count;
        }
    
        //方法二：正则表达式
        public static int funCount2(String fileName,String str) throws Exception {
            int count =0 ;
            BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
            String line ;
            StringBuilder sb = new StringBuilder();
            while((line = bf.readLine() )!= null) {
                sb = sb.append(line);
            }
            String pattern = ".*" + str + ".*";
            while(Pattern.matches(pattern, sb.toString())) {
                count ++;
                int a = sb.indexOf(str);
                sb.delete(a, a + str.length());
            }
            return count;
        }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41

> 2、写一个程序找出所有字符串的组合，并检查它们是否是回文串

public static void main(String[] args) {
      String text = "abccb";
      System.out.println(isHuiwen(text));
     }
     public static boolean isHuiwen(String text){
      int length = text.length();
      for(int i=0;i<length/2;i++){
       if(text.charAt(i)!=text.charAt(length-i-1)){
        return false;
       }
      }
      return true;
     }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13

> 3、写一个字符串反转函数，输入abcde转换成edcba代码

import java.util.Scanner;
    
    public class Test6 { 
    
        /** * 6、将字符串中进行反转。abcde --> edcba * 分析： * 字符串String 有索引 有最大长度 * 通过for循环从最大长度lengrh-1 开始到0为止倒序遍历 */
        public static void main(String[] args) {
            //键盘录入任意字符串
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一串字符串：");
            String line = sc.nextLine();
            //将字符串倒序打印
            System.out.println("字符串反转后为：");
            //循环条件int i = line.length()-1;i >= 0;i--
            for(int i = line.length()-1;i >= 0;i--){
             //字符串转换成字符输出
                System.out.print(line.charAt(i));
            }
        }
    
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26

> 4、小游戏，倒转句子中的单词

public static void reverseWord( char[ ] s,int start,int end ){ char temp;
          while(start < end){ temp = s[start];
              s[start] = s[end];
               s[end] = temp;
         }    
    }
     public static void reverseSentense(char[] s){
                  int len = s.length;
                   int start = 0,end = 0;
                  reverseWord(s,0,len-1);
               while(start < len){ if(s[start] == ' ' ){ start++;
                                      end++;
                                     continue;
    
                          }else if(s[end] == ' ' || end == len ]){ reverseWord(s,start,end-1);
                                           strat = end;
                           }else{
                                    end++;}
    
                        }
    
    
    }
    
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30

> 5、将GB2312编码的字符串转换为ISO-8859-1编码的字符串

String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");  
     
      
     
      
       1

> 6、请写一段代码来计算给定文本内字符“A”的个数。分别用迭代和递归两种方式

public class RecursiveCall {
    
        public int countA(String input) {
    
            // exit condition – recursive calls must have an exit condition
            if (input == null || input.length( ) == 0) {
                return 0;
            }
    
            int count = 0;
    
            //check first character of the input
            if (input.substring(0, 1).equals("A")) {
                count = 1;
            }
    
            //recursive call to evaluate rest of the input
            //(i.e. 2nd character onwards)
            return count + countA(input.substring(1));
        }
    
        public static void main(String[ ] args) {
            System.out.println(new RecursiveCall( ).countA("AAA rating"));  // Ans. 3
        }
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25

> 7、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”，应该截为“我AB”，输入“我ABC汉DEF”，应该输出为“我ABC”，而不是“我ABC+汉的半个”

一、需要分析
    
    1、输入为一个字符串和字节数，输出为按字节截取的字符串--------------》按照字节[byte]截取操作字符串，先将String转换成byte类型
    
    2、汉字不可以截半----------------------------------------------------------------------------------------------------------》汉字截半的话对应字节的ASC码为小于0的数值
    
    二、技术难点
    
    1、知道汉字截半的话对应字节的ASC码为小于0的数值
    
    2、对字符串操作应该都要面对的一个问题，字符串是否有效null, 字符串的长度0,1这种边界处理
    
    代码实现
    
    package com.itheima;
    
    /** * 10、 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 * 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。 * * @author 281167413@qq.com */
    
    public class Test10 { 
    
        public static void main(String[] args) {
            String srcStr1 = "我ABC";
            String srcStr2 = "我ABC汉DEF";
    
            splitString(srcStr1, 4);
            splitString(srcStr2, 6);
        }
    
        public static void splitString(String src, int len) {
            int byteNum = 0;
    
            if (null == src) {
                System.out.println("The source String is null!");
                return;
            }
    
            byteNum = src.length();
            byte bt[] = src.getBytes(); // 将String转换成byte字节数组
    
            if (len > byteNum) {
                len = byteNum;
            }
    
            // 判断是否出现了截半，截半的话字节对于的ASC码是小于0的值
            if (bt[len] < 0) {
                String subStrx = new String(bt, 0, --len);
                System.out.println("subStrx==" + subStrx);
            } else {
                String subStrx = new String(bt, 0, len);
                System.out.println("subStrx==" + subStrx);
            }
        }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59

> 8、给定 2 个包含单词列表（每行一个）的文件，编程列出交集

9、打印出一个字符串的所有排列

import java.util.Scanner;
    
    public class Demo001 { 
    
        public static void main(String[] args) {
            String str = "";
    
            Scanner scan = new Scanner(System.in);
    
            str = scan.nextLine();
    
            permutation(str.toCharArray(), 0);
        }
    
        public static void permutation(char[] str, int i) {
            if (i >= str.length)
                return;
            if (i == str.length - 1) {
                System.out.println(String.valueOf(str));
            } else {
                for (int j = i; j < str.length; j++) {
                    char temp = str[j];
                    str[j] = str[i];
                    str[i] = temp;
    
                    permutation(str, i + 1);
    
                    temp = str[j];
                    str[j] = str[i];
                    str[i] = temp;
                }
            }
        }
    
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35

> 10、将一个键盘输入的数字转化成中文输出(例如：输入1234567，输出:一百二拾三万四千五百六拾七)

public class Reader {
        private String strNum;
        private String strNumChFormat;
        private String strNumTemp;
        private int intNumLen;
        private String strBegin;
        public Reader(String strNum) {
            this.strNum = strNum;
        }
        public boolean check(String strNum) {
            boolean valid = false;
            if (strNum.substring(0,1).equals("0")){
                this.strNum = strNum.substring(1);
            }
            try {
                new Double(strNum);
                valid = true;
            }
            catch (NumberFormatException ex) {
                System.out.println("Bad number format!");
            }
            return valid;
        }
        public void init() {
            strNumChFormat = "";
            intNumLen = strNum.length();
            strNumTemp = strNum;
            strNumTemp = strNumTemp.replace('1', '一');
            strNumTemp = strNumTemp.replace('2', '二');
            strNumTemp = strNumTemp.replace('3', '三');
            strNumTemp = strNumTemp.replace('4', '四');
            strNumTemp = strNumTemp.replace('5', '五');
            strNumTemp = strNumTemp.replace('6', '六');
            strNumTemp = strNumTemp.replace('7', '七');
            strNumTemp = strNumTemp.replace('8', '八');
            strNumTemp = strNumTemp.replace('9', '九');
            strNumTemp = strNumTemp.replace('0', '零');
            strNumTemp = strNumTemp.replace('.', '点');
            strBegin = strNumTemp.substring(0, 1);
        }
        public String readNum() {
            if (check(strNum)) {
                init();
                try {
                    for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
                        if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
                            strNumChFormat = "位";
                        }
                        else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
                            strNumChFormat = "位" + strNumChFormat;
                        }
                        else if (strNumTemp.charAt(intNumLen - i) == '点') {
                            j = 1;
                            k = 1;
                            strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
                            continue;
                       }
                       else {
                           strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
                        }
              if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
                  strNumTemp.charAt(intNumLen - i - 1) != '零') {
                if (j == 1 && i < intNumLen) {
                  strNumChFormat = '拾' + strNumChFormat;
                }
                else if (j == 2 && i < intNumLen) {
                  strNumChFormat = '百' + strNumChFormat;
                }
                else if (j == 3 && i < intNumLen) {
                  strNumChFormat = '千' + strNumChFormat;
                }
              }
              if (j == 4 && i < intNumLen) {
                j = 0;
              }
              if (k == 4 && i < intNumLen) {
                strNumChFormat = '万' + strNumChFormat;
              }
              else if (k == 8 && i < intNumLen) {
                k = 0;
                strNumChFormat = '亿' + strNumChFormat;
              }
              j++;
              k++;
            }
            while (strNumChFormat.indexOf("位") != -1) {
              strNumChFormat = strNumChFormat.replaceAll("位", " ");
            }
            if (strNumChFormat.substring(0, 2) == "一拾") {
              strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
            }
            if (strNumChFormat.indexOf("点") >= 0) {
              String rebegin = strNumChFormat.substring(0,
                  strNumChFormat.indexOf("点"));
              String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
                  strNumChFormat.length());
              for (int i = 1; i <= relast.length(); i++) {
                relast = relast.replaceAll("拾", "");
                relast = relast.replaceAll("百", "");
                relast = relast.replaceAll("千", "");
                relast = relast.replaceAll("万", "");
                relast = relast.replaceAll("亿", "");
              }
              strNumChFormat = rebegin + relast;
            }
          }
          catch (ArrayIndexOutOfBoundsException ex) {
            ex.printStackTrace();
          }
          catch (Exception ex) {
            ex.printStackTrace();
          }
          int off = strNumChFormat.indexOf("点");
          strNumChFormat = strBegin + strNumChFormat.substring(0);
        }
        else {
          strNumChFormat = "";
        }
        return strNumChFormat;
      }
      public static void main(String args[]) {
        try {
          String number = args[0].toString();
          System.out.println("The number is: " + number);
          Reader reader = new Reader(number);
          System.out.println("Output String: " + reader.readNum());
        }
        catch (Exception ex) {
          System.out.println("Please input like that: javac Reader <number>");
        }
      }
    } 
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111
       112
       113
       114
       115
       116
       117
       118
       119
       120
       121
       122
       123
       124
       125
       126
       127
       128
       129
       130
       131
       132

> 11、在Web应用开发过程中经常遇到输出某种编码的字符，如从 GBK 到 ISO8859-1等，如何输出一个某种编码的字符串

public String translate (String str) {
    
            String tempStr = "";
    
            try {
                tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");
                tempStr = tempStr.trim();
            }catch (Exception e) {
                System.err.println(e.getMessage());
            }
            return tempStr;
            }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12

### 日期 ###

1、计算两个日期之间的差距

import java.text.DateFormat;  
        import java.text.ParseException;  
        import java.text.SimpleDateFormat;  
        import java.util.Date;  
        /** * 时间相距 * @author Ben * @version 1.0 * @date 2009-10-21 16:38:51 */  
        public class DateDistance {   
    
            /** * 两个时间之间相差距离多少天 * @param one 时间参数 1： * @param two 时间参数 2： * @return 相差天数 */  
            public static long getDistanceDays(String str1, String str2) throws Exception{  
                DateFormat df = new SimpleDateFormat("yyyy-MM-dd");  
                Date one;  
                Date two;  
                long days=0;  
                try {  
                    one = df.parse(str1);  
                    two = df.parse(str2);  
                    long time1 = one.getTime();  
                    long time2 = two.getTime();  
                    long diff ;  
                    if(time1<time2) {  
                        diff = time2 - time1;  
                    } else {  
                        diff = time1 - time2;  
                    }  
                    days = diff / (1000 * 60 * 60 * 24);  
                } catch (ParseException e) {  
                    e.printStackTrace();  
                }  
                return days;  
            }  
    
            /** * 两个时间相差距离多少天多少小时多少分多少秒 * @param str1 时间参数 1 格式：1990-01-01 12:00:00 * @param str2 时间参数 2 格式：2009-01-01 12:00:00 * @return long[] 返回值为：{天, 时, 分, 秒} */  
            public static long[] getDistanceTimes(String str1, String str2) {  
                DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
                Date one;  
                Date two;  
                long day = 0;  
                long hour = 0;  
                long min = 0;  
                long sec = 0;  
                try {  
                    one = df.parse(str1);  
                    two = df.parse(str2);  
                    long time1 = one.getTime();  
                    long time2 = two.getTime();  
                    long diff ;  
                    if(time1<time2) {  
                        diff = time2 - time1;  
                    } else {  
                        diff = time1 - time2;  
                    }  
                    day = diff / (24 * 60 * 60 * 1000);  
                    hour = (diff / (60 * 60 * 1000) - day * 24);  
                    min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);  
                    sec = (diff/1000-day*24*60*60-hour*60*60-min*60);  
                } catch (ParseException e) {  
                    e.printStackTrace();  
                }  
                long[] times = {day, hour, min, sec};  
                return times;  
            }  
            /** * 两个时间相差距离多少天多少小时多少分多少秒 * @param str1 时间参数 1 格式：1990-01-01 12:00:00 * @param str2 时间参数 2 格式：2009-01-01 12:00:00 * @return String 返回值为：xx天xx小时xx分xx秒 */  
            public static String getDistanceTime(String str1, String str2) {  
                DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
                Date one;  
                Date two;  
                long day = 0;  
                long hour = 0;  
                long min = 0;  
                long sec = 0;  
                try {  
                    one = df.parse(str1);  
                    two = df.parse(str2);  
                    long time1 = one.getTime();  
                    long time2 = two.getTime();  
                    long diff ;  
                    if(time1<time2) {  
                        diff = time2 - time1;  
                    } else {  
                        diff = time1 - time2;  
                    }  
                    day = diff / (24 * 60 * 60 * 1000);  
                    hour = (diff / (60 * 60 * 1000) - day * 24);  
                    min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);  
                    sec = (diff/1000-day*24*60*60-hour*60*60-min*60);  
                } catch (ParseException e) {  
                    e.printStackTrace();  
                }  
                return day + "天" + hour + "小时" + min + "分" + sec + "秒";  
            }  
        }  
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111

> 文章有不当之处，欢迎指正，同时也欢迎在评论区给你的漂亮的答案，你也可以关注我的微信公众号：`好好学java`，每日更新知识点总结干货。  
> ![好好学java][java 3]

[https_blog.csdn.net_sihai12345_article_details_79465620]: https://blog.csdn.net/sihai12345/article/details/79465620
[java]: http://mp.weixin.qq.com/s?__biz=MzI2OTQ4OTQ1NQ==&mid=2247483797&idx=1&sn=0418b3c569ddc1f0d585e2c0db18a63d&chksm=eadec5d5dda94cc39db8e2d0ce175e5ee6fbee91793d0e73961d20f1bef71687d7e32f48695f#rd
[java 1]: http://mp.weixin.qq.com/s?__biz=MzI2OTQ4OTQ1NQ==&mid=2247483796&idx=1&sn=6a9b9c1c073dc32c8acae72a959ede29&chksm=eadec5d4dda94cc20b667313c045e69dc2cdf8291dccc26415469af77b7bd311c37814abe68e#rd
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzI2OTQ4OTQ1NQ==&mid=2247483855&idx=1&sn=47e3f6ff6b689aab562417c785a54c48&chksm=eadec58fdda94c990ec318e298c1febe7eb1c79af7d89377c1362aa6afbad462e3e8abd9efe3#rd
[java 2]: https://mp.weixin.qq.com/s?__biz=MzI2OTQ4OTQ1NQ==&mid=2247483871&idx=1&sn=42e12d045a26b83451cf639e2030e601&chksm=eadec59fdda94c89f0aebf5bab659588306fe828db9dafe3b18721957ff67c3ef7500e9a2169#rd
[http_blog.csdn.net_zxp_cpinfo_article_details_53523697]: http://blog.csdn.net/zxp_cpinfo/article/details/53523697
[https_www.jianshu.com_p_2461535c38f3]: https://www.jianshu.com/p/2461535c38f3
[http_blog.csdn.net_u013322876_article_details_76610029]: http://blog.csdn.net/u013322876/article/details/76610029
[http_blog.sina.com.cn_s_blog_c065adec0101eu98.html]: http://blog.sina.com.cn/s/blog_c065adec0101eu98.html
[http_blog.csdn.net_lai1365266_article_details_45271985]: http://blog.csdn.net/lai1365266/article/details/45271985
[http_blog.csdn.net_guoweimelon_article_details_50849710]: http://blog.csdn.net/guoweimelon/article/details/50849710
[https_www.cnblogs.com_OceanEyes_p_overview-of-solid-principles.html]: https://www.cnblogs.com/OceanEyes/p/overview-of-solid-principles.html
[https_www.cnblogs.com_OlderBird_p_4322925.html]: https://www.cnblogs.com/OlderBird/p/4322925.html
[https_www.cnblogs.com_losbyday_p_5843960.html]: https://www.cnblogs.com/losbyday/p/5843960.html
[http_blog.csdn.net_yangkai_hudong_article_details_12554983]: http://blog.csdn.net/yangkai_hudong/article/details/12554983
[http_blog.csdn.net_suxinpingtao51_article_details_8011335]: http://blog.csdn.net/suxinpingtao51/article/details/8011335
[http_www.jb51.net_article_94783.htm]: http://www.jb51.net/article/94783.htm
[http_www.jb51.net_LINUXjishu_335549.html]: http://www.jb51.net/LINUXjishu/335549.html
[https_www.cnblogs.com_bugutian_p_4528650.html]: https://www.cnblogs.com/bugutian/p/4528650.html
[https_www.cnblogs.com_yzlpersonal_p_5077392.html]: https://www.cnblogs.com/yzlpersonal/p/5077392.html
[http_blog.csdn.net_21aspnet_article_details_50700123]: http://blog.csdn.net/21aspnet/article/details/50700123
[http_www.ruanyifeng.com_blog_2011_09_restful.html]: http://www.ruanyifeng.com/blog/2011/09/restful.html
[https_www.cnblogs.com_jian-xiao_p_5821675.html]: https://www.cnblogs.com/jian-xiao/p/5821675.html
[https_www.cnblogs.com_feng9exe_p_5611992.html]: https://www.cnblogs.com/feng9exe/p/5611992.html
[http_blog.csdn.net_johnstrive_article_details_16805121]: http://blog.csdn.net/johnstrive/article/details/16805121
[http_blog.csdn.net_apicescn_article_details_42965785]: http://blog.csdn.net/apicescn/article/details/42965785/
[https_www.cnblogs.com_vipyoumay_p_5853694.html]: https://www.cnblogs.com/vipyoumay/p/5853694.html
[http_blog.csdn.net_yanghaitao_1990_article_details_51723066]: http://blog.csdn.net/yanghaitao_1990/article/details/51723066
[http_blog.csdn.net_zj_show_article_details_8078447]: http://blog.csdn.net/zj_show/article/details/8078447
[http_blog.csdn.net_a291382932_article_details_52567094]: http://blog.csdn.net/a291382932/article/details/52567094
[https_www.cnblogs.com_yelongsan_p_6306418.html]: https://www.cnblogs.com/yelongsan/p/6306418.html
[http_blog.csdn.net_shw372029857_article_details_52687906]: http://blog.csdn.net/shw372029857/article/details/52687906
[https_www.cnblogs.com_wqhwe_p_5407468.html]: https://www.cnblogs.com/wqhwe/p/5407468.html
[https_www.cnblogs.com_likaitai_p_5431246.html]: https://www.cnblogs.com/likaitai/p/5431246.html
[http_aokunsang.iteye.com_blog_2053719]: http://aokunsang.iteye.com/blog/2053719
[http_blog.csdn.net_u013404872_article_details_70799420]: http://blog.csdn.net/u013404872/article/details/70799420
[http_blog.csdn.net_yangcheng33_article_details_76408580]: http://blog.csdn.net/yangcheng33/article/details/76408580
[http_blog.csdn.net_xingyunlost_article_details_53169283]: http://blog.csdn.net/xingyunlost/article/details/53169283
[https_www.cnblogs.com_fnng_p_3653793.html]: https://www.cnblogs.com/fnng/p/3653793.html
[https_www.cnblogs.com_webary_p_6507413.html]: https://www.cnblogs.com/webary/p/6507413.html
[https_www.cnblogs.com_Brad-Lee_p_5808299.html]: https://www.cnblogs.com/Brad-Lee/p/5808299.html
[http_blog.csdn.net_randyjiawenjie_article_details_6968591]: http://blog.csdn.net/randyjiawenjie/article/details/6968591
[https_www.cnblogs.com_Matrix_Yao_archive_2009_07_28_1532883.html]: https://www.cnblogs.com/Matrix_Yao/archive/2009/07/28/1532883.html
[http_blog.csdn.net_duhacker_article_details_48295807]: http://blog.csdn.net/duhacker/article/details/48295807
[java 3]: /images/20220127/647b2f45f09945e3b465ef5929b2079c.png