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.可替换性（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要使用强制转换

2、使用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语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

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

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

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

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

     五、以上规则对其它对象锁同样适用.

举例说明：  
     一、当两个并发线程访问同一个对象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语句。

 

 

 

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

转载于:https://www.cnblogs.com/miss3316/p/8474166.html