JAVA面试基础部分

菜鸟小学弟

已于 2024-03-14 17:52:00 修改

阅读量289

点赞数

分类专栏： java for review 文章标签：ＪＡＶＡ面试

于 2019-10-22 17:10:33 首次发布

本文链接：https://blog.csdn.net/weixin_44734394/article/details/102683975

版权

java for review 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

JAVA基础知识

inal和static关键字

https://www.cnblogs.com/skye-you/p/10214525.html
静态变量和实例变量的区别？
静态变量存在方法区，实例变量在堆中
object类中有哪些公共的方法
clone方法保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

2．getClass方法
final方法，获得运行时类型。

3．toString方法
该方法用得比较多，一般子类都有覆盖。

4．finalize方法
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5．equals方法（值得比较）（= =内存地址的比较一般在基本类型中运用）
该方法是非常重要的一个方法。equals和==是不一样的。子类一般都要重写这个方法。

6．hashCode方法
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hashCode()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

7．wait方法
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。在这里插入图片描述
a、wait是Object对象的方法，让当前线程等待这个对象的锁，线程会释放锁资源。
b、sleep是Thread线程的方法，让当前线程睡眠一段时间，是持有锁资源的。

8．notify方法-对象方法
该方法唤醒在该对象上等待的某个线程。

9．notifyAll方法-对象方法
该方法唤醒在该对象上等待的所有线程。

字符和字节：

字符：java的基本数据类型，它是计算机中使用的字母、数字、符号。

字节：字节是一种数据量的单位,一个字节等于 8 位
在这里插入图片描述
编码：Java中unicode

编码utf-8

mysql中

中文：3个
表情：4个

基础类型：
1142-8
在这里插入图片描述

equals 和 == 的区分

==比较的是内存地址：（float,double,int ,char）地址相同数值肯定同
Equals比较的是对象的引用：(String 也是引用类型)。
1.String源码：
在这里插入图片描述
为啥重写equals方法要重写hashcode方法呢？
关系：
1、如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；
2、如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)
理解为：
在这里插入图片描述
3、String、 StringBufferr（理解为缓冲线程安全）、 StringBuilder（建造器线程不安全）：
String是char[]数组的集合：char[] a={a,b,c}; String s=new String(a);
方法：charAt[i] 字符
IndexOf(子窜) 下标
IndexOf(子串，start) 下标
substring(start，end) ，截取start到末尾的子串 [start ，end)
Trim()去除两端的空白字符得到串、
StringBuffer(线程安全Synconized原因)/StringBuilder（线程不安全）:
在这里插入图片描述都是代替String做高效的字符串链接：append方法

4.IO流：
概述：IO流是用来处理设备之间的数据传输，java中对文件的操作是以流的方式进行的。
字节和字符：只有utf-8中1个字符表示3个字节，其余编码都是1个字符2个字节。
基本类型：byte(1) short(2) int(4) long(8) ; float(4) double(8) ;char(2) boolean;八大基本类型。
在这里插入图片描述

分类：
字节流抽象基类，InputStream、OutputStream 。
字符流的抽象基类，Reader、Writer。

FileWriter FileReader-------->>>>BufferdWriter,BufferedReader;(使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。缓冲区的出现是为了提高流的操作效率而出现的。)字符串.getBytes();
FileInputStream与FileOutputStream（字节输入流与字节输出流）
写：fos=new FileOutputStream(“1.txt”);
Fos.write(“abc”.getByte());
Fos.close;
读：fis=new FileInputStream(“1.txt”);//准备流
Byte[] byte= New byte[1024];//准备数组容器
int len = 0;
//有一个指针读的操作
while((len=fis.read(byte))!=-1){
System.out.println(new String(byte,0,len));
}
在这里插入图片描述
5.线程、进程：
wait, notify 和 notifyAll 与锁联系一起说明。

：每个对象都有锁，通过线程获得。
：锁是对象级别的而不是线程级别的。
再次说明：wait()是释放锁的状态。
Sleep()是持有锁的状态。

