J2SE

J2SE

1）如何调整JVM与Tomcat的内存大小？

TomCat的内存大小：

安装版：在安装目录找到Bin目录下的Tomcat7w.exe 进去以后选择Java选项卡，修改最大与最小内存；

绿色版：在bin目录下找到catalina.bat，用编辑工具打开后，在:gotHome后输入set "JAVA_OPTS=-Xms512m -Xmx1024m" ；

JVM的内存大小：

Eclise 中设置jvm内存: 改动eclipse的配置文件,对所有project都起做用改动eclipse根文件夹下的eclipse.ini文件

-vmargs  //虚拟机设置

-Xms40m //初始内存

-Xmx256m //最大内存

-Xmn16m //最小内存

-XX:PermSize=128M //非堆内存

-XX:MaxPermSize=256M

2）Java语言里的类型分类？八大基本类型之间转换问题

类型分为基本类型和引用类型；类型转换，大转小自动转，小转大强制转，强制转可能损失精度；

3）面向对象思想

封装 继承 多态

继承：

在定义和实现一个类的时候，能够在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容做为本身的内容，并能够加入若干新的内容，或修改原来的方法使之更适合特殊的须要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提升了软件的可重用性和可扩展性。

封装：

封装是保证软件部件具备优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变更影响。在面向对象的编程语言中，对象是封装 的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法能够直接访问同一个对象中的属性。一般状况下，只要记 住让变量和访问这个变量的方法放在一块儿，将一个类中的成员变量所有定义成私有的，只有这个类本身的方法才能够访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则:把 对同一事物进行操做的方法和相关的方法放在同一个类中，把方法和它操做的数据放在同 一个类中。

例如，人要在黑板上画圆，这一共涉及三个对象:人、黑板、圆，画圆的方法要分配给哪一个对象呢?因为画圆须要使用到圆心和半径，圆心和半径显然是圆的属性，若是将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两 个属性，人之后只是调用圆的画圆方法、表示给圆发给消息而已，画圆这个方法不该该分配在人这个对象上，这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的 个体，对象状态(属性)由这个对象本身的行为(方法)来读取和改变。

一个更便于理解的例子就是，司机将火车刹住了，刹车的动做是分配给司机，仍是分配给火车，显然，应该分配给火车，由于司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车本身 才能完成这一动做，火车须要调用内部的离合器和刹车片等多个器件协做才能完成刹车这个动做，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动做而已。

多态：

多态是指程序中定义的引用变量所指向的具体类型和经过该引用变量发出的方法调用在编 程时并不肯定，而是在程序运行期间才肯定，即一个引用变量倒底会指向哪一个类的实例对象， 该引用变量发出的方法调用究竟是哪一个类中实现的方法，必须在由程序运行期间才能决定。 由于在程序运行时才肯定具体的类，这样，不用修改源程序代码，就可让引用变量绑定到 各类不一样的类实现上，从而致使该引用调用的具体方法随之改变，即不修改程序代码就能够 改变程序运行时所绑定的具体代码，让程序能够选择多个运行状态，这就是多态性。多态性 加强了软件的灵活性和扩展性。例如，下面代码中的 UserDao 是一个接口，它定义引用变 量 userDao 指向的实例对象由 daofactory.getDao()在执行的时候返回，有时候指向的是 UserJdbcDao 这个实现，有时候指向的是 UserHibernateDao 这个实现，这样，不用修改 源代码，就能够改变 userDao 指向的具体类实现，从而致使 userDao.insertUser()方法调用 的具体代码也随之改变，即有时候调用的是 UserJdbcDao 的 insertUser 方法，有时候调用 的是 UserHibernateDao 的 insertUser 方法:

UserDao userDao =daofactory.getDao(); userDao.insertUser(user);

比喻:人吃饭，你看到的是左手，仍是右手?

4）如何理解多态（3个特征）

什么是多态

面向对象的三大特性：封装、继承、多态。从必定角度来看，封装和继承几乎都是为多态而准备的。这是咱们最后一个概念，也是最重要的知识点。

多态的定义：指容许不一样类的对象对同一消息作出响应。即同一消息能够根据发送对象的不一样而采用多种不一样的行为方式。（发送消息就是函数调用）

