一个JAVA中级程序员的面试准备

JAVA面试准备：

有一部分还不够完整，先将就着看吧…

1，JAVA——SE

主要字符串，面向对象，集合，多线程，设计模式，算法

基本数据类型：

• byte 8位 -128~127
• short 16位 -32768 ~ 32767
• int 32位
• long 64位
• float 32位
• double 64位
• char 16位

字符串：

• String

  • String 在内存中是独一份的。

    String a = "a";			String b = new String("a");
    System.out.println((a == b)); //false
    
    //两个字符串相加，生成第第三个字符串，内存中存在三个字符串对象
    String a = "hello2"; 　　String b = "hello" + 2; 　　
    System.out.println((a == b)); //false
    
    //final 相当于直接把值附给b,c相当于“hello”+2 ，故为true
    String a = "hello2";   　 final String b = "hello";       String c = b + 2;       System.out.println((a == c)); //true
    

• StringBuffer 与 StringBuilder

  • 相同点：
    • 都为可变字符串适合多次被修改比对String操作性能更好
  • 不同点
    • StringBuffer 线程安全，效率比StringBuilder低
    • StringBuilder线程不安全

面向对象：

• 面向对象的三大特性：封装，继承，多态

集合：

• 类图

  Collection
  	List 
  		ArrayList
  		LinkedList
  		Vector 
  	Set
  		HashSet
  		LinkedHashSet
  	Queue 保持一个队列先进先出
  Map
  	HashMap
  	Properties
  

• 比较 List 与 Set

• 比较 ArrayList与LinkedList与Vector

  都是List的实现类，保存有序的可以重复的数据 底层用数组

  ArrayList： 是List的主要实现类，线程不安全，效率高 使用Collections.synchronizedList(Xxx ) 底层用数组

  初始长度 10，扩容 ：1.5倍

  Vector： 是List的古老实现类，线程安全，效率低，

  LinkedList： 底层双向链表，

• 简述 HashSet 与LinkedHashSet

  HashSet底层是HashMap，值存的常量 new Object()

• 简述 HashMap

  HashMap的底层实现原理：

  底层是Entry类型的数组 ，容量16，加载因子 0.75，键不能重复，先比较Hash值 ，如果Hash值一样，则比较equals()

• 比较 HashMap与Hashtable的区别

  HashMap：作为Map的主要实现类 线程不安全的，可以存储null的key和value

  Hashtable：作为Map的古老实现类 线程安全的，不可以存储null的key和value

多线程

设计模式

• 单例模式

  • public class Singleton {  //饿汉式
        private Singleton() {
            System.out.println("Singleton  is  create"); // 创建单例的过程可能会比较慢
        }
     
        private static Singleton instance = new Singleton();
     
        private static Singleton getInstance() {
            return instance;
        }
    }
    

  • 1 public class Singleton { //懒汉式
    2     private Singleton() {
    3         System.out.println("LazySingleton  is  create"); // 创建单例的过程可能会比较慢
    4     }
    5 
    6     private static Singleton instance = null;
    7 
    8     public static synchronized Singleton getInstance() {
    9         if (instance == null)
      10             instance = new Singleton();
      11         return instance;
      12     }
      13 
      14 }
    

  •     1 public class Singleton {  //懒汉式的改良版本实现 延迟加载，非同步
        2     private Singleton() {
        3         System.out.println("LazySingleton  is  create"); // 创建单例的过程可能会比较慢
        4     }
        5 
        6     public static class SingletonHolder {
        7         private static Singleton instance = new Singleton();
        8     }
        9 
       10     public static synchronized Singleton getInstance() {
       11         return SingletonHolder.instance;
       12     }
       13 
       14 }
    

  在这个实现中，用内部类来保护单例，当Singleton类被加载时，内部类不会被初始化，所以可以确保Singleton类被载入JVM时，不会初始化单例类，当getInstance方法被调用时，才会加载SingleHolder，从而初始化instance，同时，由于实例的建立是在类加载时完成的，故天生对多线程友好，getInstance（）方法也不需要使用synchronized修饰，因此，这种实现能兼顾前两种写法的优点（延迟加载，非同步）。