1，怎么让t1 t2 t3 顺序执行？
答：可以用join方法比如t2 中t1.jion();t3中t2.join();然后启动t3,t2,t1线程。
2，wait和sleep方法的不同？
答：wait等待时候会释放锁，等待另一个线程执行，sleep是持有锁的。
3，线程和进程分别是什么？
答：线程是代码执行的最小单元，一个进程可以有多个线程，线程共享进程的内存空间。
在这里插入图片描述
4，多线程实现有几种方法：

答：继承Thread，实现Runnable接口，实现Callable接口重写call方法.

public class TestManyThread  {

    public static void main(String[] args) {

        // 启动线程
        new MyThread().start();

        // 启动线程
        new Thread(new MyAble()).start();

    }

    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    public static class MyAble implements Runnable{

        @Override
        public void run() {
            System.out.println("MyAble");
        }
    }

}

在这里插入图片描述
5，线程有哪几种状态：

即：new(新建)，start()可运行,running()运行，blocked()阻塞，Dead死亡状态。

线程池：
原理：

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, queue);

线程池的类型：
在这里插入图片描述

6.Collection与Map：
在这里插入图片描述
List：不是线程安全的，使用
ConcurrentLinkedQueue：随便看了下应该是通过CAS算法来实现安全的 Offer:如队列。
Linkedlist：链表类型的，是通过指针指向元素的，所以擦在任何位置都可以，只要指针指向就OK了。所插入删除比较快。
ArraysList（扩容50%）/vector（翻倍）：数组类型的集合，是通过下标访问，所以访问比较快，插入删除要遍历一遍才能做到。
Vector(自动扩容翻倍)是线程安全的，使用的Synconized来进行的但是效率很低。关系类似于HashMap于HashTable.
Set：不是线程安全的，由于底层是hashMap故ConcurrentHashMap来实现线程安全。
HashSet:链表和数组的结合体，存储和非常快; 无序—不重复。
public class TestTreeSet {

public static void main(String[] args) {
    System.out.println(run());
}

private static TreeSet run() {
    TreeSet<Integer> objects = new TreeSet<>();
    ArrayList<Integer> objects1 = new ArrayList<>();
    objects1.add(1);
    objects1.add(32);
    objects1.add(2);
    objects.addAll(objects1);
    objects.add(1);
    objects.add(2);
    objects.add(89);
    objects.add(58);
    objects.add(36);
    objects.add(76);
    return objects;
}

}
输出结果：
[1, 2, 32, 36, 58, 76, 89] 排序和去重一步搞定。

在这里插入图片描述
1，List有序可重复，Set无序不重复。
2，HashMap的实现原理：
HashMap是数组和链表来存储数据是线程不同步的。如果要同步则用Synchonized包装new的HashMap对象/ConcurrentHashMap(也是CAS算法实现的线程安全/后面有详细说)。HashTable是线程同步的。Key.hashCode() 为hash值;然后根据hash值算法计算出index是int类型的（内存空间），找到数组的位置。（竖着的是数组，横着的是链表）
在这里插入图片描述

：entity对象中有 key value next.

在这里插入图片描述
2、HashTable与HashMap的区别：（补充Vector 同ArrayList ）
前面的线程安全后面的不安全安全使用的枷锁技术但是效率不高
为什么？
答： put的时候导致的多线程数据不一致。
比如有两个线程A和B，首先A希望插入一个key-value对到HashMap中，计算记录所要落到的 hash桶的索引坐标，然后获取到该桶里面的链表头结点，此时线程A的时间片用完了，而此时线程B被调度得以执行，和线程A一样执行，只不过线程B成功将记录插到了桶里面，假设线程A插入的记录计算出来的 hash桶索引和线程B要插入的记录计算出来的 hash桶索引是一样的，那么当线程B成功插入之后，线程A再次被调度运行时，它依然持有过期的链表头但是它对此一无所知，以至于它认为它应该这样做，如此一来就覆盖了线程B插入的记录，这样线程B插入的记录就凭空消失了，造成了数据不一致的行为

