JavaSE基础面试题目分析

26:转换流当中谁是字节流通向字符流的桥梁? 谁是字符流通向字节流的桥梁?

字节流通向字符流的桥梁: InputStreamReader;
字符流通向字节流的桥梁: OutputStreamWriter;

27: 进程与线程的区别?

根本区别:进程是正在运行的程序,是操作系统分配资源的基本单位,线程
是任务调度和执行的基本单位.
包含区别: 线程是进程的一部分,线程也被成为轻量级进程.

28: Java程序的启动是多线程吗?

 是,至少开启了 主线程(main) 和 垃圾回收机线程(GC)

29: 多线程的两种实现方式之间的区别?

继承Thread:
	好处: 代码相对较简单. 因为是继承Thread类,所以可以直接使用Thread类中
		  的非私有成员.
	弊端: 扩展性相对较差. 因为已经继承Thread类了,所以就不能有其他父类了.
实现Runnable接口:
	好处: 扩展性相对较强. 因为是实现接口,所以还可以有自己的父类和其它
		  的父接口
	弊端: 代码相对较繁琐. 因为实现了Runnable接口,和Thread类没有关系,
		  所以不能直接使用Thread类中的成员.	

30: 线程的默认命名格式是什么?

 Thread-编号, 编号是从零开始.

31: 同步锁的对象分别是什么?

同步代码块
静态同步方法, 锁对象是: 该类的字节码文件对象, 例如: Demo01.class
非静态同步方法, 锁对象是: this

33: 请手写一个死锁的代码(只在面试用 实际开发无)?

/*
    案例: 演示死锁代码.

    思路:
        1. 死锁需要两个线程,两把锁.
        2. 一个线程先抢锁A, 后抢锁B.
        3. 另一个线程先抢锁B, 后抢锁A,就有可能引发死锁情况.
        4. 为了让效果更明显, 我们用 while(true) 死循环改进.

    大白话翻译:
        死锁其实指的就是 同步代码块的嵌套, 你在写代码的时候, 尽量避免这个问题.
 */
public class DeadLock {
    //1. 定义两把锁.
    private static final String LOCKA = "锁A";   //被final修饰的变量为常量  名字全部大写
    private static final String LOCKB = "锁B";

    public static void main(String[] args) {
        //2. 一个线程先抢锁A, 后抢锁B.
        new Thread("詹姆斯") {      //继承Thread类的方式.
            @Override
            public void run() {
                //4. 为了让效果更明显, 我们用 while(true) 死循环改进.
                while (true) {
                    //先抢锁A, 后抢锁B.
                    synchronized (LOCKA) {
                        System.out.println(getName() + " 获取到" + LOCKA + ", 等待" + LOCKB);
                        synchronized (LOCKB) {
                            System.out.println(getName() + " 获取到" + LOCKB + ", 成功进到小黑屋!");
                        }
                    }
                }
            }
        }.start();


        //3. 另一个线程先抢锁B, 后抢锁A,就有可能引发死锁情况.
        new Thread("阿福") {      //继承Thread类的方式.
            @Override
            public void run() {
                //4. 为了让效果更明显, 我们用 while(true) 死循环改进.
                while (true) {
                    //先抢锁B, 后抢锁A
                    synchronized (LOCKB) {
                        System.out.println(getName() + " 获取到" + LOCKB + ", 等待" + LOCKA);
                        synchronized (LOCKA) {
                            System.out.println(getName() + " 获取到" + LOCKA + ", 成功进到小黑屋!");
                        }
                    }
                }

            }
        }.start();
    }
}

34: 多线程的生命周期是什么?

 简易版: 新建, 就绪, 运行(运行的时候可能会发生阻塞), 死亡;
 进阶版: 新建, 就绪 , 运行(运行的时候肯能够发生阻塞 或者 等待), 死亡

35: 为啥wait() 和 notify() 方法是Object 类中的方法, 而不是 Thread类中的方法?

因为锁的对象可以是任意类型的, Object类是所有类的父类, 它里面的非私有
成员,可以被所有的类继承.

36: Hashtable 和 HashMap 的区别是什么?

	HashMap: 
		是JDK1.2出来的, 线程不安全, 效率高,允许储存null值和Null键.
	Hashtable:
		是JDK1.0出来的,线程安全, 效率相对较低,不允许储存Null值和Null键.

37: 线程的默认优先级是多少, 范围是多少?

1. 线程的默认优先级是: 5, 范围是1-10,  1最小, 10最大.
2. 优先级高并不代表该线程一定第一个执行, 而是代表着该线程有更大的几率抢到CPU资源.
3. 多线程的执行其实就是在抢CPU资源, 所以它的执行特点是: 随机性 和 延迟性.