实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态的做用：消除类型之间的耦合关系。

现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动做，若是当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；若是当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不一样的对象上会产生不一样的结果。

下面是多态存在的三个必要条件，要求你们作梦时都能背出来！

多态存在的三个必要条件
1、要有继承；
2、要有重写；
3、父类引用指向子类对象。

 多态的好处：

1.可替换性（substitutability）。多态对已存在代码具备可替换性。例如，多态对圆Circle类工做，对其余任何圆形几何体，如圆环，也一样工做。
2.可扩充性（extensibility）。多态对代码具备可扩充性。增长新的子类不影响已存在类的多态性、继承性，以及其余特性的运行和操做。实际上新加子类更容易得到多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性（interface-ability）。多态是超类经过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操做，提升了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤为在处理大量对象的运算和操做时，这个特色尤其突出和重要。
Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

5）具备继承关系类之间的类型转换问题

继承中类型转换的两种方式
1.向上转型 
  将子类对象转换成父类类型，例如：
  Pet pet=new Dog();
  此类型转换为自动转换
  由于子类的功能比父类更增强大，至关于让一个能力强的对象去作一件简单的事情，所以能够自动转换完成


2.向下转型

向下转型的时候须要用instanceof判断一个对象是否属于右边的类型。(强制转换可能失败)

将父类对象转换为子类类型，例如：
  Pet pet=new Pet();
  Dog dog=(Dog)pet;
  此类型转换为强制转换
  由于反之，父类的功能要弱于子类，所以须要强制转换

6）抽象类与接口的关系

区别：接口只能有赋值的全局常量；接口的全部方法只能是Public修饰的；而且没有构造函数。

抽象类有构造函数，有普通成员变量，能够有带方法体的方法，也能够是抽象方法；

联系：a)接口和抽象类都有抽象方法

      b)都不能直接去new ，只能new不是抽象类型的子类（实现类）。

彻底抽象化的抽象类，能够叫作接口。

接口不是特殊的抽象类。

7）类与类之间的关系

继承：

  继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并能够增长它本身的新功能的能力。在Java中继承关系经过关键字extends明确标识，在设计时通常没有争议性。在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。

实现：

实现指的是一个class类实现interface接口（能够是多个）的功能，实现是类与接口之间最多见的关系。在Java中此类关系经过关键字implements明确标识，在设计时通常没有争议性。在UML类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。 

依赖：

简单的理解，依赖就是一个类A使用到了另外一个类B，而这种使用关系是具备偶然性的、临时性的、很是弱的，可是类B的变化会影响到类A。好比某人要过河，须要借用一条船，此时人与船之间的关系就是依赖。表如今代码层面，为类B做为参数被类A在某个method方法中使用。在UML类图设计中，依赖关系用由类A指向类B的带箭头虚线表示。

关联：

一对一  多对多   一对多

关联体现的是两个类之间语义级别的一种强依赖关系，好比我和个人朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，通常是长期性的，并且双方的关系通常是平等的。关联能够是单向、双向的。表如今代码层面，为被关联类B以类的属性形式出如今关联类A中，也多是关联类A引用了一个类型为被关联类B的全局变量。在UML类图设计中，关联关系用由关联类A指向被关联类B的带箭头实线表示，在关联的两端能够标注关联双方的角色和多重性标记。 

聚合：

 聚合是关联关系的一种特例，它体现的是总体与部分的关系，即has-a的关系。此时总体与部分之间是可分离的，它们能够具备各自的生命周期，部分能够属于多个总体对象，也能够为多个总体对象共享。好比计算机与CPU、公司与员工的关系等，好比一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。表如今代码层面，和关联关系是一致的，只能从语义级别来区分。在UML类图设计中，聚合关系以空心菱形加实线箭头表示。

组合：

组合也是关联关系的一种特例，它体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它一样体现总体与部分间的关系，但此时总体与部分是不可分的，总体的生命周期结束也就意味着部分的生命周期结束，好比人和人的大脑。表如今代码层面，和关联关系是一致的，只能从语义级别来区分。在UML类图设计中，组合关系以实心菱形加实线箭头表示。 