3、线程安全使用java.util.concurrent包里的ConcurrentHashMap类：
ConcurrentHashMap不仅线程安全而且效率高，因为它包含一个segment数组，将数据分段存储，给每一段数据配一把锁，也就是所谓的锁分段技术。
解决问题？：
Java7：Segment（锁段）的概念
Java8：CAS算法（后面的乐观锁也是这么实现线程安全的）
初始数组容量为16

4.、Servlet线程安全吗？
不是线程安全的。
在这里插入图片描述

当servlet有变量时候，可能会报错的。

6、http状态码：https://blog.csdn.net/qq_34986769/article/details/51984829
一般说出来几个就可以了
200——表明该请求被成功地完成，所请求的资源发送回客户端
302——请求的网页被转移到一个新的地址，但客户访问仍继续通过原始URL地址，重定向，新的URL会在response中的Location中返回，浏览器将会使用新的URL发出新的Request。
400——客户端请求有语法错误，不能被服务器所理解
401——请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用
HTTP 401.1 - 未授权：登录失败
　　HTTP 401.2 - 未授权：服务器配置问题导致登录失败
　　HTTP 401.3 - ACL 禁止访问资源
　　HTTP 401.4 - 未授权：授权被筛选器拒绝
HTTP 401.5 - 未授权：ISAPI 或 CGI 授权失败
403——禁止访问，服务器收到请求，但是拒绝提供服务
404——一个404错误表明可连接服务器，但服务器无法取得所请求的网页，请求资源不存在。eg：输入了错误的URL
405——用户在Request-Line字段定义的方法不允许
7、RestFul：你说说看？（面试说的重点）！
什么是restFul
在这里插入图片描述

post:增加
delete:删除
put:修改
get:查询、

8、看过那些源码
1、SqlSessionFactory源码是一个接口，其具体实现类是DefaultSqlSessionFactory，工厂用来生产 SqlSession对象，SqlSession中有我们进行数据库操作的增删改查接口。
2、HashMap的源码：Key.hashCode() 为hash值;然后根据hash值算法计算出index是int类型的，找到数组的位置。（竖着的是数组，横着的是链表）。
3、String的源码：重写equals方法和hashcode 。
4、Concurrent包下（乐观锁的源码）：CAS算法（比较改变）。
5、classLoader的源码分析:先找父类，找找子类。去加载。
9、支付接口

思路：你----->生成订单—>蚂蚁服务器（加签）---->你----->App---->调用起支付页面。调用支付宝的接口。

10、设计模式：
在这里插入图片描述
单例模式、工厂模式、代理模式。
1、单例模式？

//懒汉式（线程安全，同步方法）
class Singleton{
 
   // 加入volatile关键字
   private static volatile Singleton instance;
 
   //构造器私有化
   private Singleton(){}
 
   //提供一个静态公有方法，加入双重检查代码，
   //解决线程安全问题,同时解决懒加载问题
   //同时保证了效率，推荐使用
   public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                   instance = new Singleton();
                }
            }
        }
        return instance;
   }
}

Java中常见的一种设计模式，单例模式分为3种：饿汉模式，懒汉模式，登记试单例。
饿汉模式：初始化就有实例
Public Class Singleton1{
          Private Singleton1(){}
         Private static final Singleton s1=new Singleton1();
         Public static Singleton1 getInstance(){
        Return s1;
}
}
    懒汉模式：第一次调用就有实例
Public Class Singleton2{
    Private Singleton2(){}
    Private static Singleton2 s2=null;
Public static  Singleton2 getInstance(){    
       If(s2=
       =null){
     S2=new Singleton2();
}
    Return s2;
}
}