38: 线程的优先级越高,说明它一定执行吗?

不一定,线程具有随机性 和 延迟性.

39: Callable接口 和 Runnable接口的区别是什么?

1. 使用范围不同.
	Runnable既可以结合线程池使用,还可以结合Thread类使用.
	Callable只能结合线程池一起使用
2. 返回值不同.
	Callable#call()方法: 可以有具体的返回返回值.
	Runnable#run()方法: 没有具体的返回值, 既:返回值类型为void
3. 关于异常的处理方法不同.
	Callable#call()方法: 可以try 也可以抛出去
	Runnable#run()方法: 只能try	

40: C/S架构 B/S架构的区别?

略.........

41: 端口号的范围?

概述: 指的是 程序在设备上的唯一标识.
范围: 0 - 65535, 其中0- 1023 号段不要用,因为已经被用做系统端口或者
	保留端口了.
查看本机运行的程序端口号:
	netstat -ano

42: UDP 与 TCP的区别?

TCP传输协议，是一种面向连接的、基于字节流的传输层通信协议,因为需要建立连接,所以通过TCP连接传输的数据无差错、不丢失、不重复，并且能够按序到达;

UDP是Internet协议集支持一个无连接的传输协议，为应用程序提供了一种无需建立连接，就可以发送封装的IP数据包的方法,会丢失数据,效率相对TCP较高；

43: close() 和 flush()方法的区别是什么?

  close(): 用来关闭对象释放资源的, 在关闭之前会自动刷新一次缓冲区, 关闭之后, IO流对象就不能继续使用了.
  flush(): 用来刷新缓冲区 获取数据的, 刷新之后, IO流对象还可以继续使用.

44: Writer, 字节缓冲流, 字符缓冲流的默认缓冲区的大小分别是多少?

字节输出流没有缓冲区  FileOutputStrem(); 	
 Writer:     1024个字符 = 2048个字节 = 2KB
 字节缓冲流:   8192个字节 = 8KB
 字符缓冲流:   8192个字符 = 16KB

45: 你知道的常用的关系型数据库有哪些?

	关系型数据库: MySQL, Oracle, SQLserver, DB2等
	非关系型数据库: Redis, HBase, MongDB

46: 说一下你对事物的了解.

	//ACID
	 原子性（Atomicity）:   原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
	 
     一致性（Consistency）: 事务前后数据的完整性必须保持一致。
     
     隔离性（Isolation） :  事务的隔离性是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。
     
     持久性（Durability） : 持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。           

47: 说一下你对脏读, 不可重复读, 幻读的理解.

 脏读:  也叫: 读-未提交
         指的是一个事务读取到了另一个事务还没有来得及提交的数据, 
         导致多次查询结果不一致.
                    
不可重复读: 也叫: 读-已提交(更新)
         指的是一个事务读取到了另一个事务已经提交的(更新, 修改)数据,
         导致多次查询结果不一致.
         
虚读(幻读): 也叫: 读-已提交(插入)
        指的是一个事务读取到了另一个事务已经提交的(插入)数据, 导致
        多次查询结果不一致.

48: 说一下你对事物的隔离级别的理解

	 其实所谓的不考虑隔离性, 就是不考虑事务的隔离级别, 那么事务的隔离级别有哪些呢? 具体如下:
            隔离级别从小到大分别是:
                read uncommitted <  read committed < repeatable read < serializable
            隔离级别安全从低到高分别是:
                read uncommitted <  read committed < repeatable read < serializable
            隔离级别效率从高到第分别是:
                read uncommitted >  read committed > repeatable read > serializable
                
        总结:
            1. 四大隔离级别可能发生以及已经解决的问题.
               read uncommitted:
                会发生: 3, 脏读, 不可重复读, 虚读.
                已解决: 0
               read committed:
                会发生: 2, 不可重复读, 虚读.
                已解决: 1, 脏读.
               repeatable read:
                会发生: 1, 虚读.
                已解决: 2, 脏读, 不可重复读
               serializable:
                会发生: 0
                已解决: 3, 脏读, 不可重复读, 虚读.

49: Oracle 和 MySQL 数据库的区别?

1. MySQL数据库默认的隔离级别是: repeatable read   Oracle数据库默认的隔离级别是:read committed
2. MySQL数据库默认开启了事务的自动提交功能, 每一个SQL语句都是一个事务.
3. Oracle数据库默认没有开启事务的自动提交功能, 需要我们手动开启.

50: 删除maven仓库没下载好的jar包

本文地址：https://blog.csdn.net/m0_49834705/article/details/109642977