点关注,不迷路;持续更新Java架构相关技术及资讯热文!!!
答:Java 通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。在Java 中,每个异常都是一个对象,它是Throwable 类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并进行处理。Java 的异常处理是通过5 个关键词来实现的:try、catch、throw、throws 和finally。一般情况下是用try 来执行一段程序,如果出现异常,系统会抛出(throws)一个异常,这时候你可以通过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器来处理;try 用来指定一块预防所有“异常”的程序;catch 子句紧跟在try 块后面,用来指定你想要捕捉的“异常”的类型;throw 语句用来明确地抛出一个“异常”;throws 用来标明一个成员函数可能抛出的各种“异常”;Finally 为确保一段代码不管发生什么“异常”都被执行的一段代码;可以在一个成员函数调用的外面写一个try 语句,在这个成员函数内部写另一个try 语句保护其他代码。每当遇到一个try 语句,“异常”的框架就放到堆栈上面,直到所有的try 语句都完成。如果下一级的try 语句没有对某种“异常”进行处理,堆栈就会展开,直到遇到有处理这种“异常”的try 语句。
答:异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误。java 编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。
答:ArithmeticException
, ArrayStoreException
, BufferOverflowException
,
BufferUnderflowException
, CannotRedoException
, CannotUndoException
,
ClassCastException
, CMMException
, ConcurrentModificationException
,
DOMException
,EmptyStackException
,IllegalArgumentException
,
IllegalMonitorStateException
,IllegalPathStateException
,
IllegalStateException
, ImagingOpException
, IndexOutOfBoundsException,
MissingResourceException
, NegativeArraySizeException
,
NoSuchElementException
, NullPointerException
, ProfileDataException
,
ProviderException
,RasterFormatException
,SecurityException
,
SystemException
, UndeclaredThrowableException
,
UnmodifiableSetException
, UnsupportedOperationException
答:
有如下代码片断:
try{
throw new ExampleB(“b”);
}
catch(ExampleA e){
System.out.printfln(“ExampleA”);
}
catch(Exception e){
System.out.printfln(“Exception”);
}
输出的内容应该是:
A:ExampleA B:Exception C:b D:无
答:输出为A。
答:Collection FrameWork 如下:
Collection 是最基本的集合接口,一个Collection 代表一组Object,即Collection 的元素(Elements); Map 提供key 到value 的映射。
Collection 和 Collections的区别
答:最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和Vector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对(称作“键”和“值”),其中每个键映射到一个值。
答:ArrayList 和Vector 都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector 由于使用了synchronized 方法(线程安全),通常性能上较ArrayList 差,而LinkedList 使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。
答:Collection 是java.util 下的接口,它是各种集合的父接口,继承于它的接口主要有Set 和List;Collections 是个java.util 下的类,是针对集合的帮助类,提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
答:二者都实现了Map 接口,是将惟一键映射到特定的值上;主要区别在于:
答:就ArrayList 与Vector 主要从二方面来说:
答:List 以特定次序来持有元素,可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value 值,value 可多值。
答:Set 里的元素是不能重复的,用equals ()方法来区分重复与否。覆盖equals()方法用来判断对象的内容是否相同,而”==”判断地址是否相等,用来决定引用值是否指向同一对象。
答:代码如下:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
public class RandomSort {
public static void printRandomBySort() {
Random random = new Random();
// 创建随机数生成器
List<Integer> list = new ArrayList<Integer>();
// 生成10 个随机数,并放在集合list 中
for (int i = 0; i < 10; i++) {
list.add(random.nextint(1000));
}
Collections.sort(list);
// 对集合中的元素进行排序
//第一种输出方法
Iterator<Integer> it = list.iterator();
int count = 0;
while (it.hasNext()) {
// 顺序输出排序后集合中的元素
System.out.println(++count + ": " + it.next());
}
//第二种输出方法
for (Integer integer : list) {
System.out.println(integer);
}
}
public static void main(String[] args) {
printRandomBySort();
}
}
//欢迎加入Java高级架构进阶Qqun:963944895,私聊管理员免费领取Java架构学习视频、Java最新面试题、Java编程书籍
答:用选择排序代码如下:
public class ChooseSort {
private int[] array;
private int length;
public ChooseSort(int[] array) {
this.array = array;
this.length = array.length;
}
/**
* 打印数组中的所有元素
*/
public void display() {
for (int i : array) {
System.out.print(i + " ");
}
System.out.println();
}
/**
* 选择排序算法
*/
public void chooseSort() {
for (int i = 0; i < length - 1; i++) {
// 做第i趟排序
int minIndex = i;
for (int j = minIndex + 1; j < length; j++) {
// 选最小的记录
if (array[minIndex]>array[j]) {
minIndex = j;
// 记下目前找到的最小值所在的位置
}
}
// 在内层循环结束,也就是找到本轮循环的最小的数以后,再进行交换
if (i != minIndex) {
// 交换a[i]和a[minIndex]
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
}
}
public static void main(String[] args) {
int[] array = { 100, 45, 36, 21, 17, 13, 7 };
ChooseSort cs = new ChooseSort(array);
System.out.println("排序前的数据为:");
cs.display();
cs.chooseSort();
System.out.println("排序后的数据为:");
cs.display();
}
}
//欢迎加入Java高级架构进阶Qqun:963944895,私聊管理员免费领取Java架构学习视频、Java最新面试题、Java编程书籍
JAVA 类实现序例化的方法是实现java.io.Serializable 接口;Collection 框架中实现比较要实现Comparable 接口和Comparator 接口。
答:sleep 是线程类(Thread)的方法,使此线程暂停执行并指定时间,把执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用sleep 不会释放对象锁。wait 是Object 类的方法,对对象调用wait 方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify 方法(或notifyAll)后本线程才进入对象锁定池准备,获得对象锁进入运行状态。
答:其它线程只能访问该对象的其它非同步方法,同步方法则不能进入。
答:
答:多线程有两种实现方法,分别是继承Thread 类与实现Runnable 接口,同步的实现方面有两种,分别是synchronized,wait 与notify。
答:如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。
答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时,才开始执行run()方法(如果有的话)。start()是方法,它调用run()方法.而run()方法是你必须重写的. run()方法中包含的是线程的主体。
答:线程指在程序执行过程中,能够执行程序代码的一个执行单位,每个程序至少都有一个线程,也就是程序本身;Java 中的线程有四种状态分别是:运行、就绪、挂起、结束。
答:相同点:Lock 能完成synchronized 所实现的所有功能;
不同点:Lock 有比synchronized 更精确的线程语义和更好的性能。synchronized 会自动释放锁,而Lock 一定要求程序员手工释放,并且必须在finally中释放。
答:有两种实现方法,分别是继承Thread 类与实现Runnable 接口;用synchronized 关键字修饰同步方法;反对使用stop(),是因为它不安全。它会解除由线程获取的所有锁定,而且如果对象处于一种不连贯状态,那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在;suspend()方法容易发生死锁。调用suspend()的时候,目标线程会停下来,但却仍然持有在这之前获得的锁定。此时,其他任何线程都不能访问锁定的资源,除非被“挂起”的线程恢复运行。对任何线程来说,如果它们想恢复目标线程,同时又试图使用任何一个锁定的资源,就会造成死锁。故不应该使用suspend(),而应在自己的Thread 类中置入一个标志,指出线程应该活动还是挂起。若标志指出线程应该挂起,便用wait()命其进入等待状态。若标志指出线程应当恢复,则用一个notify()重新启动线程。
答:以下程序使用内部类实现线程,对j 增减的时候没有考虑顺序问题:
public class TestThread {
private int j;
public TestThread(int j) {
this.j = j;
}
//增加j
private synchronized void inc() {
j++;
System.out.println(j + "--Inc--" + Thread.currentThread().getName());
}
//减少j
private synchronized void dec() {
j--;
System.out.println(j + "--Dec--" + Thread.currentThread().getName());
}
public void run() {
new Dec().start();
new Thread(new Inc()).start();
new Dec().start();
new Thread(new Inc()).start();
}
class Dec extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
dec();
}
}
}
class Inc implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
inc();
}
}
}
public static void main(String[] args) {
new TestThread(5).run();
}
}
答:序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题;序列化的实现:将需要被序列化的类实现Serializable 接口,该接口没有需实现的方法,implements Serializable 只是为了标注该对象是可被序列化的。
答:字节流,字符流。字节流继承于InputStream、OutputStream,字符流继承于Reader、Writer。在java.io 包中还有许多其他的流,主要是为了提高性能和使用方便。
答: 1)示例代码如下:
File file = new File("e:");
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isFile())
System.out.println(files[i]);
}
2)示例代码如下:
File file = new File("e:\");
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory())
System.out.println(files[i]);
}
3)创建File 对象,调用其exsit()方法即可返回是否存在,如:
System.out.println(new File("d:\\t.txt").exists());
4)示例代码如下:
public class Test {
public static void main(String[] args) throws IOException {
// 读文件:
FileInputStream fin = new FileInputStream("e:\tt.txt");
byte[] bs = new byte[100];
while (true) {
int len = fin.read(bs);
if (len <= 0)
break;
System.out.print(new String(bs, 0, len));
}
fin.close();
// 写文件:
FileWriter fw = new FileWriter("e:\test.txt");
//System.getProperty("line.separator")相当于"/n"n’ 这样写的话,剔除了平台无关性
fw.write("hello world!" + System.getProperty("line.separator"));
fw.write("你好!郑州!");
fw.close();
}
}
//欢迎加入Java高级架构进阶Qqun:963944895,私聊管理员免费领取Java架构学习视频、Java最新面试题、Java编程书籍
答:代码如下:
public static int countWords(String file, String find) throws Exception {
int count = 0;
Reader in = new FileReader(file);
int c;
while ((c = in.read()) != -1) {
while (c == find.charAt(0)) {
for (int i = 1; i < find.length(); i++) {
c = in.read();
if (c != find.charAt(i))
break;
if (i == find.length() - 1)
count++;
}
}
}
return count;
}
//欢迎加入Java高级架构进阶Qqun:963944895,私聊管理员免费领取Java架构学习视频、Java最新面试题、Java编程书籍
答:Server 端程序:
import java.net.*;
import java.io.*;
public class Server {
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server() {
try {
//创建 ServerSocket 对象(并绑定端口)
ss = new ServerSocket(10000);
while (true) {
//调用 accept 方法,等待来自客户端的连接
socket = ss.accept();
String RemoteIP = socket.getInetAddress().getHostAddress();
String RemotePort = ":" + socket.getLocalPort();
System.out.println("A client come in!IP:" + RemoteIP + RemotePort);
//调用 getXXXStream 方法,进行 I/O操作
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println("Cleint send is :" + line);
out = new PrintWriter(socket.getOutputStream(), true);
out.println("Your Message Received!");
out.close();
in.close();
//关闭 Socket
socket.close();
}
}
catch (IOException e) {
out.println("wrong");
}
}
public static void main(String[] args) {
new Server();
}
}
//欢迎加入Java高级架构进阶Qqun:963944895,私聊管理员免费领取Java架构学习视频、Java最新面试题、Java编程书籍
Client 端程序:
import java.io.*;
import java.net.*;
public class Client {
Socket socket;
BufferedReader in;
PrintWriter out;
public Client() {
try {
System.out.println("Try to Connect to 127.0.0.1:10000");
//1.创建 Socket 对象,并连接服务器 (ip字符串,端口号)
socket = new Socket("127.0.0.1", 10000);
System.out.println("The Server Connected!");
System.out.println("Please enter some Character:");
BufferedReader line = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(), true);
out.println(line.readLine());
//2.调用 getXXXStream 方法,进行 I/O操作
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
//3、关闭 Socket
socket.close();
}
catch (IOException e) {
out.println("Wrong");
}
}
public static void main(String[] args) {
new Client();
}
}
//欢迎加入Java高级架构进阶Qqun:963944895,私聊管理员免费领取Java架构学习视频、Java最新面试题、Java编程书籍
点关注,不迷路;持续更新Java架构相关技术及资讯热文!!!
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。