总结： 对于继承、实现这两种关系没多少疑问，它们体现的是一种类和类、或者类与接口间的纵向关系。其余的四种关系体现的是类和类、或者类与接口间的引用、横向关系，是比较难区分的，有不少事物间的关系要想准肯定位是很难的。前面也提到，这四种关系都是语义级别的，因此从代码层面并不能彻底区分各类关系，但总的来讲，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖。

8）内部类

为何要出现内部类：方便一个类去访问一个类里面私有的内容；

内部类的分类：成员式内部类，方法式内部类，匿名内部类

建立静态内部类对象的通常形式为：  外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()

建立成员内部类对象的通常形式为：  外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()

9）Object

内容的比较（equal  hascode）

equal比较的是对象的值；==比较的是对象的地址；

hascode是更具特殊的算法算出的每一个实例的码；

对象的克隆（clone）

clone方法是用来复制一个对象。不一样于“=”。
对于值类型的数据是能够经过“=”来实现复制的。可是对于引用类型的对象，“=”只能复制其内存地址，使对象的引用指向同一个对象，而不会建立新的对象。clone则能够建立与原来对象相同的对象。

引用类型转换成字符串

toString  如需改变须要重写toString和hascode方法；

Wait：将线程放置锁池  notify：唤醒一个至运行队列    notifyall：所有唤醒至运行队列

10）如何来实现对自定义类设置排序规则？

//采用实现Comparable接口的方法实现排序  

class S1 implements Comparable{  

   //实现排序方法。先比较x，若是相同比较y  

    @Override  

