JAVA基础.docx
《JAVA基础.docx》由会员分享，可在线阅读，更多相关《JAVA基础.docx（25页珍藏版）》请在冰豆网上搜索。
JAVA基础
java的基本包
java.lang其中包含有：
接口：
Comparable、Cloneable、Runable等
类：
八个基本数据类型封装类、Math、Runtime、Object、String、StringBuffer、Thread、Exception等
ArrayList和Vector的区别,HashMap和Hashtable的区别
答：
就ArrayList与Vector主要从二方面来说.
一.同步性:
Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:
当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
java.lang其中包含有：
接口：
Comparable、Cloneable、Runable等
类：
八个基本数据类型封装类、Math、Runtime、Object、String、StringBuffer、Thread、Exception等
ArrayList和Vector的区别,HashMap和Hashtable的区别
答：
就ArrayList与Vector主要从二方面来说.
一.同步性:
Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:
当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半ArrayList,Vector,LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
就HashMap与HashTable主要从三方面来说.
一.历史原因:
Hashtable是基于陈旧的Dictionary类的，HashMap是Java1.2引进的Map接口的一实现
二.同步性:
Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：
只有HashMap允许在一个集合中有一个null键和在一个集合中有多个null值
Hashtable是HashMap的同步版本；HashMap允许有null值和一个null键，但是，Hashtable不允许有任何内容为nullHashtable类的对象必须覆盖Object类的hashCode（）和equals（）方法关于其他集合类型：
一.ArrayList提供快速遍历和快速访问。
现在设计了新的RandomAccess接口，它指出这种列表支持快速随机访问。
Vector也实现了RandomAccess接口。
二.遍历HashSet与HashMap时，其顺序是未知的（但添加删除快）。
LinkedHashSet和LinkedHashSet是按照元素的插入的顺序遍历的（遍历快）。
三．TreeSet和TreeMap将保证元素按照元素的自然顺序进行排列。
也可以使用一个用户自己实现的比较规则。
四、HashSet有一个散列表支持它。
它为基本操作提供固定时间性能。
TreeSet它确保了排序集将按元素升序，根据自然顺序排序。
Dictionary类
主要用于将关键字转换成值，该类接收一个关键字并返回一个值。
Dictionary是一个抽象类，它是H
Hashtable的超类。
Properties类
扩展了Hashtable类，但Properties对象的关键字和值必须是String类型，并能将对象写入一个输出流并保存在一个文件中，然后可以把它读回一个输入流。
如果需要维护和搜索一个部件列表，它们由唯一的字母数字序列号标示，其中的部件是Part类型，这时应该使用哪种集合？
如果我们改变需求，你也需要能够按顺序、按它们的序列号打印出部件？
1、应该选择HashMap
2、应该选择TreeMap
多线程有几种实现方法,都是什么?
同步有几种实现方法,都是什么?
答：
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
抽象类与接口？
答：
抽象类与接口都用于抽象，但是抽象类（JAVA中）可以有自己的部分实现，而接口则完全是一个标识（同时有多重继承的功能）。
abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能接口是否可继承接口?
抽象类是否可实现（implements）接口?
抽象类是否可继承实体类（concreteclass）?
接口可以继承接口。
抽象类可以实现（implements）接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。
AnonymousInnerClass（匿名内部类）是否可以extends（继承）其它类，是否可以implements（实现）interface（接口）?
可以继承其他类或完成其他接口，在swing编程中常用此方式。
IO流
字节流：
数据在存储时与传输时都是以字节为单位进行的。
通常用于读写二进制数据，如图像和声音文件。
字符流：
数据在存储与传输时都是以字符为单位进行的。
流：
对数据源的一种抽象，其目的是想用统一的方式访问各种不同的数据源（文件、网络、内存的缓冲区）文件读写的基本类：
File类提供定位本地文件系统，描述文件和目录的功能。
管道流用于在线程之间通信：
PipedInputStream、PipedOutputStream、PipedReader、PipedWriter
线程1àPipedOutputStreamàPipedInputStreamà线程2
键盘输入：
try{
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
Strings=br.readLine（）;
System.out.println（s）;
}catch（Exceptione）{
}
文件输入输出：
try{
Filef=newFile（"test.txt"）;
FileOutputStreamfout=newFileOutputStream（f）;
fout.write（System.in.read（））;
fout.close（）;
FileInputStreamfin=newFileInputStream（f）;
intsize=fin.available（）;
for（inti=0;i System.out.print（（char）fin.read（））;
}
fin.close（）;
}catch（Exceptione）{
}
通过网络传输文件：
客户端：
Filef=newFile（"bk.exe"）;
FileInputStreamfin=newFileInputStream（f）;
Socketst=newSocket（"localhost",6000）;
BufferedOutputStreambout=newBufferedOutputStream（st.getOutputStream（））;
intsize=fin.available（）;
for（inti=0;i bout.write（fin.read（））;
}
服务器端：
ServerSocketserver=newServerSocket（6000）;
Socketst=server.accept（）;
Filef=newFile（"kk.exe"）;
BufferedInputStreambin=newBufferedInputStream（st.getInputStream（））;
FileOutputStreamfout=newFileOutputStream（f）;
inti=0;
while（i!
=-1）{
i=bin.read（）;
fout.write（i）;
}
串行化的注意事项以及如何实现串行化
对象的寿命通常随着生成该对象的程序的终止而终止。
有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。
我们把对象的这种能记录自己的状态以便将来再生的能力，叫做对象的持续性（persistence）。
对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化（serialization）。
序列化的过程就是对象写入字节流和从字节流中读取对象。
将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。
一：
对象序列化可以实现分布式对象。
二：
java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。
串行化的注意事项以及如何实现串行化
对象的寿命通常随着生成该对象的程序的终止而终止。
有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。
我们把对象的这种能记录自己的状态以便将来再生的能力，叫做对象的持续性（persistence）。
对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化（serialization）。
序列化的过程就是对象写入字节流和从字节流中读取对象。
将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。
一：
对象序列化可以实现分布式对象。
二：
java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。
常见排序法：
publicclassSort{
publicstaticintcount=0;
publicbooleanLT（intnum1,intnum2）{
returnnum1 }
publicvoidoutput（int[]array）{
System.out.print（"第"+count+"次排序：
"）;
for（inti=0;i System.out.print（array[i]+""）;
System.out.println（）;
}
//冒泡排序法
publicvoidBubbleSort（int[]array）{
booleanswap=true;
intindex=0;
inti=0;
while（i inttemp=array[i];
for（intj=i;j if（!
LT（array[i],array[j]））{
inttemp2=array[i];
array[i]=array[j];
array[j]=temp2;
swap=true;
index=j;
}else{
swap=false;
}
}
i++;
if（swap）{
array[i]=array[index];
array[index]=temp;
i++;
}
output（array）;
}
}
//直接插入排序法
publicvoidInsertSort（int[]array）{
for（inti=1;i if（LT（array[i],array[i-1]））{
inttemp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
for（intj=i-1;j>0;--j）{
if（LT（array[j],array[j-1]））{
array[j]=array[j-1];
array[j-1]=temp;
}else{
break;
}
}
output（array）;
}
}
}直接插入排序法
publicvoidInsertSort（int[]array）{
for（inti=1;i if（LT（array[i],array[i-1]））{
inttemp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
for（intj=i-1;j>0;--j）{
if（LT（array[j],array[j-1]））{
array[j]=array[j-1];
array[j-1]=temp;
}else{
break;
}
}
output（array）;
}
}
}//快速排序法
privateintPartition（intarray[],intlow,inthigh）{
inttemp=array[low];
intpivotkey=array[low];
while（low while（lowpivotkey）--high;
array[low]=array[high];
while（low array[high]=array[low];
}
array[low]=temp;
output（array）;
returnlow;
}快速排序法
privateintPartition（intarray[],intlow,inthigh）{
inttemp=array[low];
intpivotkey=array[low];
while（low while（lowpivotkey）--high;
array[low]=array[high];
while（low array[high]=array[low];
}
array[low]=temp;
output（array）;
returnlow;
}publicvoidqsort（intarray[],intlow,inthigh）{
if（low intpivotloc=Partition（array,low,high）;
QSort（array,low,pivotloc-1）;
QSort（array,pivotloc+1,high）;
}
}qsort（intarray[],intlow,inthigh）{
if（low intpivotloc=Partition（array,low,high）;
QSort（array,low,pivotloc-1）;
QSort（array,pivotloc+1,high）;
}
}voidQuickSort（intarray[]）{
QSort（array,0,array.length-1）;
}
publicstaticvoidmain（Stringargs[]）{
intarray[]={49,38,65,97,76,13,27,49};
Sortsort=newSort（）;
System.out.println（"==================================="）;
sort.output（array）;
System.out.println（"优化冒泡排序法"）;
sort.BubbleSort（array）;
System.out.println（）;
System.out.println（"==================================="）;
array=newint[]{49,38,65,97,76,13,27,49};
sort.output（array）;
System.out.println（"直接插入排序法"）;
sort.InsertSort（array）;
插入排序法"）;
sort.InsertSort（array）;System.out.println（）;
System.out.println（"==================================="）;
array=newint[]{49,38,65,97,76,13,27,49};
sort.output（array）;
System.out.println（"快速排序法"）;
sort.QuickSort（array）;
}
}
如在COLLECTION框架中，实现比较要实现什么样的接口？
Collection框架中实现比较要实现Comparable接口和Comparator接口
什么是线程？
线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。
所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程（light-weightprocess）。
一个进程中可以包含多个线程。
一个线程是一个程序内部的顺序控制流。
1.进程：
每个进程都有独立的代码和数据空间（进程上下文），进程切换的开销大。
2.线程：
轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
3.多进程：
在操作系统中，能同时运行多个任务程序。
4.多线程：
在同一应用程序中，有多个顺序流同时执行。
进程上下文），进程切换的开销大。
2.线程：
轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
3.多进程：
在操作系统中，能同时运行多个任务程序。
4.多线程：
在同一应用程序中，有多个顺序流同时执行。
同步和异步有和异同，在什么情况下分别使用他们？
临界资源问题
线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。
但是经常有一些同时运行的线程需要共享数据，此时就需考虑其他线程的状态和行为，否则就不能保证程序的运行结果的正确性。
我们需要做的是允许一个线程彻底完成其任务后，再允许下一个线程执行。
必须保证一个共享的资源一次只能被一个线程使用。
实现此目的的过程称为同步。
同步是用于确保资源一次只能被一个线程使用的过程。
同步对于单线程程序没有任何好处。
使用同步比非同步的性能差三到四倍。
临界资源问题
线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。
但是经常有一些同时运行的线程需要共享数据，此时就需考虑其他线程的状态和行为，否则就不能保证程序的运行结果的正确性。
我们需要做的是允许一个线程彻底完成其任务后，再允许下一个线程执行。
必须保证一个共享的资源一次只能被一个线程使用。
实现此目的的过程称为同步。
同步是用于确保资源一次只能被一个线程使用的过程。
同步对于单线程程序没有任何好处。
使用同步比非同步的性能差三到四倍。
线程方法介绍：
构造函数：
Thread（）
Thread（Runabletarget）
Thread（Runabletarget，Stringname）
Thread（ThreadGroupgroup,Runabletarget）
Thread（ThreadGroupgroup,Runabletarget,Stringname）
Thread（ThreadGroupgroup,Stringname）
用于完成一个线程“实际功能”的代码放在run方法中。
Run方法可以在Thread的子类中重写，也可以在Runable对象中重写。
一旦线程死去，它就永远不能再重新启动，否则会抛出异常。
用start方法启动一个已经启动的线程也会抛出异常。
isAlive、interrupt、Thread.currentThread、suspend、resume、stopSleep方法可以使低优先级的线程得到执行的机会，Yield方法只能使同优先级的线程有执行的机会。
Join方法能够使调用该方法的线程在此之前执行完毕，在该方法之后，调用join方法的线程不会产生输出了，Wait与notify使用时，需要注意的事项？
它们只能用于synchronized同步块中；
它们需要配对使用；
Wait一般出现在一个while循环中，while语句使用一个boolean标志控制。
死锁
当被锁定的A对象试图访问另一个被锁定的B对象，B对象同时又要访问已被锁定的A对象。
这样导致两个线程都在等待另一个线程释放资源，这样就出现了死锁。
STRING与STRINGBUFFER的区别。
答：
STRING的长度是不可变的，STRINGBUFFER的长度是可变的。
如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toSt
升级会员 