Java高级部分面试大全

1.IO

外存  内存   缓存

打开txt文件的步骤：

1. 启动一个应用程序[记事本，word，excel],系统会给这个程序分配内存空间
2. 在外存和内存之间建立一个管道

     3.将外存中的数据通过管道输送到内存中

     4.输送数据的管道叫做数据流对象

字节是可以操作的最小的有意义的单位 ，所有的数据都可以用字节表示。

字节输入流：

InputStream                     所有字节输入流的抽象父类

FileInputStream               文件输入流

ByteArrayInputStream   字节数组输入流

ObjectInputStream          对象输入流

FilterInputStream                   过滤输入流

BufferedInputStream       缓冲字节输入流

DataInputStream             基本数据类型输入流

常用方法：

int len = available()                获得流中的估计剩余字节数

int t = read();                         读取流中的字节，如果是-1，说明读取到文件末尾，返回值表示读取到的字节数，如果为-1，表示到流的末尾

skip(t);                                    丢弃到t个字节

int t =read(byte[])                    将流中的数据读入到字节数组中，直到填满整个数组

int t = read(byte[],off,len)      将流中的数据读入到字节数组中,从数组的第off个位置开始填充，读取len个，返回值表示读取到的真实的字节数，如果为-1，表示到流的末尾

字节输出流

OutputStream

FileOutputStream                  文件输出流

ByteArrayOutputStream        字节数组输出流

ObjectOutputStream             对象输出流

FilterOutputStream                过滤输出流

BufferedOutputStream          缓冲字节输出流

DataOutputStream                基本数据类型输出流

常用方法：

write(int)                                将指定的字节写到输出流

write(byte[])                           将字节数组中的所有字节写到输出流

write(byte[],off,len)                将字节数组中的字节写到输出流,从下标off开始，写len个

flush()                                    刷新输出流，将流中的字节强制输出

2.对象的序列化和反序列化

序列化：对象本身是不能够在流中串行的，将对象转换成可串行的，有序的数据流

反序列化：将串行的有序的流数据转换成对象的形式

 3.如何实现序列化和反序列化

如果某一个类的对象需要序列化或反序列化，就需要让该类实现序列化Serializable接口

序列化接口不做任何操作，仅仅是给该类的对象添加一个可序列化标记

4.NIO  

//创建文件字节流

 FileInputStream fis = new FileInputStream(src);

 FileOutputStream fos = new FileOutputStream(dest, true);

 //获得输入和输出管道

 FileChannel inChannel = fis.getChannel();

 FileChannel outChannel = fos.getChannel();

 outChannel.transferFrom(inChannel, 0, f.length());

 inChannel.transferTo(0, f.length(), outChannel);

 ByteBuffer buffer = ByteBuffer.wrap("中南大".getBytes());

 outChannel.write(buffer);

 5.文件路径

绝对路径：从根磁盘开始计算的路径

windows:         D:\\aa\\bb\\cc\\dd.txt

Linux:               /aa/bb/cc/dd.txt

http://www.qq.com/aa/bb/cc.css

相对路径：

 A:   D:\\aa\\a.txt

B:   D:\\aa\\bb\\cc\\c.txt

A相对于B的路径:  ..\\..\\a.txt

B相对于A的路径:  bb\\cc\\c.txt

6.程序，进程，线程

程序：一组能完成一定任务的文件，是静止的

进程：程序运行之后至少会启动一个进程，是一个动态变化的

          一个程序可以启动多个进程

         多进程会消耗更多的系统资源

         每一个进程都独占一块内存，进程之间通信开销大

线程：线程是进程内部的运行单元

           一个进程可以包含多个线程，至少包含一个线程

           每一个线程有独立的内存空间，多个线程之间可以通过进程的内存进行通信

 7.如何实现多线程编程

   a.通继承Thread实现多线程

   b.实现Runnable接口

   c.通过定时器创建线程：TimerTask  定时任务

   d.Callable

