面经2020.2.27

最新推荐文章于 2022-09-26 20:26:57 发布

BUG指挥官

最新推荐文章于 2022-09-26 20:26:57 发布

阅读量338

点赞数

本文链接：https://blog.csdn.net/WXF_Sir/article/details/104541188

版权

1、说说常用集合的实现都有哪些？及扩容机制？

List(列表):

List的元素以线性方式存储，可以存放重复对象，List主要有以下两个实现类：

ArrayList : 长度可变的数组，可以对元素进行随机的访问，向ArrayList中插入与删除元素的速度慢。 JDK8 中ArrayList扩容的实现是通过grow()方法里使用语句newCapacity = oldCapacity + (oldCapacity >> 1)（即1.5倍扩容）计算容量，然后调用Arrays.copyof()方法进行对原数组进行复制。

LinkedList: 采用链表数据结构，插入和删除速度快，但访问速度慢。

Set(集合):

Set中的对象不按特定(HashCode)的方式排序，并且没有重复对象，Set主要有以下两个实现类：

HashSet： HashSet按照哈希算法来存取集合中的对象，存取速度比较快。当HashSet中的元素个数超过数组大小*loadFactor（默认值为0.75）时，就会进行近似两倍扩容（newCapacity = (oldCapacity << 1) + 1）。

TreeSet ：TreeSet实现了SortedSet接口，能够对集合中的对象进行排序。

Map(映射):

Map是一种把键对象和值对象映射的集合，它的每一个元素都包含一个键对象和值对象。 Map主要有两个实现类：

HashMap：HashMap基于散列表实现，其插入和查询<K,V>的开销是固定的，可以通过构造器设置容量和负载因子来调整容器的性能。

LinkedHashMap：类似于HashMap，但是迭代遍历它时，取得<K,V>的顺序是其插入次序，或者是最近最少使用(LRU)的次序。

TreeMap：TreeMap基于红黑树实现。查看<K,V>时，它们会被排序。TreeMap是唯一的带有subMap()方法的Map，subMap()可以返回一个子树

HashMap 和 Hashtable 有什么区别？

底层都是数组+链表实现

Hashtable：

1.无论是key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个Hashtable，效率低

2.初始size为11，扩容：newsize＝oldsize*2+1

Hashmap：

1.可以存储null键和null值，线程不安全

2.初始size为16，扩容：newsize ＝oldsize*2，size一定为2的n次幂

null可以作为键，这样的键只有一个，但可以有一个或多个键所对应的值为null.当get（）方法返回null值时，即可以表示Hashmap中没有该key，也可以表示该key所对应的value为null。因此，在Hashmap中不能由get（）方法来判断Hashmap中是否存在某个key，应该用containsKey（）方法来判断。

说一下 HashMap 的实现原理？

HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好

ArrayList 和 Vector 的区别是什么？

1. Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。

2.当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

2 、java 中操作字符串都有哪些类？它们之间有什么区别？

String、StringBuffer、StringBuilder

String : final修饰，String类的方法都是返回new String。即对String对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。

StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。

StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以new StringBuilder对象，调用StringBuilder对象的append、replace、delete等方法修改字符串。

执行效率：String<StringBuffer<StringBuilder

3、JVM的GC回收机制？手动执行GC操作有什么影响？

引用计数法：

给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不再被使用的，垃圾收集器将回收该对象使用的内存。

优点：

引用计数收集器可以很快的执行，交织在程序运行中。对程序需要不被长时间打断的实时环境比较有利。

缺点：

无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0.而且每次加减非常浪费内存。

复制算法

S0和s1将可用内存按容量分成大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另一块内存上去，然后把使用过的内存空间一次清理掉。这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。

复制算法的缺点显而易见，可使用的内存降为原来一半。

复制算法用于在新生代垃圾回收

标记-清除算法

标记-清除（Mark-Sweep）算法顾名思义，主要就是两个动作，一个是标记，另一个就是清除。

标记就是根据特定的算法（如：引用计数算法，可达性分析算法等）标出内存中哪些对象可以回收，哪些对象还要继续用。

标记指示回收，那就直接收掉；标记指示对象还能用，那就留下。

缺点

标记与清除没有连续性效率低;
清除之后内存会产生大量碎片；
标记-整理算法

标记压缩法在标记清除基础之上做了优化，把存活的对象压缩到内存一端,而后进行垃圾清理。(java中老年代使用的就是标记压缩法)

分代收集算法

根据内存中对象的存活周期不同，将内存划分为几块，java的虚拟机中一般把内存划分为新生代和年老代，当新创建对象时一般在新生代中分配内存空间，当新生代垃圾收集器回收几次之后仍然存活的对象会被移动到年老代内存中，当大对象在新生代中无法找到足够的连续内存时也直接在年老代中创建。

