笔试总结Word下载.docx

笔试总结Word下载.docx

《笔试总结Word下载.docx》由会员分享，可在线阅读，更多相关《笔试总结Word下载.docx（27页珍藏版）》请在冰豆网上搜索。

successful"

outStream.close（）;

}catch（FileNotFoundExceptione）{

e.printStackTrace（）;

}catch（IOExceptione）{

}}

javaMap遍历速度最优解

第一种:

Mapmap=newHashMap（）;

Iteratoriter=map.entrySet（）.iterator（）;

while（iter.hasNext（））{ 

Map.Entryentry=（Map.Entry）iter.next（）;

Objectkey=entry.getKey（）;

Objectval=entry.getValue（）;

} 

效率高,以后一定要使用此种方式！

第二种:

Iteratoriter=map.keySet（）.iterator（）;

Objectkey=iter.next（）;

Objectval=map.get（key）;

效率低,以后尽量少使用！

HashMap的遍历有两种常用的方法，那就是使用keyset及entryset来进行遍历，但两者的遍历速度是有差别的，对于keySet其实是遍历了2次，一次是转为iterator，一次就从hashmap中取出key所对于的value。

而entryset只是遍历了第一次，他把key和value都放到了entry中，所以就快了。

注:

Hashtable的遍历方法和以上的差不多！

如果要保持HashMap的遍历顺序和原插入顺序一致，可以使用LinkedHashMap，使用方法和HashMap一样，改一下声明即可：

LinkedHashMapmyMap=newLinkedHashMap（）;

当然需要导入：

java.util.LinkedHashMap

软件的维护活动可以分为改正性维护、适应性维护、完善性维护和预防性维护四类，其中完善性维护是软件维护工作的主要部分;

线程：

java.lang.Thread实现了Thread接口

1、程序：

指令集，静态概念

2、进程：

操作系统调度程序，动态概念

3、线程：

在进程内多条执行路径——虚拟多线程：

根据调度算法执行（不同线程间的切换）——真实多线程：

多个CPU的实现多个线程eg：

main方法和gc的关系，和异常的关系；

也称为轻量级的进程；

一个进程的线程共享相同的内存单元，内存地址空间——》可以访问相同的变量和对象，而且他们从同一堆中分配对象——》通信，数据交换，同步操作

由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信机制，这就使得通信更加简单而且信息的传递速度也更快；

区别：

进程：

创建进程：

1.模拟龟头赛跑：

a、创建线程：

继承Thread类和实现run方法；

b、调用线程：

创建线程对象，调用其start方法；