    public int compareTo(Object o) {  

        S1 obj = (S1) o;  

        if(x != obj.x)  

        {  

            return x - obj.x;  

        }  

        return y - obj.y;  

}  

实现Comparator

11）String  StringBuffer  StringBuild

主要在字符串拼接，String是把拼接的每次结果都开辟内存空间。

StringBuffer  的全部方法都实现了同步，因此慢

StringBuild 是线程不安全的，因此快。

12）线程安全    线程不安全

主要体如今多线程中，线程不安全容易形成不可预估的错乱。而线程安全的只有每次执行完整才会让下一个线程进入；

13）基本类型   包装类    字符串

基本类型转包装类叫装箱

包装类转基本类型叫拆箱

JDK1.5以后支持自动装箱与拆箱。

字符串转基本类型经过各自包装类的解析方法解析；或者经过特有的构造函数；

14）实现数组对象的复制

Arrays.copyOf(被复制的数组，复制长度)。

copyOf(),,不是System的方法，而是Arrays的方法,下面是源码，能够看到本质上是调用的arraycopy方法。，那么其效率必然是比不上 arraycopy的.

public static int[] copyOf(int[] original, int newLength) {

   int[] copy = new int[newLength];

   System.arraycopy(original, 0, copy, 0,

   Math.min(original.length, newLength));

   return copy;

}

使用方法： 
1.使用clone 
int[] src={1,3,5,6,7,8}; 
int[] dest; 
dest=(int[]) src.clone();//使用clone建立副本,注意clone要使用强制转换

二、使用System.arraycopy 
int[] src={1,3,5,6,7,8}; 
int[] dest = new int[6]; 
System.arraycopy(src, 0, dest, 0, 6);

15）垃圾回收机制

能够经过System.gc()进行提醒

能够重写Object类里的析构函数finalize

在对象回首以前会调用finalize（） 相似C语言中的析构函数这个；

方法区：
1. 有时候也成为永久代，在该区内不多发生垃圾回收，可是并不表明不发生GC，在这里进行的GC主要是对方法区里的常量池和对类型的卸载
2. 方法区主要用来存储已被虚拟机加载的类的信息、常量、静态变量和即时编译器编译后的代码等数据。
3. 该区域是被线程共享的。
4. 方法区里有一个运行时常量池，用于存放静态编译产生的字面量和符号引用。该常量池具备动态性，也就是说常量并不必定是编译时肯定，运行时生成的常量也会存在这个常量池中。

虚拟机栈:
1. 虚拟机栈也就是咱们日常所称的栈内存,它为java方法服务，每一个方法在执行的时候都会建立一个栈帧，用于存储局部变量表、操做数栈、动态连接和方法出口等信息。
2. 虚拟机栈是线程私有的，它的生命周期与线程相同。
3. 局部变量表里存储的是基本数据类型、returnAddress类型（指向一条字节码指令的地址）和对象引用，这个对象引用有多是指向对象起始地址的一个指针，也有多是表明对象的句柄或者与对象相关联的位置。局部变量所需的内存空间在编译器间肯定
4.操做数栈的做用主要用来存储运算结果以及运算的操做数，它不一样于局部变量表经过索引来访问，而是压栈和出栈的方式
5.每一个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用过程当中的动态链接.动态连接就是将常量池中的符号引用在运行期转化为直接引用。

本地方法栈
本地方法栈和虚拟机栈相似，只不过本地方法栈为Native方法服务。

堆
java堆是全部线程所共享的一块内存，在虚拟机启动时建立，几乎全部的对象实例都在这里建立，所以该区域常常发生垃圾回收操做。

程序计数器
内存空间小，字节码解释器工做时经过改变这个计数值能够选取下一条须要执行的字节码指令，分支、循环、跳转、异常处理和线程恢复等功能都须要依赖这个计数器完成。该内存区域是惟一一个java虚拟机规范没有规定任何OOM状况的区域

判断一个对象是否存活有两种方法:
1. 引用计数法
所谓引用计数法就是给每个对象设置一个引用计数器，每当有一个地方引用这个对象时，就将计数器加一，引用失效时，计数器就减一。当一个对象的引用计数器为零时，说明此对象没有被引用，也就是“死对象”,将会被垃圾回收.
引用计数法有一个缺陷就是没法解决循环引用问题，也就是说当对象A引用对象B，对象B又引用者对象A，那么此时A,B对象的引用计数器都不为零，也就形成没法完成垃圾回收，因此主流的虚拟机都没有采用这种算法。

2.可达性算法(引用链法)
该算法的思想是：从一个被称为GC Roots的对象开始向下搜索，若是一个对象到GC Roots没有任何引用链相连时，则说明此对象不可用。
在java中能够做为GC Roots的对象有如下几种:

虚拟机栈中引用的对象

方法区类静态属性引用的对象

方法区常量池引用的对象

本地方法栈JNI引用的对象

虽然这些算法能够断定一个对象是否能被回收，可是当知足上述条件时，一个对象比不必定会被回收。当一个对象不可达GC Root时，这个对象并不会立马被回收，而是出于一个死缓的阶段，若要被真正的回收须要经历两次标记
若是对象在可达性分析中没有与GC Root的引用链，那么此时就会被第一次标记而且进行一次筛选，筛选的条件是是否有必要执行finalize()方法。当对象没有覆盖finalize()方法或者已被虚拟机调用过，那么就认为是不必的。
若是该对象有必要执行finalize()方法，那么这个对象将会放在一个称为F-Queue的对队列中，虚拟机会触发一个Finalize()线程去执行，此线程是低优先级的，而且虚拟机不会承诺一直等待它运行完，这是由于若是finalize()执行缓慢或者发生了死锁，那么就会形成F-Queue队列一直等待，形成了内存回收系统的崩溃。GC对处于F-Queue中的对象进行第二次被标记，这时，该对象将被移除”即将回收”集合，等待回收。

简述java垃圾回收机制?

在java中，程序员是不须要显示的去释放一个对象的内存的，而是由虚拟机自行执行。在JVM中，有一个垃圾回收线程，它是低优先级的，在正常状况下是不会执行的，只有在虚拟机空闲或者当前堆内存不足时，才会触发执行，扫面那些没有被任何引用的对象，并将它们添加到要回收的集合中，进行回收。

16）异常处理机制

异常分为：编译期异常   运行期异常

常见的异常：

NO.1  Java.alng.NullPointerException 

这个异常你们确定都常常遇到，异常的解释是 “程序赶上了空指针 “，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误常常出如今建立图片，调用数组这些操做中，好比图片未经初始化，或者图片建立时的路径错误等等。对数组操做中出现空指针，不少状况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配须要的空间，而初始化后的数组，其中的元素并无实例化，
依然是空的，因此还须要对每一个元素都进行初始化（若是要调用的话）。
　　在jsp编程中常常出现：if (request.getParameter(“username”).equals(“xxx”))、out.println(session.getAttribute(“record”))等。解决这个问题的方法是在使用前进行判空比较：
　　 if (request.getParameter(“username”)!=null)
　　{if if (request.getParameter(“username”).
　　equals(“xxx”))…}

 

NO.2　java.lang.ClassNotFoundException

这个异常是不少本来在JB等开发环境中开发的程序员，把JB下的程序包放在WTk下编译常常出现的问题，异常的解释是 “指定的类不存在 “，这里主要考虑一下类的名称和路径是否正确便可，若是是在JB下作的程序包，通常都是默认加上Package的，因此转到WTK下后要注意把Package的路径加上。

 

NO.3　java.lang.ArithmeticException

这个异常的解释是 “数学运算异常 “，好比程序中出现(1/0)除以零这样的运算就会出这样的异常，对这种异常，你们就要好好检查一下本身程序中涉及到数学运算的地方，公式是否是有不妥了。

 

NO.4　java.lang.ArrayIndexOutOfBoundsException
　　这个异常相信不少朋友也常常遇到过，异常的解释是 “数组下标越界 “，如今程序中大多都有对数组的操做，所以在调用数组的时候必定要认真检查，看本身调用的下标是否是超出了数组的范围，通常来讲，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就常常出错了，还有一种状况，是程序中定义的数组的长度是经过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以避免出现这个异常

 

NO.5　java.lang.IllegalArgumentException
　　这个异常的解释是 “方法的参数错误 “，不少J2ME的类库中的方法在一些状况下都会引起这样的错误，好比音量调节方法中的音量参数若是写成负数就会出现这个异常，再好比g.setColor(int red,int green,int blue)这个方法中的三个值，若是有超过２５５的也会出现这个异常，所以一旦发现这个异常，咱们要作的，就是赶忙去检查一下方法调用中的参数传递是否是出现了错误。

 