对于新生代和老年代来说,新生代回收频率很高,但是每次回收耗时很短,而老年代回收频率较低,但是耗时会相对较长,所以应该尽量减少老年代的GC.

java中手动调用 System.gc();也不能立刻让程序立刻就执行垃圾回收，这个调用相当于“建议”执行垃圾回收，但是什么时候调用是不能确定的！

4、Java的内存结构？

类加载子系统:负责从文件系统或者网络加载Class信息，加载的信息存放在一块称之方法区的内存空间。
方法区:就是存放类的信息、常量信息、常量池信息、包括字符串字面量和数字常量等。
Java堆：在Java虚拟机启动的时候建立Java堆，它是Java程序最主要的内存工作区域，几乎所有的对象实例都存放到Java堆中，堆空间是所有线程共享。
直接内存：JavaNio库允许Java程序直接内存，从而提高性能，通常直接内存速度会优于Java堆。读写频繁的场合可能会考虑使用。
每个虚拟机线程都有一个私有栈：一个线程的Java栈在线程创建的时候被创建，Java栈保存着局部变量、方法参数、Java的方法调用、返回值等。
本地方法栈：最大不同为本地方法栈用于本地方法调用。Java虚拟机允许Java直接调用本地方法（通过使用C语言写）
垃圾收集系统是Java的核心，也是不可少的，Java有一套自己进行垃圾清理的机制，开发人员无需手工清理。
PC（Program Couneter）寄存器也是每个线程私有的空间， Java虚拟机会为每个线程创建PC寄存器，在任意时刻，一个Java线程总是在执行一个方法，这个方法称为当前方法，如果当前方法不是本地方法，PC寄存器总会执行当前正在被执行的指令，如果是本地方法，则PC寄存器值为Underfined，寄存器存放如果当前执行环境指针、程序技术器、操作栈指针、计算的变量指针等信息。
虚拟机核心的组件就是执行引擎，它负责执行虚拟机的字节码，一般户先进行编译成机器码后执行。
方法区和堆为线程共享区，虚拟机栈、本地方法栈及程序计数器为线程独占区。

5、怎么判断对象是否可以被回收？四种引用？

jvm要做垃圾回收时，首先要判断一个对象是否还有可能被使用。那么如何判断一个对象是否还有可能被用到？

如果我们的程序无法再引用到该对象，那么这个对象就肯定可以被回收，这个状态称为不可达。当对象不可达，该对象就可以作为回收对象被垃圾回收器回收

四类引用的区别就在于GC时是否回收该对象

强引用(Strong) 就是我们平时使用的方式 A a = new A();强引用的对象是不会被回收的

软引用(Soft) 在jvm要内存溢出(OOM)时，会回收软引用的对象，释放更多内存

弱引用(Weak) 在下次GC时，弱引用的对象是一定会被回收的

虚引用(Phantom) 对对象的存在时间没有任何影响，也无法引用对象实力，唯一的作用就是在该对象被回收时收到一个系统通知

6、面向对象的特点？子类是否可以重写父类中的静态方法？

封装：根据职责将属性和方法封装到一个抽象的类中；继承:实现代码的重用，相同的代码不需要重复的写；多态：(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果；抽象。

static是一个修饰符，用于修饰成员，（成员变量，成员函数）

static优先于对象存在，因为static的成员随着类的加载就已经存在

static修饰的成员多了一种调用方式，可以被类名调用（类名.静态成员）

static修饰的数据是共享数据，对象中的存储是特有数据

所以子类可以继承父类的静态方法，但不能重写父类的静态方法呈现多态性。

7、说说spring的IOC和AOP？

IOC即控制反转，即由Spring来负责控制对象的生命周期和对象间的相互关系。通常，在实现一个业务逻辑时需要多个对象相互协作来完成，每个对象在使用它的协作对象时都要通过new Obeject()的方式来创建，这样加大了对象间的耦合程度。

AOP即面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
作用场景可以用于权限认证、日志、事务等。

底层基于动态代理实现：首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。

JDK动态代理：基于Java反射机制实现，必须要实现了接口的业务类才能用这种办法生成代理对象。新版本也开始结合ASM机制。

CGLIB动态代理：基于ASM机制实现，通过生成业务类的子类作为代理类。不能应用到被代理对象的final方法上

8、spring项目如何使用过滤器和拦截器？

过滤器：就是过滤的作用，在web开发中过滤一些我们指定的url。比如过拦截掉我们不需要的接口请求，修改请求（request）和响应（response）内容，完成CORS跨域请求等等。

现在我们来实现一个简单的过滤器：
可以新建一个filter包，随着项目的扩大过滤器会越来越多
在这里我新建了一个TestFilter类，实现Filter接口

@Component
@WebFilter(urlPatterns = "/Blogs",filterName = "blosTest")
public class TestFilter implements Filter{}

1.@Component就是把这个类注入到IOC容器中
2.@WebFilter(urlPatterns = "/Blogs",filterName = "blosTest")说明这是一个web过滤器，它拦截的url为/Blogs，过滤器名字为blogsTest

然后实现接口之后的三个重构方法：

@Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request= (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        System.out.printf("过滤器实现");
        filterChain.doFilter(request,response);
    }
 
    @Override
    public void destroy() {
 
    }

初始化（init）和摧毁（destroy）方法一般不会用到，具体使用看下源码便知
doFilter（）是过滤器的核心
注意：在实现接口方法之后，我们要转换request和response类型至HttpServlet，否则接下去的操作可能会报错。
如果过滤通过，执行filterChain.doFilter(request,response);说明这个url已经经过了我们的Filter。

可以看到，只需要一个类我们就实现了一个简单的过滤器

当然可以不用注解的方式，配置启动类

//过滤器
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        List<String> urlPatterns = new ArrayList<String>();
 
        TestFilter testFilter = new TestFilter();   //new过滤器
        urlPatterns.add("/Blogs");      //指定需要过滤的url
        filterRegistrationBean.setFilter(testFilter);       //set
        filterRegistrationBean.setUrlPatterns(urlPatterns);     //set
 
        return filterRegistrationBean;
    }

