面试题整合

灰太狼 2023-10-01 19:54 8阅读 0赞

**01.java三大版本(J2SE\\ J2EE\\ J2ME)**

> J2SE:数据库连接，接口定义，输入/输出，网络编程 J2EE：包含了J2SE中的类，还包括了servlet，JSP，XML，事务控制。  
> J2ME：包含了J2SE中部分类，用于消费电子产品的软件开发。---------呼机，智能卡，手机，PDA，机顶盒。  
> J2SE包含于J2EE中，J2ME包含了J2SE的核心类，但新添加了一些专有类 应用场合，API的覆盖范围各不相同

**02.java的安全性**

> 1.取消了指针  
> 2.垃圾回收机制-------不需要程序员直接控制内存回收，避免了程序员忘记及时回收，导致内存泄漏，避免程序错误回收程序核心类库对1内存，导致系统崩溃。  
> 3.异常处理机制-----try,catch,finally,throw,throws五个关键字。  
> 4.强制类型转换：只有满足强制类型转换规则的情况下才能强制转成功。  
> 5.保证了底层安全性：Java在字节码的传输过程中使用了公开密匙加密机制（PKC）  
> 6.在运行环境提供了四级安全保障机制：字节码校验器—类装载器—运行时内存布局–文件访问限制。

**03.java的垮平台原理**

> 由源文件(.java)—>字节码文件(.class)(二进制文件)-----> 解释---->Unix,Win,Linux等机器。  
> 1.一次编译，到处运行  
> 2.编译器的作用：将源文件编译成class文件  
> 3.虚拟机的作用：将字节码文件解释成对应平台机器码并执行。  
> 4.java可以实现跨所有的平台？只有提供并且安装了相对应的虚拟机就可以跨该平台。  
> 5.虚拟机和解释器的关系：解释器是虚拟机的一个重要的组成部分。  
> 6.Java语言的执行要经过编译和解释两个阶段。

**C语言跨平台原理**

> 由源文件(.c)—>编译成相对应的机器码---->Unix,Win,Linux  
> 1.多次编译，到处运行  
> 2.C和Java哪个速度快？C语言是直接执行编码，Java是先将class文件解释成机器码再执行。

**04.搭建一个java的开发环境**

> 安装JDK

**05.什么是JVM？什么是JDK？什么是JRE？**

JVM------Java Virtual
    	Machine。JVM是Java平台的基础，和实际的机器一样，它也有自己的指令集，并且在运行时操作不同的内存区域，它相当于是一个独立工作的机器，JVM的主要工作是解释自己的指令集（即字节码）到CPU的指令集或对应的系统调用，保护用户免被恶意程序骚扰。
    	JVM对上层的Java源文件是不关心的，它关注的只是由源文件生成的类文件（.class文件）。 JRE----java runtime
    	environment.光有JVM还不能让class文件执行，因为在解释class的时候JVM需要调用解释所需要的类库lib。在JDK的安装目录里你可以找到jre目录，里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和lib和起来就称为jre.
    JDK---java development kit. JDK的安装目录：
        	bin: 最主要的是编译器(javac.exe)
            include: java和JVM交互用的头文件
            lib：类库      
            jre: java运行环境   JDK是用于java程序的开发,而jre则是只能运行class而没有编译的功能。

**06.java中基本数据类型占几个字节**