 NO.6　java.lang.IllegalAccessException
　　这个异常的解释是 “没有访问权限 “，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的状况下要注意这个异常。

 

NO.7　java.lang.IncompatibleClassChangeError
不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。通常在修改了应用中的某些类的声明定义而没有对整个应用从新编译而直接运行的状况下，容易引起该错误。

 

NO.8　java.lang.InstantiationError
实例化错误。当一个应用试图经过Java的new操做符构造一个抽象类或者接口时抛出该异常。

 

NO.9　java.lang.LinkageError
连接错误。该错误及其全部子类指示某个类依赖于另一些类，在该类编译以后，被依赖的类改变了其类定义而没有从新编译全部的类，进而引起错误的状况。

 

NO.10　java.lang.StackOverflowError
堆栈溢出错误。当一个应用递归调用的层次太深而致使堆栈溢出时抛出该错误。

 

异常处理的方法，

对于能处理的异常采用捕获异常

对于不能处理的异常采用抛出异常交给其余类处理；

 

17）数据库来的异常处理

PL-SQL 之抛出异常：

DECLARE

BEGIN

EXCEPTION

WHEN OTHERS THEN

RAISE;

END

PL/SQL处理异常不一样于其余程序语言的错误管理方法，PL/SQL的异常处理机制与ADA很类似，有一个处理错误的全包含方法。当发生错误时，程序无条件转到异常处理部分，这就要求代码要很是干净并把错误处理部分和程序的其它部分分开。oracle容许声明其余异常条件类型以扩展错误/异常处理。这种扩展使PL/SQL的异常处理很是灵活。

    当一个运行时错误发生时，称为一个异常被抛出。PL/SQL程序编译时的错误不是能被处理得异常，只有在运行时的异常能被处理。在PL/SQL程序设计中异常的抛出和处理是很是重要的内容。

    抛出异常

    由三种方式抛出异常

    . 经过PL/SQL运行时引擎