• 工厂

• 抽象工厂

• 代理

• 动态代理

• 适配器

• 装饰

相关算法：

交换值：

    public void sawp(int[] arr,int i,int j){
        arr[i] = arr[i]+arr[j];
        arr[j] = arr[i] - arr[j];
        arr[i] = arr[i] - arr[j];
    }

选择排序：

   //选择排序：
    public void selectSort(){
        int arr[] = {8,11,33,4,55,66,76,43};
        for(int i = 0;i<arr.length; i++){
            for(int j=i+1; j<arr.length;j++){
                if(arr[i] > arr[j]){
                    sawp(arr,i,j);
                }
            }
        }
        //打印
        for(int i = 0;i<arr.length; i++){
            System.out.print(arr[i]+"  ");
        }
    }

冒泡排序：

    //冒泡排序：
    public void maoPaoSort(){
        int arr[] = {98,11,33,4,55,66,76,43};
        for(int i = 0;i<arr.length-1; i++){
            for(int j=0; j<arr.length-1-i;j++){
                if(arr[j] > arr[j+1]){
                    sawp(arr,j,j+1);
                }
            }
        }
        //打印
        for(int h = 0;h<arr.length; h++){
            System.out.print(arr[h]+"  ");
        }
    }

快速排序：

 public static void quickSort(int arr[],int _left,int _right){
        int left = _left;
        int right = _right;
        int temp = 0;
        if(left <= right){   //待排序的元素至少有两个的情况
            temp = arr[left];  //待排序的第一个元素作为基准元素
            while(left != right){   //从左右两边交替扫描，直到left = right

                while(right > left && arr[right] >= temp)  
                     right --;        //从右往左扫描，找到第一个比基准元素小的元素
                  arr[left] = arr[right];  //找到这种元素arr[right]后与arr[left]交换

                while(left < right && arr[left] <= temp)
                     left ++;         //从左往右扫描，找到第一个比基准元素大的元素
                  arr[right] = arr[left];  //找到这种元素arr[left]后，与arr[right]交换

            }
            arr[right] = temp;    //基准元素归位
            quickSort(arr,_left,left-1);  //对基准元素左边的元素进行递归排序
            quickSort(arr, right+1,_right);  //对基准元素右边的进行递归排序
        }        
    }
    public static void main(String[] args) {
        int array[] = {10,5,3,1,7,2,8};
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element+" ");
        }
        
        quickSort(array,0,array.length-1);

        System.out.println("\n排序之后：");
        for(int element : array){
            System.out.print(element+" ");
        }

    }

二分查找：

    public void binarySearch(){
        int arr[] = {1,11,33,44,45,46,47,76,100,200,201};
        int serch = 201;
        int low = 0;
        int hight = arr.length-1;
        int mid = (low + hight)/2 ;
        while(low <= hight){
            if(serch>arr[mid]){
                low = mid+1;
                mid = (low + hight)/2 ;
            }else if(serch<arr[mid]){
                hight = mid-1;
                mid = (low + hight)/2 ;
            }else{
                System.out.print(mid);
                break;
            }
        }
    }

面试题之：某某与某某有什么区别

重载与重写

throw与throws

final finally finalize()

Conllections Conlletions

String StringBuffer StringBuider

抽象类 接口

sleep() wait()：都可以让线程阻塞，Sleep是thread类中的方法，sleep是Objicet中的方法

==与equals()方法有什么区别：==是运算符 比较两个基本数据类型的值，和两个对象的地址值，equals()是object对象的方法，自定义得重写 equals（）方法

2，JAVA——EE

spring,springmvc ,mybitis,springboot,springcloud,dobbo,zookeeper

SPRING

具体来说Spring是一个轻量级的容器，用于管理业务相关对象的。核心功能主要为：IOC,AOP,MVC。