注册模式：像spring一样，直接从里面取出来。
Public class singleton3{
//1.hashMap 2.怎么取（static示范）3.getInstance(String name)4构造方法
Private static  Map<String ,Singleton3> map=New HashMap<String . Singleton3>();
Procted Singleton3(){}
Static {//静态代码块
    Singleton3 single= New Singleton3();
    Map.put(single.getClass.getName ,single);//实例获得名字
}
Public Singleton3 getInstance(String name){
    If(name==null){
   name=Singleton3.class.getName(); //类获得名字,然后通过名字去取 ，而不是先存。
  }
 If(map.get(name)==null){
  Try{
   Map.put(name,(Singleton3)Class.forName(name).newInstance());
}catch (Exception e){
e.print
}
Return  map.get(name);
}
}
}

2、特点？
1、单例类只有一个实例。2、单例类必须自己创建唯一的实例。3、必须给所有其他对象提供这一实例。

11、什么是线程安全？
如果在一个进程中有多个线程同时访问一段代码，每次访问的结果和单线程访问的都是一样的，而且其他的变量的值和预期的也是一样的，就是线程安全的。

12、Mysql及其优化
在这里插入图片描述

总结：1大写，2* ，3null，4between代替in, 5Varchar代替char, 6union all代替or。
1.insert into Students (姓名,性别,出生日期) values (‘开心朋朋’,’男’,’1980/6/15’)
2.delete from a where name=’开心朋朋’（删除表a中列值为开心朋朋的行）
3.update tongxunlu set 年龄=18 where 姓名=’蓝色小名’
4.select * from A

13、# 与 $
#{}: select * from user where name=#{name};
预编译为 select * from user where name=?; (占位符) 会加上引号的
JDBC 中使用对象 PreparedStatement 来抽象预编译语句

${}: select * from user where name=$ {name};当传递的参数为“jack”
纯粹的变量替换 select * from user where name=”jack”;
预编译之前的 SQL 语句已经不包含变量了，完全已经是常量数据了。
综上所得， ${ } 变量的替换阶段是在动态 SQL 解析阶段，而 #{ }变量的替换是在 DBMS 中。

#防止sql注入攻击

14、httpClient:客户端编程工具包
在这里插入图片描述
15、HTTP与HTTPS的区别：
HTTP：是浏览器与网站服务器之间的通信，是明文通信的，不存在加密信息，不安全。80端口。
HHTPS:使数据传输更加安全，HTTP+SSL 协议，依靠证书来和服务器通信，并且对通信进行加密。加密传输协议。
不同：
在这里插入图片描述
原理：

在这里插入图片描述

16、算法题判断单向链表是否有环？
方法一：先循环遍历节点，再循环遍历该节点之前的节点，比较是否相同，同则是由环的。
方法二：用HashSet（set集合存储的是不重复的元素，是因为ID不重复，把节点当key）。
有兴趣的可以写写代码实现。

17、锁技术
1.公平锁和非公平锁：（吞吐量比公平的大）
在这里插入图片描述
2.可重入锁：（可一定程度避免死锁

3.独享锁，共享锁：(广义说法)

4.互斥锁与读写锁：（具体实现）

5.乐观锁与悲观锁：（并发同步的角度）

CAS算法实现的乐观锁：

2、理解算法？

3、JDK应用的CAS算法：
在这里插入图片描述
4、结论：

18、NIO和IO
IO：面向流、每次读一个或者多个字节、阻塞的、直到数据被读取或者完全写入。该线程在此过程不能再做其他事情了、一旦返回就表示读完、直到它读完。少量的连接但是每个连接有大量的数据。
NIO:面向缓冲区的、非阻塞的、可以管理多个通道、从通道读写。必须跟踪有多少数据读入缓冲区/使得处理数据困难。（更复杂但是可以管理多个）成千上万个链接但是每个链接少量数据。

菜鸟小学弟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JAVA面试基础部分

1.静态变量和实例变量的区别？答：静态变量存在方法区，实例变量在堆中。2.object类中有哪些公共的方法？1．clone方法保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。2．getClass方法final方法，获得运行时类型。3．toString方法该方法用得比较多，一般子类都有覆盖...
复制链接

扫一扫