1、 什么是脏数据?
脏数据(DirtyRead)是指源系统中的数据不在给定的范围内或对于实际业务毫无意义,或是数据格式非法,以及在源系统中存在不规范的编码和含糊的业务逻辑。
脏数据在临时更新(脏读)中产生。事务A更新了某个数据项X,但是由于某种原因,事务A出现了问题,于是要把A回滚。但是在回滚之前,另一个事务B读取了数据项X的值(A更新后),A回滚了事务,数据项恢复了原值。事务B读取的就是数据项X的就是一个“临时”的值,就是脏数据。
2、 解释一下什么是进程?什么是线程?
进程是指运行中的应用程序,每个进程都有自己独立的地址空间(内存空间),比如用户点击桌面的IE浏览器,就启动了一个进程,操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器,又启动了一个进程,操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
要点:用户每启动一个进程,操作系统就会为该进程分配一个独立的内存空间。
线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。
差异:
1、线程是轻量级的进程
2、线程没有独立的地址空间(内存空间)
3、线程是由进程创建的(寄生在进程)
4、一个进程可以拥有多个线程-->这就是我们常说的多线程编程
5、线程有几种状态:
a、新建状态(new)
b、就绪状态(Runnable)
c、运行状态(Running)
d、阻塞状态(Blocked)
e、死亡状态(Dead)
3、解释一下hashtable?
定义:哈希表是一种重要的存储方式,也是一种常见的检索方法。其基本思想是将关系码的值作为自变量,通过一定的函数关系计算出对应的函数值,把这个数值解释为结点的存储地址,将结点存入计算得到存储地址所对应的存储单元。检索时采用检索关键码的方法。现在哈希表有一套完整的算法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象,实现快速检索。
HashMap和Hashtable的区别:HashMap和Hashtable都实现了Map接口,但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有:线程安全性,同步(synchronization),以及速度。HashMap几乎可以等价于Hashtable,除了HashMap是非synchronized的,并可以接受null(HashMap可以接受为null的键值(key)和值(value),而Hashtable则不行)。
HashMap是非synchronized,而Hashtable是synchronized,这意味着Hashtable是线程安全的,多个线程可以共享一个Hashtable;而如果没有正确的同步的话,多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap,它是HashTable的替代,比HashTable的扩展性更好。另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器,而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构(增加或者移除元素),将会抛出ConcurrentModificationException,但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为,要看JVM。这条同样也是Enumeration和Iterator的区别。由于Hashtable是线程安全的也是synchronized,所以在单线程环境下它比HashMap要慢。如果你不需要同步,只需要单一线程,那么使用HashMap性能要好过Hashtable。HashMap不能保证随着时间的推移Map中的元素次序是不变的。
4、try… catch…的作用是什么?对于catch分支需要注意什么?
try catch用来捕获异常的.try 里面用来放可能出现异常的代码,
catch里面放异常处理代码。如果try 里面的语句出现异常,则执行catch里的语句,否则catch里的语句不执行。
catch语句的参数类似于方法的声明,包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类,它指明了catch语句所处理的例外类型,例外对象则由运行时系统在try所指定的代码块中生成并被捕获,大括号中包含对象的处理,其中可以调用对象的方法。catch语句可以有多个,分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测,直到找到类型相匹配的catch语句为止。这里,类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类,因此,catch语句的排列顺序应该是从特殊到一般。也可以用一个catch语句处理多个例外类型,这时它的例外类型参数应该是这多个例外类型的父类,程序设计中要根据具体的情况来选择catch语句的例外处理类型。
5、什么单例、工厂模式?
概念:
Java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。
单例模式有以下特点:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态,避免政出多头。
概念:
工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。
工厂模式在《Java与模式》中分为三类:
1)简单工厂模式(SimpleFactory):不利于产生系列产品;
2)工厂方法模式(FactoryMethod):又称为多形性工厂;
3)抽象工厂模式(AbstractFactory):又称为工具箱,产生产品族,但不利于产生新的产品;
6、什么是索引?索引有什么作用?
在关系数据库中,是一种单独的、物理的对数据库表中一列或多列的值进行排序的一种存储结构,它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单。
索引的作用提高数据查询的速度。
7、什么是链表(数据结构)?
链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。相比于线性表顺序结构,操作复杂。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
链表主要是便于管理长度或数量不确定的数据,相对于数组,链表处理这种数据时比较节省内存。动态语言通常不大需要链表,因为动态语言的解释器帮你管理内存,但当你对空间效率或插入动作的效率有特殊要求时也可在动态语言中使用链表。
8、什么是二分查找?写一个demo。
二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。
public static int sort(int []array,inta,int lo,int hi){
if(lo<=hi){
int mid=(lo+hi)/2;
if(a==array[mid]){
return mid+1;
}
else if(a>array[mid]){
return sort(array,a,mid+1,hi);
}else{
return sort(array,a,lo,mid-1);
}
}
return -1;
}
9、二叉树?
二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式,即使是一般的树也能简单地转换为二叉树,而且二叉树的存储结构及其算法都较为简单,因此二叉树显得特别重要。
二叉树(BinaryTree)是n(n≥0)个结点的有限集,它或者是空集(n=0),或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。
这个定义是递归的。由于左、右子树也是二叉树,因此子树也可为空树。下图中展现了五种不同基本形态的二叉树。
package study_02.datastructure.tree;
import java.util.Stack;
/**
* 二叉树的链式存储
*@author WWX
*/
public class BinaryTree {
privateTreeNode root=null;
publicBinaryTree(){
root=newTreeNode(1,"rootNode(A)");
}
/**
* 创建一棵二叉树
* <pre>
* A
* B C
* D E F
* </pre>
* @param root
* @author WWX
*/
publicvoid createBinTree(TreeNode root){
TreeNodenewNodeB = new TreeNode(2,"B");
TreeNode newNodeC = new TreeNode(3,"C");
TreeNode newNodeD = new TreeNode(4,"D");
TreeNode newNodeE = new TreeNode(5,"E");
TreeNode newNodeF = new TreeNode(6,"F");
root.leftChild=newNodeB;
root.rightChild=newNodeC;
root.leftChild.leftChild=newNodeD;
root.leftChild.rightChild=newNodeE;
root.rightChild.rightChild=newNodeF;
}
publicboolean isEmpty(){
returnroot==null;
}
//树的高度
publicint height(){
returnheight(root);
}
//节点个数
publicint size(){
returnsize(root);
}
privateint height(TreeNode subTree){
if(subTree==null)
return0;//递归结束:空树高度为0
else{
inti=height(subTree.leftChild);
intj=height(subTree.rightChild);
return(i<j)?(j+1):(i+1);
}
}
privateint size(TreeNode subTree){
if(subTree==null){
return0;
}else{
return1+size(subTree.leftChild)
+size(subTree.rightChild);
}
}
//返回双亲结点
publicTreeNode parent(TreeNode element){
return(root==null|| root==element)?null:parent(root, element);
}
publicTreeNode parent(TreeNode subTree,TreeNode element){
if(subTree==null)
returnnull;
if(subTree.leftChild==element||subTree.rightChild==element)
//返回父结点地址
returnsubTree;
TreeNodep;
//现在左子树中找,如果左子树中没有找到,才到右子树去找
if((p=parent(subTree.leftChild,element))!=null)
//递归在左子树中搜索
returnp;
else
//递归在右子树中搜索
returnparent(subTree.rightChild, element);
}
publicTreeNode getLeftChildNode(TreeNode element){
return(element!=null)?element.leftChild:null;
}
publicTreeNode getRightChildNode(TreeNode element){
return(element!=null)?element.rightChild:null;
}
publicTreeNode getRoot(){
returnroot;
}
//在释放某个结点时,该结点的左右子树都已经释放,
//所以应该采用后续遍历,当访问某个结点时将该结点的存储空间释放
publicvoid destroy(TreeNode subTree){
//删除根为subTree的子树
if(subTree!=null){
//删除左子树
destroy(subTree.leftChild);
//删除右子树
destroy(subTree.rightChild);
//删除根结点
subTree=null;
}
}
publicvoid traverse(TreeNode subTree){
System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
traverse(subTree.leftChild);
traverse(subTree.rightChild);
}
//前序遍历
publicvoid preOrder(TreeNode subTree){
if(subTree!=null){
visted(subTree);
preOrder(subTree.leftChild);
preOrder(subTree.rightChild);
}
}
//中序遍历
publicvoid inOrder(TreeNode subTree){
if(subTree!=null){
inOrder(subTree.leftChild);
visted(subTree);
inOrder(subTree.rightChild);
}
}
//后续遍历
publicvoid postOrder(TreeNode subTree) {
if(subTree != null) {
postOrder(subTree.leftChild);
postOrder(subTree.rightChild);
visted(subTree);
}
}
//前序遍历的非递归实现
publicvoid nonRecPreOrder(TreeNode p){
Stack<TreeNode>stack=new Stack<TreeNode>();
TreeNodenode=p;
while(node!=null||stack.size()>0){
while(node!=null){
visted(node);
stack.push(node);
node=node.leftChild;
}
<spanabp="507"style="font-size:14px;">while</span>(stack.size()>0){
node=stack.pop();
node=node.rightChild;
}
}
}
//中序遍历的非递归实现
publicvoid nonRecInOrder(TreeNode p){
Stack<TreeNode>stack =new Stack<BinaryTree.TreeNode>();
TreeNodenode =p;
while(node!=null||stack.size()>0){
//存在左子树
while(node!=null){
stack.push(node);
node=node.leftChild;
}
//栈非空
if(stack.size()>0){
node=stack.pop();
visted(node);
node=node.rightChild;
}
}
}
//后序遍历的非递归实现
publicvoid noRecPostOrder(TreeNode p){
Stack<TreeNode>stack=new Stack<BinaryTree.TreeNode>();
TreeNodenode =p;
while(p!=null){
//左子树入栈
for(;p.leftChild!=null;p=p.leftChild){
stack.push(p);
}
//当前结点无右子树或右子树已经输出
while(p!=null&&(p.rightChild==null||p.rightChild==node)){
visted(p);
//纪录上一个已输出结点
node=p;
if(stack.empty())
return;
p=stack.pop();
}
//处理右子树
stack.push(p);
p=p.rightChild;
}
}
publicvoid visted(TreeNode subTree){
subTree.isVisted=true;
System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
}
/**
* 二叉树的节点数据结构
* @author GYC
*/
privateclass TreeNode{
privateint key=0;
privateString data=null;
privateboolean isVisted=false;
privateTreeNode leftChild=null;
privateTreeNode rightChild=null;
publicTreeNode(){}
/**
* @param key 层序编码
* @param data 数据域
*/
publicTreeNode(int key,String data){
this.key=key;
this.data=data;
this.leftChild=null;
this.rightChild=null;
}
}
//测试
publicstatic void main(String[] args) {
BinaryTree bt = new BinaryTree();
bt.createBinTree(bt.root);
System.out.println("the size of the tree is " + bt.size());
System.out.println("the height of the tree is " +bt.height());
System.out.println("*******(前序遍历)[ABDECF]遍历*****************");
bt.preOrder(bt.root);
System.out.println("*******(中序遍历)[DBEACF]遍历*****************");
bt.inOrder(bt.root);
System.out.println("*******(后序遍历)[DEBFCA]遍历*****************");
bt.postOrder(bt.root);
System.out.println("***非递归实现****(前序遍历)[ABDECF]遍历*****************");
bt.nonRecPreOrder(bt.root);
System.out.println("***非递归实现****(中序遍历)[DBEACF]遍历*****************");
bt.nonRecInOrder(bt.root);
System.out.println("***非递归实现****(后序遍历)[DEBFCA]遍历*****************");
bt.noRecPostOrder(bt.root);
}
}
10、接口和抽象类的区别?
抽象类和接口都不能直接实例化,如果要实例化,抽象类变量必须指向实现所有抽象方法的子类对象,接口变量必须指向实现所有接口方法的类对象。
抽象类要被子类继承,接口要被类实现。
接口只能做方法申明,抽象类中可以做方法申明,也可以做方法实现
接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量。
抽象类里的抽象方法必须全部被子类所实现,如果子类不能全部实现父类抽象方法,那么该子类只能是抽象类。同样,一个实现接口的时候,如不能全部实现接口方法,那么该类也只能为抽象类。
抽象方法只能申明,不能实现,接口是设计的结果,抽象类是重构的结果
抽象类里可以没有抽象方法
如果一个类里有抽象方法,那么这个类只能是抽象类
抽象方法要被实现,所以不能是静态的,也不能是私有的。
接口可继承接口,并可多继承接口,但类只能单根继承。
11、什么RuntimeException?并举例。
运行异常
NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常
12、final修饰类,方法,变量。
final修饰一个类时,表明这个类不能被继承。也就是说,如果一个类你永远不会让他被继承,就可以用final进行修饰。final类中的成员变量可以根据需要设为final,但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
修饰方法的原因有两个。第一个原因是把方法锁定,以防任何继承类修改它的含义;第二个原因是效率。
修饰变量,该变量设为常量不可更改。
13、封装、继承、多态、抽象?
封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节,对于数据访问只能通过已定义的接口。
继承:是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。Java不支持多继承。
多态:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)。
抽象:抽象就是提取,提取一类事物的共同特征.方便用JAVA语言来定义类
14、重写,重载区别?
(1)方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。
(2) Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具
有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型
来决定具体使用哪个方法, 这就是多态性。
(3) 重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
15、堆和栈?
堆:(对象)
引用类型的变量,其内存分配在堆上或者常量池(字符串常量、基本数据类型常量),需要通过new等方式来创建。堆内存主要作用是存放运行时创建(new)的对象
栈:(基本数据类型变量、对象的引用变量)
基本数据类型的变量(int、short、long、byte、float、double、boolean、char等)以及对象的引用变量,其内存分配在栈上,变量出了作用域就会自动释放。栈内存的主要作用是存放基本数据类型和引用变量。栈的内存管理是通过栈的"后进先出"模式来实现的。
例题:一个栈的输入顺序是a,b,c,d,e则下列序列中不可能是出栈顺序是()
A:e,d,a,c,b
B:a,e,d,c,b
C:b,c,d,a,e
D:b,c,a,d,e
选择:A
先从B开始解释,B中,由于输入顺序是a,b,c,d,e所以,B中可以栈先输入a然后a出,然后输入b,c,d,e那么上述出栈顺序就是e,d,c,b;
C中栈先输如a,b,c则此时c出,b出.这时候d输入,那么a先进所以a后处,此时d出然后a出,最后e进e出.
D中栈先输入a,b则输出可以是b先出,c近c出,然后是a出,d近d出,最后才是e出.
A中应该是a,b,c,d,e一起输入,此时e出,d出,a不可能比c先出所以这个错了.正确的出栈顺序应该是e,d,c,b,a.
当然出栈顺序也可以是a,b,c,d,e这时候是进去一个出栈一个.a进a出,b进b出,c进c出,d进d出,e进e出,所以最后顺序就是a,b,c,d,e.
16、java中 "==" 和 ".equels"的区别?
object类的equels方法就是比较他们的值是否相等
而逻辑运算符==是将两个变量的内存地址进行比较
java中equals和==的区别 值类型是存储在内存中的堆栈(简称栈),而引用类型的变量在栈中仅仅是存储引用类型变量的地址,而其本身则存储在堆中。
==操作比较的是两个变量的值是否相等,对于引用型变量表示的是两个变量在堆中存储的地址是否相同,即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用,即堆中的内容是否相同。
==比较的是2个对象的地址,而equals比较的是2个对象的内容,显然,当equals为true时,==不一定为true。
17、如何将两个list合并?
addAll()方法
遍历赋值
(以上是个人参加技术面试的总结,搞不懂为何南京这边追求这种虚伪缥缈的东西,难道是被培训机构坑害的?)