8.Thread和Runnable的区别

Thread对象是一个线程对象，可以直接并行运行。

Runnable对象只是一个可并行的任务，不能够直接并行运行，需要将其包装成                  Thread对象。

 9.线程的常用方法

Thread th = Thread.currentThread();            获得当前线程对象

String name = th.getName();                        获得线程的名字

String id = th.getID();                                    获得线程的标识符

10.线程的生命周期

 New Thread 新建状态                       创建了线程对象，调用start之前

Runnable   就绪状态[可运行状态]      调用了start之后，run方法执行之前

 Running    运行状态                          run方法正在执行

 Not Run    阻塞状态[挂起]                  线程sleep,wait的时候

 Dead       死亡状态                            run正常结束或者进程终止

 11.线程池

线程池的四种创建方式及用法：

//创建一个存放单一线程的线程池

//ExecutorService service = Executors.newSingleThreadExecutor();

//创建固定线程数量的线程池

//ExecutorService service = Executors.newFixedThreadPool(2);

//创建一个可缓存线程对象的线程池

//ExecutorService service = Executors.newCachedThreadPool();

//创建一个可延时执行的线程池，

ScheduledExecutorService service=Executors.newScheduledThreadPool(2);

12.线程的常用方法

设置和获得线程优先级的方法

 //线程的优先级从1到10，默认值是5 

 setPriority(int newPriority);

 getPriority();

线程休眠的方法

  sleep(long millis);

等待该线程先执行完毕

  join();

暂停当前正在执行的线程，去执行其他线程

  yield();

中断线程,中断线程会抛出线程中断的异常

 interrupt();

设置守护线程

  setDaemon(true);

 13.线程的同步

 线程的执行默认是异步的:

  多个线程可以同时访问同一个数据[同一块内存]

  同步：在同一个时间只能有一个线程访问这个数据

如何实现线程同步：

1. 使用同步代码块

synchronized(对象){

需要同步的代码

}

    2.使用同步方法 

public synchronized void method(){

}

    3.使用同步锁

Lock lo = new ReentrantLock();

lo.lock();//上锁

lo.unlock(); //解锁

   4.使用本地变量

  使用ThreadLocal存放变量

14.生产消费者模型

wait和sleep的区别：

wait和sleep都是让当前线程进入阻塞状态

wait方法是Object类中的方法，sleep是Thread类的方法

当线程在wait的时候，会释放线程占用的资源，线程sleep的时候，会继续占用资源

 notify与notifyAll的区别：

notify随机唤醒在同一个对象上wait的线程，notifyAll唤醒所有在这个对象上wait的线程

15.网络通信

     IP地址：                设备在网络上的唯一标识

     127.0.0.1               表示本机地址

     localhost               表示本机

     MAC地址              网卡的物理地址

     DNS：                  域名解析服务

    端口：                   设备上的程序用来在网络上交换数据的标识

 端口的值是从0~65535, 尽量不要使用比较小的数字

Web服务：80  、8080/8081、8009

MySQL:3306

Oracle:1521

如何检测两台设备之间的网络是不是通的:

 网络防火墙

如何查看网络是不是同的:

ping 对方IP

如何查看本机IP:

ipconfig

如何查看哪些端口可以使用:

netstat -ano

 16.java.net

ServerSocket              服务端套接字

 Socket                       客户端套接字

17.网络通信的7层模型和4层模型

OSI 7层模型

应用层 HTTP FTP SMTP

表示层

会话层

传输层    TCP   UDP

网络层       IP

数据链路层

物理层

TCP/IP四层模型

应用层 HTTP FTP

传输层 TCP UDP

网络层 IP

接口层

TCP和UPD协议:

TCP:   传输控制协议，面向连接的 可靠的    类似于打电话

UDP：用户数据报协议，无连接的，不可靠的   类似于发短信

 18.TCP协议的传输过程

1.通过三次握手建立连接