IOD：控制反转，将对象的创建过程交给容器，让容器管理对象的生命周期如创建，初始化，销毁等。

AOP：面向切面编程，对关注点进行模块化，通过对某一功能点进行编程，比如记录日志，有很多个类都需要记录日志的方法，则创建记录日志的代理方法，需要调用该功能是只需要调用代理方法，这就是AOP。

MVC:SpringMvc,Spring提供的基于MVC模式设计的Web框架，如今比较流行的框架之一。

SPRINGMVC

MYBATIS

SPRINGBOOT

传统一体化架构有什么缺点：

• 不灵活——无法使用多种技术去构建一体化应用
• 不可靠——即便系统中只有一个功能不工作了，也会造成整个系统不工作
• 不可扩展——应用无法被轻易地被扩展，因为每次应用需要被升级，都必须重新构建整个系统
• 阻塞持续集成——应用中的很多功能无法同时被构建和部署
• 迭代速度慢——一体化应用中新开发的代码需要很长时间来构建，因为需要一个一个地构建每一块功能。
• 不适用于复杂应用——复杂应用的功能有耦合度很高的依赖

什么是微服务：

微服务，又叫微服务架构，是一种软件架构方式。它将应用构建成一系列按业务领域划分模块的、小的自治服务。在微服务架构中，每个服务都是自我包含的，并且实现了单一的业务功能。

微服务的特点：

• 解耦：同一系统内的服务大部分可以被解耦。因此应用，作为一个整体，可以轻易地被构建、修改和扩展。

• 组件化：微服务可以被看成相互独立的组件，这些组件可以被轻易地替换和升级。

• 业务能力：微服务很小，它们可以专注于某种单一的能力

• 自治：开发者和团队可以独立地工作，提高开发速度。

• 持续交付：允许持续发布软件新版本，通过系统化的自动手段来创建、测试和批准新版本。

• 职责明确：微服务不把应用看成一个又一个的项目。相反，它们把应用当成了自己需要负责的项目。

• 去中心化管理：关注于使用正确的工具来完成正确的工作。这也就是说，没有标准化的方式或者技术模式。开发者们有权选择最好的工具来解决问题。

• 敏捷性：微服务支持敏捷开发。任何新功能都可以被快速开发或丢弃。

SPRINTCLOUD

• ​

DOUBBO

ZOOKEEPER

3，MYSQL NOSQL

mysql,redis,mongo

MYSQL

• 影响mysql的性能因素：

  • 业务对mysql的影响：合适合度
  • 存储定位对mysql的影响：
    • 二进制多媒体数据不适合
    • 流水队列数据不适合
    • 超大文本不适合
  • Schema设计对系统的性能影响
  • 硬件环境
  • 需要放进缓存的数据：
    • 系统各种配置及规则数据
    • 活跃用户的基本信息数据
    • 活跃用户个性化定制信息数据
    • 准实时的统计信息数据
    • 其他一些访问频繁但是数据变更较少的

• 索引：

  • 索引是一种特殊的文件(InnoDB数据表上的索引是表空间的一个组成部分)，它们包含着对数据表里所有记录的引用指针。

  • ALTER TABLE table_name ADD INDEX index_name (column_list) //建索引
    ALTER TABLE table_name ADD UNIQUE (column_list)		//唯一
    ALTER TABLE table_name ADD PRIMARY KEY (column_list) //主键
    

    ​

• 查询优化：

  • 永远小表驱动大表
  • order by
    • 尽量使用 index方式排序，避免出现 filesort
    • 尽量在索引列上完成排序操作，遵照索引建的最佳左前缀
  • ​

• EXPLAIN:使用其关键字可以模拟优器执行SQL查询语句，从而知道mysql如何处理你的sql语句

  • id：id的值越大优先级越高，id值一样从上往下执行
  • select_type: 查询类型
  • table:这一行的数据是关于哪张表出来的
  • type:访问类型排列 从最好到最差依次是 system>const>eq_ref>range>index>all
  • possible_keys:显示可能应用在这张表中的索引，一个或者多个 但是不一定被实现查询使用
  • key:实际使用的索引，如果 为NULL 则没有用到索引
  • key_len：表示 索引中使用的字节数，并非实际使用长度，长度越短越好
  • rows:根据表统计信息及索引选用的情况，大致估算出读取的行数，越小越好
  • extra:额外信息