拦截器：可以新建一个interceptor包
在里面新建一个名为MyInterceptor的类

public class MyInterceptor implements HandlerInterceptor {}

这个类实现了HandleInterceptor接口

public class MyInterceptor implements HandlerInterceptor {
    //在请求处理之前进行调用（Controller方法调用之前
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.printf("preHandle被调用");
        return true;    //如果false，停止流程，api被拦截
    }
 
    //请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle被调用");
    }
 
    //在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("afterCompletion被调用");
    }
}

它依次实现了三个方法
相比过滤器，拦截器还需要在springmvc中注入
所以我们打开启动类，写入以下代码

public class WarApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(WarApplication.class, args);
    }
 
    //mvc控制器
    //@Configuration
    static class WebMvcConfigurer extends WebMvcConfigurerAdapter{
        //增加拦截器
        public void addInterceptors(InterceptorRegistry registry){
            registry.addInterceptor(new MyInterceptor())    //指定拦截器类
                    .addPathPatterns("/Handles");        //指定该类拦截的url
        }
    }
}

拦截器是AOP( Aspect-Oriented Programming)的一种实现，底层通过动态代理模式完成。

区别：

（1）拦截器是基于java的反射机制的，而过滤器是基于函数回调。

（2）拦截器不依赖于servlet容器，而过滤器依赖于servlet容器。

（3）拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

（4）拦截器可以访问action上下文、值栈里的对象，而过滤器不能。

（5）在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

9、Mybatis 中 #{}和 ${}的区别是什么？

1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成的sql为order by "id".

2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为order by user_id, 如果传入的值是id，则解析成的sql为order by id.

3. #方式能够很大程度防止sql注入。　　

4.$方式无法防止Sql注入。

5.$方式一般用于传入数据库对象，例如传入表名.

6.一般能用#的就别用$. MyBatis排序时使用order by 动态参数时需要注意，用$而不是#

10、说一下 mybatis 的一级缓存和二级缓存？

一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构用于存储缓存数据。不同的sqlSession之间的缓存数据区域是互相不影响的。也就是他只能作用在同一个sqlSession中，不同的sqlSession中的缓存是互相不能读取的。

一级缓存的工作原理：用户发起查询请求，查找某条数据，sqlSession先去缓存中查找，是否有该数据，如果有，读取；如果没有，从数据库中查询，并将查询到的数据放入一级缓存区域，供下次查找使用。但sqlSession执行commit，即增删改操作时会清空缓存。这么做的目的是避免脏读。如果commit不清空缓存，会有以下场景：A查询了某商品库存为10件，并将10件库存的数据存入缓存中，之后被客户买走了10件，数据被delete了，但是下次查询这件商品时，并不从数据库中查询，而是从缓存中查询，就会出现错误。

一级缓存是mybatis默认开启的

二级缓存原理：二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。UserMapper有一个二级缓存区域（按namespace分），其它mapper也有自己的二级缓存区域（按namespace分）。每一个namespace的mapper都有一个二级缓存区域，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。
二级缓存是mybatis默认关闭的，开启需要配置。

11、Springboot的核心注解？如何理解Springboot的starter？Springboot配置文件的几种形式?如何读取配置文件