> java中的八种基本数据类型（值类型）：int、long、float、double、short、byte、char、boolean  
> ![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTlsI_pg60u_size_20_color_FFFFFF_t_70_g_se_x_16]
> 
>     英文字母：
>      - 字节数 : 1;编码：GB2312
>      - 字节数 : 1;编码：GBK
>      - 字节数 : 1;编码：ISO-8859-1
>      - 字节数 : 1;编码：UTF-8
>     
>     中文汉字：
>      - 字节数 : 2;编码：GB2312
>      - 字节数 : 2;编码：GBK
>      - 字节数 : 1;编码：ISO-8859-1
>      - 字节数 : 3;编码：UTF-8 ```

**07. public, private, protected以及不写的区别？**

1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
        2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
    3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。
    4、friendly：friendly表示当前包的，默认不写情况下使用。
                   
     作用域       当前类    同一package   子孙类     其他package
      public        √          √          √           √
      protected     √          √          √           ×
      friendly      √          √          ×           ×
      private       √          ×          ×           ×
    注：不写时默认为friendly

**12.关键字final，finally和finalize的区别是什么？**

> final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。  
> finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。

**13.是否可以在一个static方法中使用非static变量或者方法？**

> 不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。

**2.多态的好处**

> 允许不同类对象对同一消息做出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用)。主要有以下优点：
> 
> 1.  可替换性：多态对已存在代码具有可替换性
> 2.  可扩充性：增加新的子类不影响已经存在的类结构
> 3.  接口性：多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。
> 4.  灵活性
> 5.  简化性

**07.java面向对象的特征**

> 面向对象的特性：  
> 2.POP(Procedure Oriented Program) 面向过程的编程 ：只通过控制结构解决问题，数据与函数分离  
> 2.OOP(Object Oriented Program) 面向对象的编程 ：数据(属性)与函数(方法)封装在一起  
> 3.AOP(Aspect Oriented Program) 面向切面的编程：可以做到对程序的透明过滤 面向对象编程(OOP)的三大特征：
> 
> 1.  封装（保证了属性与方法的关联性）
> 2.  继承（代码复用）
> 3.  多态（在代码复用的同时，强化了个性差异）

**13.代码中如何实现多态**

> 实现多态主要有以下三种方式：
> 
> 1.  接口实现
> 2.  继承父类重写方法
> 3.  同一类中进行方法重载

**14：代码中如何实现多态虚拟机是如何实现多态的**

> 动态绑定技术(dynamic binding)，执行期间判断所引用对象的实际类型，根据实际类型调用对应的方法。

**15：接口的意义**

> 接口的意义用三个词就可以概括：规范，扩展，回调。

**3.抽象类和接口的区别有哪些？**

> 抽象类（abstract class）：
> 
> 1.  如果一个类中有抽象方法，那么这个类一定是抽象类
> 2.  抽象类中不一定有抽象方法
> 3.  抽象类中可以存在普通属性、方法、静态属性、静态方法、抽象方法 和构造方法
> 4.  抽象类中的抽象方法需要有子类实现，如果子类不实现，则子类也需要定义为抽象的
> 
> 接口（interface）：
> 
> 1.  接口中的方法，永远都被public来修饰
> 2.  接口中没有构造方法，也不能实例化接口对象
> 3.  接口中只有方法的声明，没有方法体
> 4.  接口中只有常量，如果定义变量，在编译的时候都会默认加上“public static final”
> 5.  接口中定义的方法都需要实现类来实现，如果实现类不能实现接口中的所有方法，则实现类需要定义为抽象类
> 6.  静态方法不能被子类重写（覆盖），因此接口中不定声明静态方法
> 7.  使用接口可以实现多继承
> 
> 接口和抽象类的区别之处：
> 
> 1.  接口中所有的方法隐含都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法
> 2.  类可以实现很多个接口，但是只能继承一个抽象类
> 3.  类可以不实现抽象类和接口声明的所有方法，在这种情况下，类也必须得声明成是抽象的
> 4.  抽象类可以在不提供接口方法实现的情况下实现接口
> 5.  java接口中声明的变量默认都是final的，抽象类可以包含非final变量
> 6.  java接口中的成员函数默认都是public的，抽象类中的成员函数可以是private，protected或者是public的
> 7.  接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是如果它包含main方法的话是可以被调用的

**2.构造方法能否被重写和重载？**

> 重写特性：
> 
> 1.  重写的方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)
> 2.  子类抛出的异常不能超过父类相应方法抛出的异常(子类异常不能大于父类异常)
> 3.  子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)
> 4.  重写只能重写父类非私有的方法，只存在于继承关系中(只存在于子类中)
> 
> 重载特性：
> 
> 1.  方法名一定要相同。
> 2.  方法的返回值类型、修饰符可以相同，也可不同
> 3.  方法的参数列表必须不同，也就是参数个数或参数顺序不一致，以此区分不同的方法体。  
>     1）.如果参数个数不同，就不管它的参数类型了！  
>     2）.如果参数个数相同，那么参数的类型或者参数的顺序必须不同。
> 
> 构造方法特性：
> 
> 1.  方法名和类名相同，并且没有返回值和void返回值，在初始时被调用，
> 2.  重载方法的参数个数或参数顺序必须不一致。
> 3.  默认带无参的隐藏构造方法，构造方法一经重载，要手动声明无参构造方法。
> 
> 对比重载和重写：
> 
> 1.  重写要求参数列表必须一致，而重载要求参数列表必须不一致
> 2.  重写要求返回值类型必须一致，而重载对此没有限制
> 3.  重写只能用于子类重写父类的方法，重载可以用于同一类中的所有方法
> 
> 构造方法能否被重写和重载？
> 
> 1.  构造方法可以被重载，但不能被重写，重写只能存在于带继承关系的子类中，正确的构造方法，没有返回值和void值，而继承父类后重写父类的构造方法因为没有返回值会报错，加上void值后不是一个构造方法而是一个普通的方法，在初始化时不会被执行，所以子类只能调用父类的构造方法，不能重写父类的
> 2.  构造方法，而重载可以用于同一个类中的所有方法。

**16：抽象类的意义**

> 抽象类的意义可以用三句话来概括：
> 
> 1.  为其他子类提供一个公共的类型
> 2.  封装子类中重复定义的内容
> 3.  定义抽象方法,子类虽然有不同的实现，但是定义时一致的

**17父类的静态方法能否被子类重写**

> 不能。重写只适用于实例方法,不能用于静态方法，而子类当中含有和父类相同签名的静态方法，我们一般称之为隐藏。

**08.装箱和拆箱**

> 简单一点说，装箱就是 自动将基本数据类型转换为包装器类型；拆箱就是 自动将包装器类型转换为基本数据类型。

**下表是基本数据类型对应的包装器类型：**

<table> 
 <thead> 
  <tr> 
   <th>int（4字节）</th> 
   <th>Integer</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte（1字节）</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short（2字节）</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>long（8字节）</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float（4字节）</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double（8字节）</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char（2字节）</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean（未定）</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

**09.==和equals的区别**

> == ：== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。  
> equals：  
> equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

**2. & 和 && 的区别**

> &运算符有两种用法：(1)按位与；(2)逻辑与。 
    > &&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是 true 整个表达式的值才是 true。
    > &&之所以称为短路运算是因为，如果&&左边的表达式的值是
    > false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是 null
    > 而且不是空字符串，应当写为username != null
    > &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如 果不成立，根本不能进行字符串的
    > equals 比较，否则会产生 NullPointerException
    > 异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

**18什么是不可变对象**

> 不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。

**10.String是基本数据类型吗？**

> String 是引用类型，底层用char数组实现的。

**6. String类常用方法**

**10.是否可以继承String**

> String 类是final类，不可以被继承。 继承 String 本身就是一个错误的行为，对 String  
> 类型最好的重用方式是关联关系（Has-A）和依赖关系（Use-A）而不是继承关系（Is-A）。

**11.String, StringBuffer和StringBuilder区别**

> String是字符串常量，final修饰： StringBuffer字符串变量(线程安全)； StringBuilder  
> 字符串变量(线程不安全)。

**12.String和StringBuffer主要区别是性能：**

> String是不可变对象，每次对String类型进行操作都等同于产生了一个新的String对象，然后指向新的String对象。所以尽量不在对String进行大量的拼接操作，否则会产生很多临时对象，导致GC开始工作，影响系统性能。  
> StringBuffer是对对象本身操作，而不是产生新的对象，因此在有大量拼接的情况下，我们建议使用StringBuffer。

**9.Java编程中，运行时异常与一般异常的区别？**

> 在Java中提供了两种错误的异常类，分别是Error和Exception，它们拥有共同的父类Throwable。
    > Error:表示程序在运行期间出现了非常严重的错误，该错误不可恢复，发生在JVM层次，将导致程序终止执行，OutOfMemoryError、ThreadDeath都属于错误；
    > Exception:表示可恢复的异常，可以被编译器捕捉，分为Checked Exception和RunTime Exception两大类。
    
    Checked Exception：
    这类异常是在程序中最常见的，所有继承于Exception类并且不是RunTime Exception的异常都是Checked Exception，比如常见的IOException、SQLException。  
    这类异常发生在程序的编译阶段，Java编译器强制程序去捕获该类异常，即把所有出现这些异常类的代码放到try代码块中，把对异常的处理放在catch块中,
    
    该类异常一般在如下情况下使用：
    1. 异常的发生并不会导致程序出错，进行处理后可以继续进行后续的操作，例如，连接数据库失败后可以重新连接后进行后续操作；
    2. 程序依赖于不可靠的外界条件，例如IO系统。
    
    RunTime Exception：
    RunTime Exception不同于Checked Exception，编译器没有进行强制的捕获并处理。如果不对这类异常进行处理，将会交由Java虚拟机进行处理，如NullPointerException异常。常见的RunTime Exception有：NullPointerException、ClassCaseException、ArrayIndexOutOfBoundsException、ArrayStoreException、BufferOverflowException、ArithmeticException等。
    
    出现异常后，系统会一值把异常往上抛出，知道遇到处理代码位置。如果没有处理代码，则抛掷最上层；如果多线程就用Thread.run()方法抛出；如果是单线程就用main()方法抛出。抛出之后，若果是线程那么该线程退出，若果是主程序，那么主程序退出。因此，如果不对运行时的异常进行处理，后果非常严重，一旦发生，线程终止，程序退出。
    
    处理RunTIme Exception时应该注意以下几点：
    1. 进行异常捕获时，应该按照县捕获子类，再捕获基类的信息的原则；
    2. 尽早抛出异常，并对异常进行处理，或者从错误中恢复，或者让程序继续执行；
    3. 根据实际情况自定义继承于Exception的异常类；
    4. 异常能处理就处理，不能处理就抛出。

**10.try语句块里有一个return语句，那么紧跟在这个try后的finally语句块会不会被执行？如果会被执行，执行的时机是什么？**

> 1、不管有没有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行；  
> 3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；  
> 4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

**11.在异常处理当中throw和throws有什么区别和联系？**

Throws：是用来声明一个方法可能抛出的所有异常信息，一般写在方法（类）上，通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；
    语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{
        ......}
    如： public void function() throws Exception{
        ......}
    
    
    Throw：则是指抛出的一个具体的异常类型，一般写在方法体内部，需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。
    语法：throw（异常对象）；
    	throw e；
    
    throw与throws的区别
    1、throw用在方法体内， throws用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。
    2、throw是具体向外抛异常的，抛出的是一个异常实例，throws声明了是哪种类型的异常，使它的调用者可以捕获这个异常
    3、throw，如果执行了，那么一定是抛出了某种异常了，而throws表示可能出现，但不一定。
    4、同时出现的时候，throws出现在函数头、throw出现在函数体，两种不会由函数去处理，真正的处理由函数的上层调用处理

**38．get、post两种请求方式的区别**

> 1、GET请求，请求的数据会附加在URL之后，以?分割URL和传输数据，多个参数用&连接。URL的编码格式采用的是ASCII编码，而不是uniclde，即是说所有的非ASCII字符都要编码之后再传输。
    > POST请求：POST请求会把请求的数据放置在HTTP请求包的包体中。上面的item=bandsaw就是实际的传输数据。
    > 因此，GET请求的数据会暴露在地址栏中，而POST请求则不会。 2、传输数据的大小
    > 在HTTP规范中，没有对URL的长度和传输的数据大小进行限制。但是在实际开发过程中，对于GET，特定的浏览器和服务器对URL的长度有限制。因此，在使用GET请求时，传输数据会受到URL长度的限制。
    > 对于POST，由于不是URL传值，理论上是不会受限制的，但是实际上各个服务器会规定对POST提交数据大小进行限制，Apache、IIS都有各自的配置。
    > 3、安全性
    > POST的安全性比GET的高。这里的安全是指真正的安全，而不同于上面GET提到的安全方法中的安全，上面提到的安全仅仅是不修改服务器的数据。比如，在进行登录操作，通过GET请求，用户名和密码都会暴露再URL上，因为登录页面有可能被浏览器缓存以及其他人查看浏览器的历史记录的原因，此时的用户名和密码就很容易被他人拿到了。除此之外，GET请求提交的数据还可能会造成Cross-site
    > request frogery攻击 4、HTTP中的GET，POST，SOAP协议都是在HTTP上运行的

**17.说说你对Servlet的理解**

> Servlet（Servlet Applet），全称Java  
> Servlet,是用Java编写的服务器端程序。而这些Servlet都要实现Servlet这个接口。其主要功能在于交互式的浏览和修改数据，生成动态Web内容。Servlet运行于支持Java的应用服务器中。

**18.Servlet的生命周期**

> Servlet运行在Servlet容器中，其生命周期由容器来管理。Servlet的生命周期通过javax.servlet.Servlet接口中的init()、service()和destroy()方法来表示。  
> Servlet的生命周期包含了下面4个阶段：  
> （1）加载和实例化  
> （2）初始化  
> （3）请求处理  
> （4）服务终止

**19.Servlet中forward和redirect的区别**

1．
    forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址. 
    redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL. 
    2.从数据共享来说  
    forward:转发页面和转发到的页面可以共享request里面的数据. 
    redirect:不能共享数据. 
    3.从运用地方来说  
    forward:一般用于用户登陆的时候,根据角色转发到相应的模块. 
    redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等. 
    4.从效率来说  
    forward:高.
    redirect:低.

**20.jsp和Servlet的相同点和不同点**

> JSP 是 Servlet 技术的扩展，本质上是 Servlet  
> 的简易方式，更强调应用的外表表达。相同点：JSP和Servlet和本质上都是java类。Servlet 和 JSP 最主要的不同点在于，  
> Servlet 的应用逻辑是在 Java 文件中，并且完全从表示层中的 HTML 里分离开来。 而 JSP 的情况是 Java和 HTML  
> 可以组合成一个扩展名为.jsp 的文件。 JSP 侧重于视图，Servlet 主要用于控制逻辑。

**21.九大内置对象和四大作用域和页面传值**

作用域：
    
    第一个作用域是page，他只在当前页面有效，也就是用户请求的页面有效，当当前页面关闭或转到其他页面时，page对象将在响应回馈给客户端后释放。
    第二个作用域是request，他在当前请求中有效，request可以通过setAttribute()方法实现页面中的信息传递，也可以通过forward()方法进行页面间的跳转，需要注意的是request是转发不是重定向，转发相对于浏览器来说是透明的，也就是无论页面如何跳转，地址栏上显示的依旧是最初的地址。
    第三个作用域是session，他在当前回话中有效。当一个台电脑上的同一浏览器对服务器进行多次访问时，在这多次访问之间传递的信息就是session作用域的范围。它从浏览器发出第一个HTTP请求即可认为会话开始，但是会话结束的时间是不确定的，因为在浏览器关闭时并不会通知服务器，一般Tomcat设置的默认时间为120分钟，也可以通过setMaxInactiveInterval(int)方法进行设置，或是通过invalidate()方法强制结束当前会话。
    第四个作用域是application，他在所有的应用程序中都有效，也就是当服务器开始到服务器结束这段时间，application作用域中存储的数据都是有效的，同样可以通过setAttribute赋值和getAttribute取值。
    
    内置对象：
    内置对象一（out）：
        out 对象用于在Web浏览器内输出信息，并且管理应用服务器上的输出缓冲区。在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出流。其最常用的方法为print，可在页面中显示字符串信息。out的作用域为page：
    
    内置对象二（request）：
        request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数据。（包括头信息、系统信息、请求方式以及请求参数等）。request对象的作用域为一次请求（也就是request作用域）。request的常用方法有getParameter(String name)根据表单组件名称获取页面提交数据，getParameterValues(String name)获取一组以相同名称命名的表单组件提交的数据，setCharacterEncoding(String charset)在调用getParameter()方法前进行设定，用于解决中文乱码，getRequestDispatcher(String path)返回一个javax.servlet.RequestDispatcher对象，该对象的forward()方法用于转发请求：
    
    内置对象三（response）：
        response 代表的是对客户端的响应，主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域，它只在JSP页面内有效。response的常用方法有addCookie(Cookie cookie)向客户端添加cookie，serContentType(String type)设置HTTP响应的contentType类型，setCharacterEncoding(String charset)设置响应所采用的字符编码类型，sendRedirect(String location)将请求重新定位到一个新的地址上，这是地址栏上的地址会改变：
    
    内置对象四（session）：
        session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。session对象内部使用Map类来保存数据，因此保存数据的格式为 “Key/value”。 session对象的value可以使用对象类型。session的常用方法有setAttribute(String key,Object value)以key/value的形式将对象保存到session中，getAttribute(String key)通过key值获取session中保存的value，invalidate()强制session对象失效，getId()获取sessionid，setMaxInactiveInterval(int interval)设置session的非活动时间，getMaxInactiveInterval()获取session的有效非活动时间，removeAttribute(String key)删除session中对应key的value值：
    
    内置对象五（application）：
        application 对象可将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。与session对象相比，application对象生命周期更长，类似于系统的“全局变量”。application常用方法有setAttribute(String key,Object value)以key/value的形式将对象存储到application中，getAttribute(String key)通过key获取application中存储的对象，getRealPath(String path)返回相对路径的真实路径：
    
    内置对象六（pageContext）：
        pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。pageContext对象的创建和初始化都是由容器来完成的，在JSP页面中可以直接使用 pageContext对象。pageContext的常用方法有getRequest()获取request对象，getResponse()获取response对象，getSession()获得session对象，getOut()获取out对象，setAttribute(String key,Object value)保存属性，getAttribute(String key)获取属性，include("url")请求指定的资源，并且将目标资源的响应结果包含在调用页面的响应中：
    内置对象七（page）：
        page 对象代表JSP本身，只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量，类似于Java编程中的 this 指针。
    
    内置对象八（config）： 
        config 对象的主要作用是取得服务器的配置信息。通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。当一个Servlet 初始化时，容器把某些信息通过 config对象传递给这个 Servlet。 开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。
    
    内置对象九（exception）：
        exception 对象的作用是显示异常信息，只有在包含 isErrorPage="true" 的页面中才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。excepation对象和Java的所有对象一样，都具有系统提供的继承结构。exception 对象几乎定义了所有异常情况。在Java程序中，可以使用try/catch关键字来处理异常情况； 如果在JSP页面中出现没有捕获到的异常，就会生成 exception 对象，并把 exception 对象传送到在page指令中设定的错误页面中，然后在错误页面中处理相应的 exception 对象。

**22.Session和Cookie的区别和使用场景**

cookie存于客户端，session存于服务器端。
       cookie的作用是与服务器进行交互，作为http规范的一部分存在，而web storage是为了在本地存储“数据”而生。
       cookie应用场景：①判断用户是否登录过网站； ②用来记录购物车或者记录用户使用偏好来制定推送；
       session应用场景：①登录验证信息
    　 cookie是网站为了标示用户身份而储存在用户本地终端（Client Side）上的数据（通常经过加密）。
    　 cookie数据始终在同源的http请求中携带（即使不需要），记会在浏览器和服务器间来回传递。
    　 sessionStorage和localStorage不会自动把数据发给服务器，仅在本地保存。
     
    有效期不同：
    　localStorage：存储持久数据，浏览器关闭后数据不丢失除非主动删除数据；
    　sessionStorage：数据在当前浏览器窗口关闭后自动删除。
    　cookie：设置的cookie过期时间之前一直有效，即使窗口或浏览器关闭
     
    作用域不同：
        sessionStorage：在打开的不同浏览器窗口不共享，既使是同一页面
        localStorage：在同源页面共享
        cookie：同源页面共享
     
    存储大小：
    　cookie数据大小不能超过4k
    　sessionStorage和localStorage 虽然也有存储大小的限制，但比cookie大得多，可以达到5M或更大。

**01.讲一下java中的集合**

> Java中集合可以分为map集合和set集合和list集合。 Map集合是一对键值对集合，键是唯一，值是不唯一的,  
> 最常用的就是HashMap集合，HashMap集合键值都是可以为空的， set集合是不可重复的，无序，而list集合是有序并且可重复的，  
> list又可以分为ArrayList和LinkedList，arrayList内部是可变的数组结构， 他的访问速度快，插入，删除速度慢。  
> LinkedList内部是双向链表结构，他的访问速度慢，但是插入和删除速度快

**02.线程安全的集合对象**

> 1.  Vector 线程安全：
> 
>  *  HashTable 线程安全：
>  *  StringBuffer 线程安全：
> 
> 1.  非线程安全的对象
> 
>  *  ArrayList ：
>  *  LinkedList：
>  *  HashMap：
>  *  HashSet：
>  *  TreeMap：
>  *  TreeSet：
>  *  StringBulider：
> 
> 1.  ArrayList 和LinkedList、Vector的区别 list又可以分为ArrayList和LinkedList， ArrayList内部是可变的数组结构，他的访问速度快，插入，删除速度慢。  
>     LinkedList内部是双向链表结构，他的访问速度慢，但是插入和删除速度快  
>     Vector与ArrayList一样，也是通过数组实现的，支持线程同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此它的线程安全，访问速度比ArrayList慢。
> 2.  HashMap和HashTable、HashSet的区别 HashMap和Hashtable都实现了Map接口 HashMap集合，HashMap集合键值都是可以为空的，线程不安全，运行速度较快  
>     HashTable集合，HashTable集合键不可以为空，值可以为空，线程安全，运行速度较慢  
>     HashSet集合，HashSet集合基于HashMap实现，无容量限制，非线程安全的，切无序的
> 3.  List集合和set集合的区别 set和list都实现了Collection接口 set集合是不可重复的，无序，而list集合是有序并且可重复的 set又可以分为HashSet和TreeSet TreeSet  
>     是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。 HashSet  
>     是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。  
>     HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的  
>     String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。  
>     list又可以分为ArrayList和LinkedList， ArrayList内部是可变的数组结构，他的访问速度快，插入，删除速度慢。  
>     LinkedList内部是双向链表结构，他的访问速度慢，但是插入和删除速度快
> 4.  TreeSet集合和HashSet集合的区别 set又可以分为HashSet和TreeSet TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。 HashSet  
>     是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。  
>     HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的  
>     String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。
> 5.  TreeSet集合和TreeMap集合的区别 TreeSet和TreeMap都是完全基于Map来实现的，并且都不支持get(index)来获取指定位置的元素，需要遍历来获取。另外，TreeSet还提供了一些排序方面的支持，例如传入Comparator实现、descendingSet以及descendingIterator等。  
>     1、TreeSet： a. 基于TreeMap实现的，支持排序； b. 是非线程安全的；  
>     2、TreeMap： a.典型的基于红黑树的Map实现，因此它要求一定要有key比较的方法，要么传入Comparator比较器实现，要么key对象实现Comparator接口；  
>     b. 是非线程安全的；

**19.例举几个线程安全的集合框架**

> vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。  
> statck：堆栈类，先进后出 hashtable：就比hashmap多了个线程安全 enumeration：枚举，相当于迭代器  
> 除了这些之外，其他的都是非线程安全的类和接口。 线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。

**15.什么叫线程安全？**

什么是进程？
    单独运行的程序就是一个独立的进程，进程之间是相互独立存在的。如：QQ、酷狗播放器、电脑管家等等都是独立的进程
    什么是线程？
    进程想要执行任务需要依赖线程，换句话说就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。
    什么是多线程？
    多线程：分为串行和并行，所谓串行其实是相对于单条线程来执行多个任务，直至所有任务完成为止，并行就是多条线程在同一时刻执行不同的操作，直到执行完所有任务为止。
    什么是线程安全？
    线程安全：就是当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类时线程安全的。
    如何保证线程安全？
    在要让多个线程进行访问或操作的某个方法上加上线程锁，就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问，从而保证数据的原子性和一致性。

**18.Java中你怎样唤醒一个阻塞的线程？**

> 这是个关于线程和阻塞的棘手的问题，它有很多解决方法。如果线程遇到了IO阻塞，我并且不认为有一种方法可以中止线程。如果线程因为调用wait()、sleep()、或者join()方法而导致的阻塞，你可以中断线程，并且通过抛出InterruptedException来唤醒它。我之前写的《How  
> to deal with blocking methods in java》有很多关于处理线程阻塞的信息。

**6.Java编程中，sleep()和wait()方法的区别有哪些？**

sleep():
    sleep 是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep 不会释放对象锁。
    wait():
    wait 是Object 类的方法，对此对象调用wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify 方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
    
    
    sleep()和wait()方法的区别:
    1、这两个方法来自不同的类分别是Thread和Object
    2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
    3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围)
    
    	synchronized(x){
        
     　　	x.notify()
     　　	 //或者wait()
     　　}
     　　
    4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常。

**20.你了解守护线程吗？它和非守护线程有什么区别**

> 程序运行完毕，jvm会等待非守护线程完成后关闭，但是jvm不会等待守护线程。守护线程最典型的例子就是GC线程。

**21.什么是多线程上下文切换**

> 多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程。

**22.创建两种线程的方式?他们有什么区别?**

> 通过实现java.lang.Runnable或者通过扩展java.lang.Thread类。相比扩展Thread，实现Runnable接口可能更优.原因有二：  
> Java不支持多继承。因此扩展Thread类就代表这个子类不能扩展其他类。而实现Runnable接口的类还可能扩展另一个类。  
> 类可能只要求可执行即可，因此继承整个Thread类的开销过大。

**23.Thread类中的start()和run()方法有什么区别?**

> start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

**13.线程的的实现方式？怎么启动线程？怎么区分线程？**

Java 实现一条线程 有两种方法：
      1、继承Thread 类
      2、实现Runnable接口
    
    怎么启动线程？
    	调用run()方法
    
    什么是线程？
        线程有时候又被称为轻量级进程，是程序执行的最小单元。一个进程可对应多个线程，而一个线程只属于一个进程。

**14.线程并发库和线程池的作用**

什么是线程池？
        线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。
    
    简单了解一下线程并发库
        JDK5 中增加了DougLea 的并发库,这一引进给Java线程的管理和使用提供了强大的便利性。java.util.current 包中提供了对线程优化、管理的各项操作，使得线程的使用变得的心应手。该包提供了线程的运行，线程池的创建，线程生命周期的控制。
    
    
    线程池的作用?
      1、限定线程的个数，不会导致由于线程过多导致系统运行缓慢或崩溃。
      2、线程池不需要每次都去创建或销毁，节约了资源。
      3、线程池不需要每次都去创建，响应时间更快。
    
    Java通过Executors 提供四个静态方法创建线程池，分别为:
        newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
        newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
        newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
        newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,UFO,优先级)执行。

**14.并发编程的3要素是什么？**

> 1、原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 实现大范围原子性的方法：  
> 悲观锁（synchronized或者Lock） 乐观锁（原子类 cas）
> 
> 2、可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法：  
> synchronized或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见性。  
> volatile:被volatile修饰的变量，一个线程修改后直接把值写入主内存，其他线程直接从主内存中读取。
> 
> 3、有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。 实现有序性的方法： synchronized或者Lock  
> volatile(禁止指令重排序)

**17.什么是竞争条件？你怎样发现和解决竞争？**

> Java多线程中多个线程对同一数据进行存取操作，可能出现某一线程尚未完成对该数据的操作，而另一线程又对该数据进行操作，造成了数据错误。  
> 竞争条件产生的原因是对数据的操作不是原子操作。例如：两个线程同时执行count+=1; 这条语句被处理过程如下：  
> 1）将count加载到寄存器；  
> 2）增加1；  
> 3）将结果写回count。  
> 当线程1执行步骤1、2后，失去运行权，线程2被唤醒执行了上述步骤，然后线程1被唤醒，继续执行步骤3，那么前述操作擦掉了第二个线程所做的更新。  
> 同时由此可见，多线程中执行的中断不是语句级别甚至不是代码可见级别的，而是机器指令级别的

**10．说说进程，线程，协程之间的区别**

> 简而言之，进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

**16.什么叫死锁？如何避免？**

死锁 : 当线程A持有独占锁a，并尝试去获取独占锁b的同时，线程B持有独占锁b，并尝试获取独占锁a的情况下，就会发生AB两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。
    死锁的四个必要条件
    1、互斥（Mutual exclusion）：存在这样一种资源，它在某个时刻只能被分配给一个执行绪（也称为线程）使用；
    2、持有（Hold and wait）：当请求的资源已被占用从而导致执行绪阻塞时，资源占用者不但无需释放该资源，而且还可以继续请求更多资源；
    3、不可剥夺（No preemption）：执行绪获得到的互斥资源不可被强行剥夺，换句话说，只有资源占用者自己才能释放资源；
    4、环形等待（Circular wait）：若干执行绪以不同的次序获取互斥资源，从而形成环形等待的局面，想象在由多个执行绪组成的环形链中，每个执行绪都在等待下一个执行绪释放它持有的资源。
    如何避免
    1) 预防死锁。
    　　这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。
    2) 避免死锁。
    　　该方法同样是属于事先预防的策略，但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件，而是在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免发生死锁。
    3)检测死锁。
    　　这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源，然后采取适当措施，从系统中将已发生的死锁清除掉。
    4)解除死锁。
    这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。
    26.Java当中有哪几种锁
    自旋锁: 自旋锁在JDK1.6之后就默认开启了。基于之前的观察，共享数据的锁定状态只会持续很短的时间，为了这一小段时间而去挂起和恢复线程有点浪费，所以这里就做了一个处理，让后面请求锁的那个线程在稍等一会，但是不放弃处理器的执行时间，看看持有锁的线程能否快速释放。为了让线程等待，所以需要让线程执行一个忙循环也就是自旋操作。在jdk6之后，引入了自适应的自旋锁，也就是等待的时间不再固定了，而是由上一次在同一个锁上的自旋时间及锁的拥有者状态来决定。
    偏向锁: 在JDK1.之后引入的一项锁优化，目的是消除数据在无竞争情况下的同步原语。进一步提升程序的运行性能。 偏向锁就是偏心的偏，意思是这个锁会偏向第一个获得他的线程，如果接下来的执行过程中，改锁没有被其他线程获取，则持有偏向锁的线程将永远不需要再进行同步。偏向锁可以提高带有同步但无竞争的程序性能，也就是说他并不一定总是对程序运行有利，如果程序中大多数的锁都是被多个不同的线程访问，那偏向模式就是多余的，在具体问题具体分析的前提下，可以考虑是否使用偏向锁。
    轻量级锁: 为了减少获得锁和释放锁所带来的性能消耗，引入了“偏向锁”和“轻量级锁”，所以在Java SE1.6里锁一共有四种状态，无锁状态，偏向锁状态，轻量级锁状态和重量级锁状态，它会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。

**4.同步和异步有什么不同点？它们分别在什么时候使用？如何避免一个对象或者方法同时被多个线程访问？**

> 同步交互：指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程；  
> 异步交互：指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待。  
> 区别：一个需要等待，一个不需要等待，在部分情况下，我们的项目开发中都会优先选择不需要等待的异步交互方式。
> 
> 如何避免一个对象或者方法同时被多个线程访问:  
> 可以根据项目的需要添加不同的线程锁。

**8.volatile关键字有什么作用？**

> 用在多线程，同步变量。  
> 线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm，  
> 它所修饰的变量不保留拷贝，直接访问主内存中的（也就是上面说的A)

**27.java中的++操作符线程安全么?**

> 不是线程安全的操作。它涉及到多个指令，如读取变量值，增加，然后存储回内存，这个过程可能会出现多个线程交差。  
> 作业：根据我给的流程图设计销售订单需要的表，并且写出实现思路

**01.什么是IO流？**

> 它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流都包括了。输入流从文件中读取数据存储到进程(process)中，输出流从进程中读取数据然后写入到目标文件。

**02.Java 中有几种类型的流**

> 按照流的方向：输入流（inputStream）和输出流（outputStream）。  
> 按照实现功能分：节点流（可以从或向一个特定的地方（节点）读写数据。如  
> FileReader）和处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。）  
> 按照处理数据的单位：字节流和字符流。字节流继承于 InputStream 和  
> OutputStream，字符流继承于InputStreamReader 和OutputStreamWriter。

**03.字节流和字符流的区别。**

> 字节流在JDK1.0中就被引进了，用于操作包含ASCII字符的文件。JAVA也支持其他的字符如Unicode，为了读取包含Unicode字符的文件，JAVA语言设计者在JDK1.1中引入了字符流。ASCII作为Unicode的子集，对于英语字符的文件，可以使用字节流也可以使用字符流。

**03.Java中流类的超类主要有那些？**

>  *  java.io.InputStream
>  *  java.io.OutputStream
>  *  java.io.Reader
>  *  java.io.Writer

**2. 字节流如何转为字符流**

> 字节输入流转字符输入流通过InputStreamReader实现，该类的构造函数可以传入InputStream对象。  
> 字节输出流转字符输出流通过OutputStreamWriter实现，该类的构造函数可以传入 OutputStream对象。

**04.FileInputStream和FileOutputStream是什么？**

> 这是在拷贝文件操作的时候，经常用到的两个类。在处理小文件的时候，它们性能表现还不错，在大文件的时候，最好使用BufferedInputStream  
> (或 BufferedReader) 和 BufferedOutputStream (或 BufferedWriter)

**05.System.out.println()是什么？**

> println是PrintStream的一个方法。out是一个静态PrintStream类型的成员变量，System是一个java.lang包中的类，用于和底层的操作系统进行交互。

**06.实现一个拷贝文件的工具类要使用字节流还是字符串**

> 字节流：传递的是字节（二进制）， 字符流：传递的是字符  
> 使用字节流的传输的文件，不一定能使用字符流传输，使用字符流传输的文件都可以转成字节流在进行传输 音乐媒体等使用 的是字节，使用字符无法传输  
> 我们拷贝的文件不确定只包含字符流，有可能包含字节流（图片，视频，音乐）。考虑到通用性，所以要使用字节流

**07.字节流和字符流，你更喜欢使用哪一个？**

> 个人来说，更喜欢使用字符流，因为他们更新一些。许多在字符流中存在的特性，字节流中不存在。比如使用BufferedReader而不是BufferedInputStreams或DataInputStream，使用newLine()方法来读取下一行，但是在字节流中我们需要做额外的操作。

**27.什么是Filter流？**

> Filter Stream是一种IO流主要作用是用来对存在的流增加一些额外的功能，像给目标文件增加源文件中不存在的行数，或者增加拷贝的性能。

**28.有哪些可用的Filter流？**

> 在http://java.io包中主要由4个可用的filter Stream。两个字节filter stream，两个字符filter  
> stream. 分别是FilterInputStream, FilterOutputStream, FilterReader and  
> FilterWriter.这些类是抽象类，不能被实例化的。

**08.有哪些Filter流的子类。**

>  *  LineNumberInputStream 给目标文件增加行号
>  *  DataInputStream 有些特殊的方法如readInt(), readDouble()和readLine() 等可以读取一个 int, double和一个string一次性的,
>  *  BufferedInputStream 增加性能
>  *  PushbackInputStream 推送要求的字节到系统中

**09.在文件拷贝的时候，那一种流可以提升更多的性能？**

> 在字节流的时候，使用BufferedInputStream和BufferedOutputStream。  
> 在字符流的时候，使用BufferedReader 和 BufferedWriter

**10.说说PrintStream和PrintWriter**

> 他们两个的功能相同，但是属于不同的分类。字节流和字符流。他们都有println()方法。

**11.说说管道流(Piped Stream)**

> 有四种管道流， PipedInputStream, PipedOutputStream, PipedReader 和  
> PipedWriter.在多个线程或进程中传递数据的时候管道流非常有用。

**12.说说File类**

> 它不属于 IO流，也不是用于文件操作的，它主要用于知道一个文件的属性，读写权限，大小等信息。

**13.说说RandomAccessFile?**

> 它在http://java.io包中是一个特殊的类，既不是输入流也不是输出流，它两者都可以做到。他是Object的直接子类。通常来说，一个流只有一个功能，要么读，要么写。但是RandomAccessFile既可以读文件，也可以写文件。  
> DataInputStream 和 DataOutStream有的方法，在RandomAccessFile中都存在。

**01. \#和 $的区别**

> 1、\#\{\}是经过预编译的,是安全的，而$\{\}是未经过预编译的,仅仅是取变量的值,是非安全的  
> 2、\#\{\} 这种取值是编译好SQL语句再取值 , $\{\} 这种是取值以后再去编译SQL语句
> 
> 3、\#\{\}引用参数的时候，Mybatis会把这个参数认为是一个字符串，并自动加上’'，同时使用$\{\}的时候会把传递的值直接放进去

**28.mysql和oracle、Sql Server的分页语句**

Oracle 分页
    方法一： 
    	sekect * from
    	(
    		sekect A.* ,rowunm rn 
    		from (select * from table_name) A 
    		where rownun<=40
    	)
    	where rn>=2;1
    
    方法二：
    	select * from 
    	（
    		select A.* rownum rn
    		from (select * from table_name) A
    	）
    	where rn between 21 and 40
    
    公认第二种方法效率没有第一种高。原因是第二种要把子查询执行完，而第一种方法子查询执行到RowNum=40后就结束了
    
    
    MySQL分页
    	select * from table_name limit 10,20
    
    表示从第11条数据开始取20条数据2返回，limit后的2个参数含意为：
    起点和步长，即从那条数据开始，取多少数据.
    
    SQL Server2000分页
    	select top @pagesize * from table_name 
    	where id not in
    	(
    	select top @pagesize*(@page-1) id 
    	from table_name order by id
    	)
    	order by id
    
    SQL Server2005分页
    	方法一： 
    		select ....
    		from(
    			select row_number() 
    			over(Order By ID asc ) AS RowNum,.....
    			from table_name
    		)AS T
    		Where T.RowNum>10  and  T.RowNum<=20
    
    方法二： 
    		WITH DataList As
    		(
    			select row_unmber() over ( Order by O.Id Desc )As RowNum,....
    			from ......
    			where .......
    		)
    		select ...
    		from DataList
    		where rowNum BETWEEN 10 And 20

**29.如何使用mysql命令查看数据库、表和导入数据？**

导入数据 ：mysql>source  ygeshop.sql;
    
    1、首先建空数据库
    mysql>create database abc;
    2、导入数据库
    方法一：
    （1）选择数据库
    mysql>use abc;
    （2）设置数据库编码
    mysql>set names utf8;
    （3）导入数据（注意sql文件的路径）
    mysql>source /home/abc/abc.sql;
    
    导出数据：mysqldump -u用户名 -p密码 数据库名 > 数据库名.sql
    
    1、导出数据和表结构：
    mysqldump -u用户名 -p密码 数据库名 > 数据库名.sql
    #/usr/local/mysql/bin/   mysqldump -uroot -p abc > abc.sql
    敲回车后会提示输入密码；
    对于没有密码的直接就是： mysqldump -uroot  abc > abc.sql
    2、只导出表结构
    mysqldump -u用户名 -p密码 -d 数据库名 > 数据库名.sql
    #/usr/local/mysql/bin/   mysqldump -uroot -p -d abc > abc.sql
    注：/usr/local/mysql/bin/  --->  mysql的data目录

**32.讲讲你理解的数据库调优**

> 1.SQL语句优化、  
> 2.索引优化、  
> 3.数据表结构优化、  
> 4.数据库配置优化、  
> 5.硬件优化

**6：介绍下Mybatis**

> mybatis是持久层框架，它内部封装了jdbc，支持动态sql，sql语句和java代码分离，一般来说，一个接口对应一个xml文件，一般来说，接口里面的一个方法对应一个xml文件里面的sql语句的id值（一条sql语句）

**27.mysql数据库最大连接数**

1、查看最大连接数
    show variables like '%max_connections%';
    2、修改最大连接数
    set GLOBAL max_connections = 200;

**25.关系型数据库的三范式**

> 1、每一列属性都是不可再分的属性值，确保每一列的原子性。  
> 2、每一行的数据只能与其中一列相关，即一行数据只做一件事。只要数据列中出现数据重复，就要把表拆分开来。  
> 3、数据不能存在传递关系，即每个属性都跟主键有直接关系而不是间接关系。像：a–>b–>c 属性之间含有这样的关系，是不符合第三范式的。

**26.事务的四大特征**

> 1、原子性（Atomicity）  
> 原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。  
> 2、 一致性（Consistency）  
> 一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。  
> 拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。  
> 3、隔离性（Isolation）  
> 隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。  
> 即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。　  
> 4、持久性（Durability）  
> 持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

**29.触发器的使用场景？**

触发器语法
    CREATE [OR REPLACE] TRIGGER 触发器名称 {
        BEFORE|AFTER} {
        DELETE|INSERT|UPDATE[OF 列名]} ON 表名 [FOR EACH ROW [WHEN(条件)]] PLSQL块
    触发器分类
    1、行级触发器
    行级触发器作用的每一条记录，都会被触发，在行级触发器上使用:old和:new伪记录变量识别值的状态
    
    2、语句级触发器
    在指定的操作之前或者操作之后执行一次，不管这条语句影响了多少行，只执行一次。
    
    使用场景
    场景一：实施复杂的安全性检查
    场景二：数据确认
    场景三：数据的审计
    场景四：数据库的备份和同步
    
    Java面试题40.jQuery基于jQuery的异步请求方法
    1.最原始的js ,new XMLHttpRequest();  //由于浏览器兼容的原因，代码复杂，多使用基于jQuery的异步请求方法（内部封装）
    
    1.function loadXMLDoc()
    2.{
        
    3.    var xmlhttp;
    4.    if (window.XMLHttpRequest)
    5.    {
        
    6.        // IE7+, Firefox, Chrome, Opera, Safari 浏览器执行代码，创建XMLHttpRequest对象
    7.        xmlhttp = new XMLHttpRequest();  
    8.    }else{
        
    9.        // IE6, IE5 浏览器执行代码，创建ActiveXObject对象
    10.        xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
    11.    }
    12.    // 每当 readyState 改变时，就会触发 onreadystatechange 事件
    13.    xmlhttp.onreadystatechange=function()
    14.    {
        
    15.        // readyState存有 XMLHttpRequest 的状态。从 0 到 4 发生变化
    16.        if (xmlhttp.readyState == 4 && xmlhttp.status == 200)
    17.        {
        
    18.           //服务器响应，responseText 属性返回字符串形式的响应；responseXML 属性返回XML的响应
    19.            document.getElementById("myDiv").innerHTML = xmlhttp.responseText;
    20.        }
    21.    }
    22.    //规定请求的类型、URL 、是否异步处理请求（ture或false）
    23.    xmlhttp.open("GET", "/try/ajax/ajax_info.txt", true); 
    24.    //发送请求
    25.    xmlhttp.send();  
    26.}

**2.基于jQuery的Ajax方法：**

(1)$.ajax()，实例如下：   
    1.$.ajax({
         
    2.    // 请求方式为get或者post等
    3.    type: "GET",
    4.    // 服务器响应的数据类型
    5.    dataType: "json",
    6.    // 请求的url(一般为后台接口)  
    7.    url: "test.json",
    8.    // 发送到服务器的参数,      
    9.    data: {
        user:"xiao"},
    10.    // 请求成功后返回的数据，赋值给变量'data'  
    11.    success: function(data){
            
    12.        // 对data进行操作          
    13.    },
    14.    // 请求失败异常后，返回的错误信息
    15.    error: function(err){
        
    16. 
    17.    }                  
    18.});
     
    (2)$.getJSON(url,[data],[callback])，实例如下：
         $.getJSON("test.php", {
         name: "xiao" }, function(data){
        alert("JSON");});
    (3)$.get(url,[callback])，实例如下：//请求方式为get
          $.get("test.php",  function(data){
        alert("JSON");});
    (4)$.post(url,[data],[callback])，实例如下：//请求方式为post
          $.post("test.php", {
         name: "xiao" }, function(data){
        alert("JSON");});
    (5)load(url,[data],[callback]),实例如下：

\***31.jdbc调用存储过程**

\***24.数据库分类和常用数据库**

\***30.存储过程的优点**

\***32.简单说一下你对jdbc的理解**

\***33.写一个jdbc的访问oracle的列子**

\***34.jdbc中preparedStatement比Statement的好处**

**35.数据库连接池的作用**

> 数据库连接是一种有限的昂贵的资源， 数据库连接影响到程序的性能指标。 数据库连接池正是针对这个问题提出来的。 数据库连接池负责分配、  
> 管理和释放数据库连接， 它允许应用程序重复使用一个现有的数据库连接， 而再不是重新建立一个；  
> 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数 据库连接而引起的数据库连接遗漏。 这项技术能明显提高对数据库操作的性能。

**55.ORM是什么？ORM框架是什么？**

> 对象关系映射（Object Relational  
> Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单来说，将程序中的兑现自动持久化到关系数据库中。那么，到底如何实现持久化呢？一种简单的反感是采用硬编码的方式（jdbc操作sql方式），为每一种可能的数据库访问操作提供单独的方法：  
> 这种方案存在以下的不足：
> 
> 1.      持久化层缺乏弹性。一旦出现业务需求的变更，就必须修改持久化层的接口。
> 2.      持久化层同时与域模型与关系数据库模型绑定，不管域模型还是关系数据库模型发生变化，都要修改持久化层的相关程序代码，增加了软件的维护难度。
> 
> ORM提供了实现持久化层的另一种模式，它采用映射元数据来描述对象关系的映射，使得ORM中间件能在任何一个应用的业务逻辑层和数据库层之间充当桥梁。Java典型的ORM框架有个：Hibernate，mybatits,speedframework  
> ORM的方法论基于三个核心原则：  
> 简单：以最基本的形式建模数据  
> 传达性：数据库结构被任何人都能理解的语言文档化  
> 精准性：基于数据模型创建正确标准化了的结构 ORM框架：为了解决面型对象与关系数据库存在的互不匹配的现象的框架。 概括起来 : 对象关系映射（Object Relational  
> Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单来说，将程序中的兑现自动持久化到关系数据库中。那么，到底如何实现持久化呢？一种简单的反感是采用硬编码的方式（jdbc操作sql方式），为每一种可能的数据库访问操作提供单独的方法。这种方法存在很多缺陷，所有使用ORM框架（为了解决面型对象与关系数据库存在的互不匹配的现象的框架）来解决。

**56.ibatis和hibernate有什么不同**

> 最大的区别在于：  
> ibatas的sql语句需要自己手动写，而hibernate能够在程序运行时自动生成。但是不要就这样以为hibernate比ibatas方便，其实二者熟悉之后的效率差不多。而hibernate还能够自动建表等等，这样的好处就在于你带着这个程序，无论到什么机器上，你都不需要数据库，应为它能自动为你完成，而ibatas就必须要有相应的数据库表才能进行移植  
> Hibernate的特点：  
> Hibernate功能强大，数据库无关性好，O/R（对象/关系）映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R  
> Mapping实现了POJO（实体类） 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO  
> 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握，  
> Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC  
> 接口加以执行。Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行，但是Hibernate现在已经是主流O/R  
> Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于iBATIS。 iBATIS的特点：  
> iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。当系统属于二次开发,无法对数据库结构做到控制和修改,那iBATIS的灵活性将比Hibernate更适合。系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBATIS会有更好的可控性和表现。  
> 现在就市场来说，hibernate的需求要大于ibatas的需求，而hibernate对个人能力的要求更高，即使公司使用ibatas，你在hibernate的基础上也能快速掌握。  
> 在二者之间如果选择学习的话我建议hibernate，上面的理由我想已经足够清楚了。 希望能够对你有所帮助。

\***57.hibernate对象状态及其转换**

\***58：hibernate的缓存**

\***64：有没有使用过云主机**

\***65：数据库优化方面的事情**

\***66：如果查询和定位慢查询**

\***67：数据库优化之数据库表设计遵循范式**

\***68：选择合适的数据库引擎**

\***69：选择合适的索引**

\***70：使用索引的一些技巧**

\***71：数据库优化之分表**

\***72：数据库的读写分离**

\***73：数据库优化之缓存**

\***74：sql语句优化小技巧**

\***75：批量插入几百万条数据**

\***45.什么是框架**

**19：介绍spring框架**

> 他是一站式框架,对每个层都提供了支持，web层提供springmvc，持久层的springJDBC。它的两大核心分别是IoC和AOP使开发者代码解耦和代码简洁易维护提供了支持。  
> AOP叫面向AOP是面向切面编程，主要作用用于事务的控制，使各个步骤之间的良好隔离性耦合性大大降低，再扩展功能的同时不对源码进行修改操作  
> IOC控制反转。以前要创建一个对象是要使用者自己创建，现在可以交给spring来完成，使用者只要注入后直接使用，程序运行速度会大大提高减少服务器的负担

**3.Spring的核心功能有哪些？**

> spring的两大核心分别是IoC和AOP  
> AOP叫面向AOP是面向切面编程，主要作用用于事务的控制，使各个步骤之间的良好隔离性耦合性大大降低，再扩展功能的同时不对源码进行修改操作  
> IOC控制反转。以前要创建一个对象是要使用者自己创建，现在可以交给spring来完成，使用者只要注入后直接使用，程序运行速度会大大提高减少服务器的负担

**34.Spring ioc的原理是什么？Aop的原理是什么？**

> AOP是面向切面编程，主要作用用于事务的控制是Spring的核心功能之一 优点：1.各个步骤之间的良好隔离性耦合性大大降低  
> 2.源代码无关性，再扩展功能的同时不对源码进行修改操作 IOC控制反转。是Spring的核心功能之一， 以前要创建一个对象是要使用者自己创建， 现在可以交给spring来完成，使用者只要注入后直接使用
> 
> 1.Spring中AOP的应用场景、Aop原理、好处？ AOP是面向切面编程，主要作用用于事务的控制是  
> Spring的核心功能之一 优点：  
> 1.各个步骤之间的良好隔离性耦合性大大降低  
> 2.源代码无关性，再扩展功能的同时不对源码进行修改操作  
> 2.Spring中IOC的作用与原理？对象创建的过程。 IOC控制反转。是Spring的核心功能之一，以前要创建一个对象是要使用者自己创建，现在可以交给spring来完成，使用者只要注入后直接使用

\***52.简单介绍一下Spring或者Spring的两大核心**

\***53.AOP是什么？都用它做什么？**

\***54.Spring事务的传播特性和隔离级别**

\***48.struts2的执行流程或者struts2的原理**

\***49.Struts2的拦截器是什么**

\***59.webservice的使用场景**

\***60.activiti的简单介绍**

**24介绍springmvc**

> Spring Web MVC是一种基于Java的实现了Web  
> MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring  
> Web MVC也是要简化我们日常Web开发的。

\***50.Spring MVC的执行流程**

\***51.SpringMVC和Struts2的不同**

\***23.mvc模式和mvc各部分的实现**

\***46.简单介绍一下MVC模式**

\***47.简单说一下对mvc框架的理解**

\***36.HTML**

\***42.简单说一下html5**

\***43.简单说一下css3**

**37.简单介绍了一下Ajax**

> AJAX 是一种用于创建快速动态网页的技术。 通过在后台与服务器进行少量数据交换，AJAX  
> 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。 传统的网页（不使用  
> AJAX）如果需要更新内容，必需重载整个网页面。 有很多使用 AJAX 的应用程序案例：新浪微博、Google 地图、开心网等等。

\***38.js和JQuery的关系**

\***39.jQuery中的常用选择器**

\***40.jQuery中页面加载完毕事件**

\***41.jQuery中Ajax和原生js实现Ajax的关系**

\***44.bootstrap的是什么**

\***76：有没有使用过redis**

\***77：redis的使用场景**

\***78：redis存储对象的方式**

**79：redis数据淘汰机制**

> redis数据淘汰策略有6种：  
> volatile-lru：从已设置过期时间的数据集（server.db\[i\].expires）中挑选最近最少使用的数据淘汰  
> volatile-ttl：从已设置过期时间的数据集（server.db\[i\].expires）中挑选将要过期的数据淘汰  
> volatile-random：从已设置过期时间的数据集（server.db\[i\].expires）中任意选择数据淘汰  
> allkeys-lru：从数据集（server.db\[i\].dict）中挑选最近最少使用的数据淘汰  
> allkeys-random：从数据集（server.db\[i\].dict）中任意选择数据淘汰  
> no-enviction（驱逐）：禁止驱逐数据

\*80：java访问redis级redis集群

**25.请列举几个你使用过的linux命令**

cd   									进入什么目录
    cd usr/ 									切换到该usr目录下
    cd ../									切换到上一层目录
    cd /										切换到系统根目录
    cd ~										切换到用户主目录
    cd -										切换到上一个所在目录
    
    mkdir [目录名]							创建目录
    ls 										查看当前目录下的所有文件名
    ls -a										查询当前目录下包括隐藏文件的所有文件名
    ls -l 										查看该目录下的所有目录和文件的详细信息，简写 ll
    find [目录] [参数]								查找某个目录下与什么相关的目录（文件）
    		find /root -nam "test*" 				查找/root下的与test相关的目录(文件)
    mv  [要修改的名称]	[新文件名]				修改目录（文件及压缩包）的名称
    mv  [要移动的文件名] [要移动的文件路径]		剪切目录、移动目录
    cp -r  [要拷贝的目录名称] [要拷贝到那个路径]	拷贝目录
    rm -r [要删除目录的路径]  /					要删除某个路径下的文件
    rm -r {
        要删除的文件路径}[要删除的文件名]		删除某个文件，不强制删除，要询问
    rm -r *										删除所有文件（目录），有询问是否删除
    rm -rf  [要删除目录的路径]  /					要强制删除那个路径下的文件，无询问是否删除
    rm -rf  {
        要删除的文件路径}[要删除的文件名]		删除某个文件，强制删除
    touch  [文件名]								创建一个空文件
    cat  {
        要查看的文件路径}[要查询的文件名]		查看那个文件
    vim  {
        文件所在路径}[要修改的文件名]			修改文件内容，提示为中文字体
    vi    {
        文件所在路径}[要修改的文件名]			修改文件内容，提示为英文字体
    进入文件修改后的操作命令：		
             按ESC   :		切换命令操作界面
    			i/a/o		插入,进入编辑状态
    			wq			写入并退出
    			q			退出
    			wq!			保存并退出
    tar -zcvf  [压缩后的文件名] [要压缩的文件列表]		压缩文件，打包文件
    tar -xvf   [要解压的文件名]						解压压缩包，解压到当前目录
    tar -xvf   [要解压的文件名] -C {
        要解压的路径}        解压压缩包到某个路径下，-C后面不写默认解压到根目录下/root
    pwd 											查看当前所在位置
    ps -ef 											查看所有的进程
    ps -ef | grep [要查看的进程]							查看某个进程的信息，加过滤
    kill -9 [进程的PID]									杀死某个进程
    ifconfig											查看当前系统网卡信息
    ping												查看某台机器的连接情况
    netstat -an										查看所有端口号
    netstat -an | grep [要查看的端口号]					查看某个端口号的占用情况
    isof –I : [端口号]									查看某个端口占用情况
    addr												查看网络信息

**26.如何配置一台linux系统的服务器java环境？**

1）编辑profile文件:
    
     vi /etc/profile
    
    2）在最底部添加
    
    
    #set java environment
    JAVA_HOME=/usr/local/jdk1.7.0_71     # 这个路径就是jdk路径
    CLASSPATH=.:$JAVA_HOME/lib.tools.jar
    PATH=$JAVA_HOME/bin:$PATH
    export JAVA_HOME CLASSPATH PATH 
    
    3）重新加载/etc/profile配置文件 source /etc/profile
    source /etc/profile

**27.linux如何查看占用端口8080的进程？**

Isof –I : 端口号
    Netstat –tunlp |grep 端口号

**28.linux如何查看程序占用的cpu与内存资源？**

Ps  ausw | head

**30.一台linux服务器，上面部署了tomcat容器，网络无问题，tomcat容器也启动并监听8080端口，但是访问http://该服务器ip:8080时无法访问，试分析问题。**

> 可能端口被占用

\***37.Linux命令有哪些，项目部署过程**

\***61.linux的使用场景**

\***63：怎么操作linux服务器**

\***15.设计模式和常用的设计模式**

\***81：微信公众号分类和微信开发原理**

\***82：怎么把微信和业务平台进行绑定**

\***83：项目的分类和项目参与者**

\***84：项目流程和业务注意事项**

\***项目流程是怎么样的**

\***部署过程是怎么样的**

\***Linux命令有哪些，项目部署过程**

\***如何培训客户**

**导致线程阻塞的原因主要有以下几方面。**

> 1、线程进行了休眠：线程执行了Thread.sleep(int n)方法，线程放弃CPU，睡眠n毫秒,然后恢复运行。
> 
> 2、线程等待获取同步锁才能进行下一步操作：线程要执行一段同步代码，由于无法获得相关的同步锁，只好进入阻塞状态，等到获得了同步锁，才能恢复运行。
> 
> 3、线程执行wait（）进入阻塞状态：线程执行了一个对象的wait()方法，进入阻塞状态，只有等到其他线程执行了该对象的notify()或notifyAll()方法，才可能将其唤醒。
> 
> 4、等待相关资源：线程执行I/O操作或进行远程通信时，会因为等待相关的资源而进入阻塞状态。（例如，当线程执行System.in.read()方法时，如果用户没有向控制台输入数据，则该线程会一直等读到了用户的输入数据才从read()方法返回。进行远程通信时，在客户程序中，线程在以下情况可能进入阻塞状态。）
> 
> 5、请求连接时：请求与服务器建立连接时，即当线程执行Socket的带参数的构造方法，或执行Socket的connect()方法时，会进入阻塞状态，直到连接成功，此线程才从Socket的构造方法或connect()方法返回。
> 
> 6、读取线程等待数据：线程从Socket的输入流读取数据时，如果没有足够的数据，就会进入阻塞状态，直到读到了足够的数据，或者到达输入流的末尾，或者出现了异常，才从输入流的read()方法返回或异常中断。  
> （ 输入流中有多少数据才算足够呢?这要看线程执行的read()方法的类型。 int read()：只要输入流中有一个字节，就算足够。 int  
> read(byte\[\] buff)：只要输入流中的字节数目与参数buff数组的长度相同，就算足够。 String  
> readLine()：只要输入流中邮一行字符串，就算足够。值得注意的是，InputStream类并没有readLine方法，在过滤流BufferedReader类中才有此方法。  
> ）
> 
> 7、线程写数据时可能会出现：线程向Socket的输出流写一批数据时，可能会进入阻塞状态，等到输出了所有的数据，或者出现异常，才从输出流的write()方法返回或异常中断。
> 
> 8、调用Socket关闭连接时阻塞直到发完数据：调用Socket的setSoLinger()方法设置了关闭Socket的延迟时间，那么当线程执行Socket的close方法时，会进入阻塞状态，直到底层Socket发送完所有剩余数据，或者超过了setSoLinger()方法设置的延迟时间，才从close()方法返回。

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTlsI_pg60u_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/22804ba7d9f54e24975a4f1d9f0fe989.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASVTlsI_pg60u,size_20,color_FFFFFF,t_70,g_se,x_16