• 索引优化：

  • 全值匹配
  • 最佳左前缀：如果索引引用了多列，要遵守些原则 ，索引 的最左前列开始且不路过索引中的列
  • 不在索引列上做任何操作（计算、函数、(自动or手动)类型转换）
  • 存储引擎不能使用索引中范围条件右边的列
  • 尽量使用覆盖索引(只访问索引的查询(索引列和查询列一致))，减少select *
  • mysql 在使用不等于(!= 或者<>)的时候无法使用索引会导致全表扫描
  • is null ,is not null 也无法使用索引
  • like以通配符开头(’%abc…’)mysql索引失效会变成全表扫描的操作
  • 字符串不加单引号索引失效
  • 少用or,用它来连接时会索引失效

• 事务：ACID

  • 原子性：Atomicity 一件事做完，要不做，要么做完
  • 一致性：Consistency 事务的运行不改变数据库原本的一致性
  • 独立性：Isolation 事务未提交，数据不会改变
  • 持久性：Durability 事务一旦提交后，即使宕机，也不会丢

REDIS

• 优点：易扩展、灵活的数据模型、高并发，高可扩，高性能、
• CAP理论：是说在分布式存储系统 中，最多只能实现下面两点，三进二，传统关系型数据库CA, 而Redis是CP型数据库
  • 强一致性: Consistency
  • 高可用：Availability
  • 分区容错性：Partiiton tolerance
• 数据结构：
  • String 有序集合
  • List 列表 底层是链表 linkedList
  • Set 集合 相当于java的 hashtalbe
  • Zset 有序集合
  • Hash 哈希 类似于java里的Map
• 主从复制：
  • 能干嘛 ：读写分离与容灾恢复
• 操作：使用spring的RedisTemplate来操作redis

MongDB

• 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库中功能最丰富，最像关系数据库的
• ​

4，前端 js

5，LINUX 环境，GIT,SVN,MAVEN

Linux

• 操作文件及目录常用命令

  命令	中文释义
  ls -l	列出文件详细信息l(list)
  mkdir -p	创建目录，若无父目录，则创建p(parent)
  cd	切换目录
  touch	创建空文件
  echo	创建带有空内容的文件
  cat	查看文件内容
  cp	拷贝
  mv	移动或者重命名
  rm -r	递归删除，可删除子目录及文件
  rm -rf	强制删除
  rm dir -	删除文件夹
  grep	在文本中查询某个字符串
  tree	显示目录结构

• 操作vim常用命令

  命令	中文释义
  :q!	强制退出
  :wq	强制保存并退出
  :set number	显示行号
  :set nonumber	隐藏行号
  /apache	在文档中查找apache 按n跳到下一个，shift+n上一个
  yyp	复制光标所在行，并粘贴

• 查看性能/系统 常用命令

  命令	中文释义
  ifconfig	查看网络情况
  netstat	显示网络状态
  kill	杀进程
  ps	查看进程
  ps -ef|grep tomcat	查看与tomcat有关的进程
  top	动态显示当前耗费资源最多进程信息

• 项目部署常用命令

  命令	中文释义
  tail -f catalina.out	cd usr/local/tomcat8/logs 下执行查看实时日志
  ./startup.sh	cd usr/local/tomcat8/bin 下执行启动tomcat
  ./shutdown.sh	关闭，关不掉，kill

• 打包压缩

  命令	中文释义
  tar -zxvf test.tar.gz	tar 解压
  upzip test.zip	zip 解压
  tar -zcf test.tar.gz /test1 /test2	tar 压缩
  zip -r test.zip /test	zip压缩

• 其它常用命令

6，架构

7，项目

​