    . 使用RAISE语句

. 调用RAISE_APPLICATION_ERROR存储过程

18）文件操做和访问

文件的增删改查，文件夹的增删改查，文件夹的遍历（递归）；

文件压缩，经过调用7Z命令。

文件的分割合并。

多线程分割

public class MultiThreading extends Thread {

private File file;// 要分割的文件；

private int size;// 每一块的大小

private int pos;

private File file01;

 

public MultiThreading(File file, int size, int pos, File file01) {

super();

this.file = file;

this.size = size;

this.pos = pos;

this.file01 = file01;

}

 

@Override

public void run() {

try {

segmentation();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

 

public void segmentation() throws IOException {

RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");

randomAccessFile.seek((int) pos);

byte[] arr = new byte[size];

int read = randomAccessFile.read(arr);

FileOutputStream fileOutputStream = new FileOutputStream(file01);

fileOutputStream.write(arr, 0, read);

randomAccessFile.close();

fileOutputStream.close();

}

 

public static void main(String[] args) throws IOException {

int danwei =  1024*1024*10 ;

File file2 = new File("F:\\系统必备软件.zip");

long length = file2.length();

int unit = (int) ((length + danwei - 1) / danwei);

for (int i = 0; i < unit; i++) {

File createTempFile = new File("F:\\123\\" + (100000 + i + 1) + ".tmp");

MultiThreading multiThreading = new MultiThreading(file2, danwei, i * danwei, createTempFile);

multiThreading.start();

String name2 = multiThreading.getName();

System.out.println("线程"+name2+"开始运行");

}

 

}

}

文件的合并

public static void he(String path) throws IOException {

File file = new File(path);

int len = -1;

byte[] arr = new byte[1024];

File[] listFiles = file.listFiles();

FileOutputStream fileOutputStream = new FileOutputStream(new File("456.exe"), true);

FileInputStream fileInputStream =null;

for (int i = 0; i < listFiles.length;i++) {

fileInputStream = new FileInputStream(listFiles[i]);

while ((len = fileInputStream.read(arr)) != -1) {

fileOutputStream.write(arr, 0, len);

}

}

fileInputStream.close();

fileOutputStream.close();

}

19）多线程

建立线程的两种形式？

实现Runnable

继承Thread

将主要代码写在Run方法中

多线程的生命周期

 

同步块和同步方法

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，可以保证在同一时刻最多只有一个线程执行该段代码。

     1、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程获得执行。另外一个线程必须等待当前线程执行完这个代码块之后才能执行该代码块。

     2、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另外一个线程仍然能够访问该object中的非synchronized(this)同步代码块。

     3、尤为关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其余线程对object中全部其它synchronized(this)同步代码块的访问将被阻塞。

     4、第三个例子一样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就得到了这个object的对象锁。结果，其它线程对该object对象全部同步代码部分的访问都被暂时阻塞。

     5、以上规则对其它对象锁一样适用.

举例说明：  
     1、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程获得执行。另外一个线程必须等待当前线程执行完这个代码块之后才能执行该代码块。

 

死锁

一个类可能发生死锁，并不意味着每次都会发生死锁，这只是表示有可能。当死锁出现时，每每是在最糟糕的状况----高负载的状况下。

一个经典的多线程问题。

当一个线程永远地持有一个锁，而且其余线程都尝试去得到这个锁时，那么它们将永远被阻塞，这个咱们都知道。若是线程A持有锁L而且想得到锁M，线程B持有锁M而且想得到锁L，那么这两个线程将永远等待下去，这种状况就是最简单的死锁形式。

 

多线程通讯

那如何让 两个线程按照指定方式有序交叉运行呢？

仍是上面那个例子，我如今但愿 A 在打印完 1 后，再让 B 打印 1, 2, 3，最后再回到 A 继续打印 2, 3。这种需求下，显然 Thread.join() 已经不能知足了。咱们须要更细粒度的锁来控制执行顺序。

这里，咱们能够利用 object.wait() 和 object.notify() 两个方法来实现。代码以下：

private static void demo3() {

    Object lock = new Object();

    Thread A = new Thread(new Runnable() {

        @Override

        public void run() {

            synchronized (lock) {

                System.out.println("A 1");

                try {

                    lock.wait();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println("A 2");

                System.out.println("A 3");

            }

        }

    });

    Thread B = new Thread(new Runnable() {

        @Override

        public void run() {

            synchronized (lock) {

                System.out.println("B 1");

                System.out.println("B 2");

                System.out.println("B 3");

                lock.notify();

            }

        }

    });

    A.start();

    B.start();

}

打印结果以下：

A 1

B1

B2

B3

A2

A3

正是咱们要的结果。

那么，这个过程发生了什么呢？

首先建立一个 A 和 B 共享的对象锁 lock = new Object();

当 A 获得锁后，先打印 1，而后调用 lock.wait() 方法，交出锁的控制权，进入 wait 状态；

对 B 而言，因为 A 最开始获得了锁，致使 B 没法执行；直到 A 调用 lock.wait() 释放控制权后， B 才获得了锁；

B 在获得锁后打印 1， 2， 3；而后调用 lock.notify() 方法，唤醒正在 wait 的 A;

A 被唤醒后，继续打印剩下的 2，3。

多个线程 操做了共同资源的时候就须要用到同步块，或者同步方法，

 

线程池（各类类型的线程池）

线程池是一种多线程处理形式，处理过程当中将任务添加到队列，而后在建立线程后自动启动这些任务。线程池线程都是后台线程。每一个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。若是某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另外一个辅助线程来使全部处理器保持繁忙。若是全部线程池线程都始终保持繁忙，但队列中包含挂起的工做，则线程池将在一段时间后建立另外一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程能够排队，但他们要等到其余线程完成后才启动。

20）集合

项目开发中用过哪些集合？

List简单。 Set去重；

集合与前面学过数组的关系

数组的大小不可改变。集合大小能够改变。

set  list  map 三者之间的区别？

set：不能记住添加元素时的顺序，该集合里的元素不能重复。

     HashSet：

     TreeSet：会对容器里的元素进行排序。

list:  能够记住添加元素时的顺序，              能够重复。

     ArrayList: 查询

     LinkedList：更新  

Map: 添加的是key-value

     HashMap

     TreeMap

21）如何实现集合里的类的线程安全？

 

22）JDBC

普通处理对象与预处理对象区别

PreparedStatement是预编译的,对于批量处理能够大大提升效率.也叫JDBC存储过程

使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement对象的开销比Statement大，对于一次性操做并不会带来额外的好处。
Statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得,preparedstatement支持批处理

在Web环境中，有恶意的用户会利用那些设计不完善的、不能正确处理字符串的应用程序。特别是在公共Web站点上,在没有首先经过PreparedStatement对象处理的状况下，全部的用户输入都不该该传递给SQL语句。此外，在用户有机会修改SQL语句的地方，如HTML的隐藏区域或一个查询字符串上，SQL语句都不该该被显示出来。
在执行SQL命令时，咱们有二种选择：可使用PreparedStatement对象，也可使用Statement对象。不管多少次地使用同一个SQL命令，PreparedStatement都只对它解析和编译一次。当使用Statement对象时，每次执行一个SQL命令时，都会对它进行解析和编译。
prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，屡次使用可提升效率。
createStatement不会初始化，没有预处理，没次都是从0开始执行SQL

 

调用存储过程和函数

存储过程

  String sql = "{call getStudentCount(?)}";

CallableStatement proc = conn.prepareCall(sql);

  proc.registerOutParameter(1, java.sql.Types.INTEGER);

  proc.execute();

  studentCount = proc.getInt(1);

函数

String callFunctionSql = "{?= call getTreeChildList(?)}";

CallableStatement   callableStatement  =  conn.prepareCall(callFunctionSql); callableStatement.registerOutParameter(1,Types.LONGVARCHAR); callableStatement.setString(2, inputStr);

 

sql注入

所谓SQL注入，就是经过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来讲，它是利用现有应用程序，将（恶意的）SQL命令注入到后台数据库引擎执行的能力，它能够经过在Web表单中输入（恶意）SQL语句获得一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。

 

 

 

数据来源-各类网站整理。