2.数据通信         

3.通过四次挥手断开连接

有序性：每个数据报都有一个序号，保证数据的顺序

丢包重传：每发送一个包，都要等待接收方的响应，如果在一定的时间内没有收到响应，就认为数据丢失，就重新发送一次       

重复数据处理：接收方如果收到数据包会检验是否重复，如果重复，就丢弃

19.XML认识 

GML:               通用标记语言   解决数据传输的格式问题

SGML：         标准的通用标记语言

HTML ：        超文本标记语言

XML:              可扩展标记语言

HTML5

 20.XML数据的标准格式

所有的XML数据都必须要先声明,必须在第一行

<?xml version='1.0' encoding='UTF-8'?>

每一个XML数据都有且只有一对根标签<a></a>

1. 开始标签和结束标签必须一致
2. 标签可以嵌套，但是不能交叉
3. 如果标签中没有文本，则一般定义成单标签<img />

每个标签都可以定义多个属性，同一个标签不能有同名的属性

21.XML解析

对XML数据的处理过程，叫做XML解析

XML的解析方式：

DOM:   Document Object Model  文档对象模型

解析思想：

1.解析的时候首先将整个XML数据一次性读入到内存中，构造成一棵树形结构

2.这个树形结构叫做Document对象

3.每一个标签[元素]叫做一个Element对象

4.每一个属性叫做Attr对象

5.每一个文本叫做Text对象

6.所有的Element、Attr、Text、Document都叫做一个结点[Node]对象，Element、Attr、Text、Document都是Node的子类

7.在解析的时候可以对整棵树进行增删改查的随机操作

22.Java中解析XML的API

JAXP

DocumentBuilderFactory                        DOM解析器工厂对象

DocumentBuilder                                    DOM解析器对象

Document对象

Element对象

Attr对象

Text对象

Node对象

NodeList                                            结点列表

NamedNodeMap                              属性名值对象列表

TransformerFactory

Transformer

DOMSource

StreamResult

23.标准xml文档

<?xml version="1.0" encoding="UTF-8"?>

<web-app>

   <servlet>

                  <servlet-name>b</servlet-name>

                  <servlet-class method="z">com.newer.demo6.UserControll</servlet-class>

      </servlet>

      <servlet-mapping>

                  <servlet-name>b</servlet-name>

                  <url-pattern>/login</url-pattern>

      </servlet-mapping>

</web-app>

 24.用dom4j解析xml文档

1.先下载dom4j解析包

2.将dom4j包导入工程目录下

3.开始解析

.......

25.JSON

JSON:JavaScript Object Notation

SON:JavaScript Object Notation

{} 表示一个JSON对象

[] 表示一个JSON数组

表示学生对象:

{

 'num':123,

 'name':'张三丰',

 'age':20,

 'sex':'男'

}

{

'num':123,

'name':'张三丰',

'age':20,

'sex':'男',

'lianxi':{

'tel':'13812345678',

'qq':'12345678',

'email':'1234@qq.com'

}

}

[{},{},{},{}]

26.GSON

下载第三方的JSON解析库 GSON

引入第三方的jar包：

1.在工程中新建一个文件夹，一般命名为lib

2.将需要的jar包拷贝到lib文件夹下

3.鼠标右键选择jar包-->build path-->Add to Build Path

JsonPaser, JsonElement, JsonObject, JsonArray

 27.类的加载与反射机制

  Java程序的运行原理：

1. 启动Java虚拟机
2. 将class文件装载到虚拟机中
3. class文件读取到内存之后以对象的形式存在，这个对象的类型是Class类型
4. 找到主类，执行主函数

 28.谁来加载类

 类加载器对象              ClassLoader

 AppClassLoader         负责加载应用程序的类

 ExtClassLoader          负责加载扩展类库

 Bootstrap加载器         引导类加载器 负责加载核心类库

 Bootstrap加载器是JVM的一部分，当JVM启动，Bootstrap加载器就已经启动