@SpringBootApplication注解是@Configuration,@EnableAutoConfiguration,@ComponentScan三个注解的组合。

@SpringBootConfiguration：这是Spring Boot 项目的相关配置注解，其实它也是一个组合注解。

@EnableAutoConfiguration：启用自动配置，该注解会使Spring Boot根据项目中依赖的jar包自动配置项目的配置项：如：我们添加了spring-boot-starter-web的依赖，项目中也就会引入SpringMVC的依赖，并且Spring Boot会自动配置tomcat 和SpringMVC。

利用starter实现自动化配置只需要两个条件——maven依赖、配置文件，这里简单介绍下starter实现自动化配置的流程。
引入maven实质上就是导入jar包，spring-boot启动的时候会找到starter jar包中的resources/META-INF/spring.factories文件，根据spring.factories文件中的配置，找到需要自动配置的类

SpringBoot的配置文件有yml文件与properties文件两种形式，@Value和引入Environment，env.getProperty("config.name")

12、数据库的隔离级别？索引结构？

未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据

提交读(Read Committed)：只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别 (不重复读)

可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读

串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞

① 脏读: 脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

② 不可重复读:是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

③ 幻读:第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。
索引的数据结构：B-、B+、R-、散列

B-树索引实现是一个专门为范围查询设计的。

B-树结构支持插入、控制操作以及通过管理一系列树根状结构的彼此联通的节点中来做选择。B-树结构中有两种节点类型：索引节点和叶子节点。叶子节点是存储数据的，而索引节点是用来告诉用户存储在叶子节点中的数据的顺序，并帮助用户找到数据。B-树不是二叉树，二叉树只是一种简单的节点层次结构的实现。

B+树是B-树结构的增强版，尽管B+树支持B-树的所有特性，他们之间最显著的不同点在于B+树中底层数据是按照提及的索引列进行排序的。B+树还通过在叶子节点之间附加引用来优化扫描的性能

散列表数据结构是一个简单的概念，他将一种算法应用到给定值中以在底层数据存储系统中返回一个唯一的指针或位置。散列表的优点是始终以线性时间复杂度找到需要读取的行的位置，而不想B-树那样需要跨越多层节点来确定位置。

R-树数据结构支持基于数据类型对集合数据进行管理。目前只有MyIsam使用R-树支持空间索引。使用空间索引也有很多限制，比如只支持唯一的NOT NULL 列等。空间索引并不常用

索引的分类：常见的索引类型有：主键索引、唯一索引、普通索引、全文索引、组合索引

1、主键索引：即主索引，根据主键pk_clolum（length）建立索引，不允许重复，不允许空值；

2、唯一索引：用来建立索引的列的值必须是唯一的，允许空值

3、普通索引：用表中的普通列构建的索引，没有任何限制

4、全文索引：用大文本对象的列构建的索引（下一部分会讲解）

5、组合索引：用多个列组合构建的索引，这多个列中的值不允许有空值

13、什么是死锁？死锁的四个必要条件？怎么防止死锁？

　线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。当线程进入对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调用wait方法，才释放资源，在此期间，其他线程将不能进入该代码块。当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁。

1.互斥条件：一个资源每次只能被一个进程使用，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

2.请求与保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

3.不可剥夺条件:进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。

4.循环等待条件: 若干进程间形成首尾相接循环等待资源的关系

避免死锁的技术：加锁顺序、加锁时限、死锁检测

14、乐观锁和悲观锁？

乐观锁

乐观锁不是数据库自带的，需要我们自己去实现。乐观锁是指操作数据库时(更新操作)，想法很乐观，认为这次的操作不会导致冲突，在操作数据时，并不进行任何其他的特殊处理（也就是不加锁），而在进行更新后，再去判断是否有冲突了。

通常实现是这样的：在表中的数据进行操作时(更新)，先给数据表加一个版本(version)字段，每操作一次，将那条记录的版本号加1。也就是先查询出那条记录，获取出version字段,如果要对那条记录进行操作(更新),则先判断此刻version的值是否与刚刚查询出来时的version的值相等，如果相等，则说明这段期间，没有其他程序对其进行操作，则可以执行更新，将version字段的值加1；如果更新时发现此刻的version值与刚刚获取出来的version的值不相等，则说明这段期间已经有其他程序对其进行操作了，则不进行更新操作。

悲观锁

与乐观锁相对应的就是悲观锁了。悲观锁就是在操作数据时，认为此操作会出现数据冲突，所以在进行每次操作时都要通过获取锁才能进行对相同数据的操作，这点跟java中的synchronized很相似，所以悲观锁需要耗费较多的时间。另外与乐观锁相对应的，悲观锁是由数据库自己实现了的，要用的时候，我们直接调用数据库的相关语句就可以了