publicclassRabbitextendsTread{

publicvoidrun（）{

for（inti=0;

i<

100;

i++）

System.out.print（"

兔子跑了"

+i+"

步"

}

publicstaticvoidmain（String[]args）{

创建子类对象

Rabbitrabbit=newRabbit（）;

Touzitouzi=newTouzi（）;

rabbit.start（）;

touzi.start（）;

//不能使用run方法，否则会作为一个普通的方法进行执行，即一个执行完后执行另一个 

使用Runable创建线程

1、实现Runable接口+重写run方法

2、启动多线程，使用静态代理

1）、创建真实角色：

Aa=newA（）;

2）、创建代理角色+真实角色的引用:

Threadproxy=newThread（a）;

3）、调用.start方法:

proxy.start（）;

优点：

1、方便共享资源

第三种创建线程方法：

实现util.concurrent下的callable接口

可以抛异常（run方法不能抛异常,只能有运行时异常）；

执行完任务后可以有返回值；

缺点：

繁琐

思路：

1）、 

创建callable实现类和重写call方法

2）、借助执行调度服务ExecutorService获取Future对象

ExecutorServiceser=Executors.newFixedThreadPool

（2）;

Futureresult=ser.submit（实现类对象）

3）、获取值result.get（）;

4）、停止服务ser.shutdownNow（）||ser.shutdown（）;

线程的状态：

停止线程方法：

1、调用终止线程方法

2、线程体里面设置标志，eg：

while（flag）时再执行软方法；

优先级（priority）：

MAX_PRIOPRITY10;

NORM_PRIOPRITY5;

MIN_PRIOPRITY1;

——Thread类的静态变量

设置方法：

setPrioprity（Thread.MAX_PRIOPRITY）;

//代表的是概率没有绝对的先后顺序

.setName（线程名称）;

给线程起名字；

getName（）;

获取线程的名称;

currentThread（）;

获取当前运行的线程，也就是线程本身

线程的同步和并发：

定义：

多个线程管理同一个对象——确保资源的安全性Synchronized：

速度变慢了

方法1）、同步方法：

publicstatic 

synchronizedvoidgetNum（）;

方法2）、同步语句块：

synchronized（this|静态类.class）{};

——注意锁定的范围大小，不能锁定资源对象的一部分内容

难点：

范围大小的选择 

死锁：

只有在线程同步中抢夺资源才会造成死锁（概率事件）；

解决死锁：

生产者消费者模式

1、管城控制；

一个容器控制

2、标志位法：

object的wait和notify方法+synchronized一起使用

任务调度：

timer类——util.Timer类

IO流:

IO流的三种分类方式

1.按流的方向分为：

输入流和输出流 

2.按流的数据单位不同分为：

字节流和字符流 

3.按流的功能不同分为：

节点流和处理流（节点流表示的是直接操作节点（例如文件，键盘）的流，例如FileInputStream.

处理流（过滤流）表示的是对节点流进行了操作（加工）的类，例如InputStreamReader）

IO流的四大抽象类

字符流：

Reader（读） 

Writer（写） 

字节流：

InputStream（读数据） 

OutputStream（写数据）

IO体系，所具备的基本功能就有两个：

读和写

1，字节流

InputStream（读）,OutputStream（写）

2,字符流

Reader（读）,Writer（写） 

结论：

只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。

缓冲流：

缓冲流要套接在相应的节点流之上，提高了读写的效率。

此处理流的构造方法都得传相对应的基类类型

BufferedReader：

提供了readLine方法用于高校读取一行字符串

BufferedWriter：

提供了newLine用于写入一个行分隔符也就是换行

BufferedInputStream 

没多大用处

BufferedOutputStream 

转换流：

主要作用将字节流转换成字符流。

用处较大！

转换流在构造时可以指定其编码集合

InputStreamReader需要和InputStream套接

OutputStreamWriter需要和OutputStream套接

例：

OutputStreamWriterosw=newOutputStreamWriter 

（newFileOutputStream（文件路径）；

方法例：

osw.getEncoding（）；

获得流的编码方式

数据流与字节数组流

数据流主要为实现可以存取Java原始数据类型如long，boolean

数据流是字节流

DataInputStream需要和InputStream套接

DataOutputStream需要和OutputStream套接

DataInputStream方法：

readBoolean（） 

readInt（）…

readUTF（）：

网络传输常用方法 

读一个Unicode字符串

DataOutputStream方法与DataInputStream基本对应为写的方法

//此构造函数等于已可以往一个字节数组里输入内容

ByteArrayOutputStreambaos=newByteArrayOutputStream 

（）；

//此方法为获取一个字节数组方法返回字节数组

baos.toByteArray（）；

//此方法获取字节数组占了多少字节

newByteArrayInputStream（一个字节数组）。

available（）

ByteArrayOutputStreambaos=newByteArrayOutputStream（）;

DataOutputStreamdos=newDataOutputStream（baos）;

publicvoidcountCharacter（）throwsIOException{

FilefileSrc=newFile（dir,"

file01.txt"

BufferedReaderfin=newBufferedReader（newFileReader（fileSrc））;

Stringline;

while（ 

（line=fin.readLine（））!

=null）{

Map<

Character,Integer>

counter=newHashMap<

（）;

intlen=line.length（）;

for（inti=0;

i<

len;

i++）{

charc=line.charAt（i）;

if（!

（（c>

='

0'

&

&

c<

9'

）||（c>

A'

Z'

a'

z'

）））{

continue;

if（counter.containsKey（c））{

counter.put（c,counter.get（c）+1）;

}else{

counter.put（c,1）;

for（Iterator<

Character>

it=counter.keySet（）.iterator（）;

it.hasNext（）;

）{

charkey=it.next（）;

intcount=counter.get（key）;

System.out.println（key+"

---"

+count）;

fin.close（）;

publicvoidcopy（）throwsIOException{

BufferedReaderbi=newBufferedReader（newFileReader（"

d:

/fileTest/file01.txt"

））;

Filedir=newFile（"

/fileTest/"

if（!

dir.exists（））{

dir.mkdir（）;

Fileafile=newFile（dir,"

file02.txt"

BufferedWriterbw=newBufferedWriter（newFileWriter（afile））;

Stringline=null;

if（（line=bi.readLine（））!

=null）{

bw.write（line）;

bi.close（）;

bw.close（）;

publicvoidfileOutput（Stringstr）throwsIOException{

Fileafile=null;

dir.mkdirs（）;

afile=newFile（dir,"

fout=newFileOutputStream（afile）;

objOut=newObjectOutputStream（fout）;

objOut.write（str.getBytes（"

utf-8"

））;

objOut.flush（）;

if（objOut!

objOut.close（）;

if（fout!

fout.close（）;

设计模式（解决类和类之间的问题）之静态代理：

1、有真实角色（重写主要的方法）：

eg：

找房子的人、结婚者

2、有代理角色（持有真实对象的引用（可以通过构造器调用此方法），写次要的方法）：

中介、婚庆公司

3、二者实现相同的接口

设计模式之单例模式——确保类只有一个对象

异常处理：

出现原因：

处理程序本身不需要考虑的问题，将和程序本身不需要考虑的问题交给一场机制处理；

抛出异常：

在执行一个方法中，出此案异常时则这个方法就生成一个代表该异常对象，停止当前的执行路径，并将异常对象提交给JRE；

捕获异常：

jre得到该异常后，寻找相应的代码来处理异常，jre在方法的调用栈中查找，从生成异常的方法中回朔，知道找到异常处理的代码为止；

error：

解决方法：

唯一的方法：

重新启动；

unCheckExceptioneg:

inti=1/0;

非捕获异常——runtimeException

checkedException被编译器检查的异常；

捕获异常try...catch（exceptione）....finally..

异常处理方式1）、手动处理2）、声明异常；

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；

如果你用System.out.println（11/0），那么你是因为你用0做了除数，会抛出java.lang.ArithmeticException的异常。

Java中的异常用对象来表示。

Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。

异常类从哪里来？

有两个来源，一是基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。

异常的对象从哪里来呢？

有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！

比如除数为0的异常。

二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。

异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。

Java异常处理的目的是提高程序的健壮性，你可以在catch和finally代码块中给程序一个修正机会，使得程序不因异常而终止或者流程发生以外的改变。

同时，通过获取Java异常信息，也为程序的开发维护提供了方便，一般通过异常信息就很快就能找到出现异常的问题（代码）所在。

Java异常处理是Java语言的一大特色，也是个难点，掌握异常处理可以让写的代码更健壮和易于维护。

二、Java异常类类图

下面是这几个类的层次图：

java.lang.Object

java.lang.Throwable

java.lang.Exception

java.lang.RuntimeException

java.lang.Error

java.lang.ThreadDeath 

1、Throwable

Throwable类是Java语言中所有错误或异常的超类。

只有当对象是此类（或其子类之一）的实例时，才能通过Java虚拟机或者Javathrow语句抛出。

类似地，只有此类或其子类之一才可以是catch子句中的参数类型。

两个子类的实例，Error和Exception，通常用于指示发生了异常情况。

通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。

三、Java异常处理机制

对于可能出现异常的代码，有两种处理办法：

第一、在方法中用try...catch语句捕获并处理异常，catach语句可以有多个，用来匹配多个异常。

第二、对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常。

如果每个方法都是简单的抛出异常，那么在方法调用方法的多层嵌套调用中，Java虚拟机会从出现异常的方法代码块中往回找，直到找到处理该异常的代码块为止。

然后将异常交给相应的catch语句处理。

如果Java虚拟机追溯到方法调用栈最底部main（）方法时，如果仍然没有找到处理异常的代码块，将按照下面的步骤处理：

第一、调用异常的对象的printStackTrace（）方法，打印方法调用栈的异常信息。

第二、如果出现异常的线程为主线程，则整个程序运行终止；

如果非主线程，则终止该线程，其他线程继续运行。

通过分析思考可以看出，越早处理异常消耗的资源和时间越小，产生影响的范围也越小。

因此，不要把自己能处理的异常也抛给调用者。

还有一点，不可忽视：

finally语句在任何情况下都必须执行的代码，这样可以保证一些在任何情况下都必须执行代码的可靠性。

比如，在数据库查询异常的时候，应该释放JDBC连接等等。

finally语句先于return语句执行，而不论其先后位置，也不管是否try块出现异常。

finally语句唯一不被执行的情况是方法执行了System.exit（）方法。

System.exit（）的作用是终止当前正在运行的Java虚拟机。

finally语句块中不能通过给变量赋新值来改变return的返回值，也建议不要在finally块中使用return语句，没有意义还容易导致错误。

最后还应该注意一下异常处理的语法规则：

第一、try语句不能单独存在，可以和catch、finally组成try...catch...finally、try...catch、try...finally三种结构， 

第二、try、catch、finally三个代码块中变量的作用域分别独立而不能相