类加载和反射机制中最核心的类 ：  Class

 29.获得Class对象的方式

类名.class

对象.getClass()

Class.forName("包名。类名")

ClassLoaderd对象.loadClass("包名。类名");

基本类型的包装类.TYPE

30.判断两个类是不是同一个实际上是比较是不是同一个class对象

实际上在Java体系中一个class文件只能由一个类加载器加载

类加载器在加载class文件的时候总是先判断父加载器是否加载这个文件，如果父加载器加载了，就不再加载，如果父加载器没有加载，再加载这个文件

31.Class对象是类中属性，方法和构造方法的描述

 通过class对象可以获得该类的构造方法，属性和方法

32.反射

可以在程序运行时通过类的Class对象动态获得类的属性，方法和构造方法，并动态调用的机制。

 33.不定项参数  

参数个数不确定

在一个方法中只能有一个不定项参数

不定项参数必须是方法的最后一个参数

34.通过Class对象获得构造方法的四种方式

getConstructors()

getContructor(Class...type)

getDeclaredConstructors()

getDeclaredConstructor(Class...type)

通过构造方法实例化对象

con.newInstance();

 35.通过class对象获得属性的四种方式

getFields();

getField(String name);

getDeclaredFields();

getDeclaredField(String name)

通过属性调用对象

   属性.set(对象,属性值);

 36.通过Class对象获得方法的四种方式

getMethods();

getMethod(String name,Class...type);

getDeclaredMethods();

getDeclaredMethod(String name,Class...type);

通过方法调用对象

方法.invoke(对象,参数值...);

37.注解

用在类，属性，方法，构造方法，参数上，作为程序的一部分

常见注解：

@Override 用在方法上，表示此方式是重写的方法

@Deprecated 用在方法上，表示此方法已经过时，不推荐使用

@SuppressWarnings("serial") 用在类，属性，方法上，用来忽略指定的警告

元注解:对注解进行注解的注解

@Target ： 注解的使用范围:

ElementType.TYPE                             类

ElementType.FIELD                            属性

ElementType.METHOD                       方法

ElementType.PARAMETER                 参数

ElementType.CONSTRUCTOR           构造方法

ElementType.LOCAL_VARIABLE         局部变量

ElementType.ANNOTATION_TYPE     注解类型

ElementType.PACKAGE                       包

ElementType.TYPE_PARAMETER       类型参数

ElementType.TYPE_USE                     类型

@Retention： 说明注解存在的生命周期:

RetentionPolicy.SOURCE       只在源代码中存在，编译成class的时候会丢弃

RetentionPolicy.CLASS           存在于class文件中，加载成Class对象的时候会丢弃

RetentionPolicy.RUNTIME       程序运行时还存在

@Documented                        此注解是否可文档化

@Inherited                              注解是否可被继承

 38.泛型

泛型:类型参数化,定义的时候没有明确具体的类型，等到调用的时候再确定要使用的类型。

1. 泛型类

public class MyClass<A>{}

 在调用泛型类的时候如果没有将泛型具体化，默认会用Object代替

      2.泛型接口

public interface MyInterface<D> {

public void test(D d);

}

泛型接口的实现必须是泛型类：   

public class MyClass<D> implements MyInterface<D>{

@Override

public void test(D d) {

 }

}

    3.泛型方法

  public <E> void change(E e){}

使用extends限定泛型的范围

public <E extends 父类> void change(E e){}

      4.使用?通配符

 public void abc(ArrayList<? extends Number> list){

 for(Number m:list){

 System.out.println(m);

 }

}

39.数据的加密和解密

1.Base64

加密：

Encoder coder = Base64.getEncoder();

String mimaStr = coder.encodeToString(msg.getBytes());

解密：

Decoder coder = Base64.getDecoder();

byte[] bs = coder.decode(mima);

String msg = new String(bs);

2.MD5

3.SHA