阿里内部面试总结

最新推荐文章于 2022-02-09 17:20:48 发布
最新推荐文章于 2022-02-09 17:20:48 发布
阅读量361 收藏 1
点赞数
分类专栏： Java 文章标签： Java

目录：

  1. StringBuffer和StringBuilder有什么区别？假设有一个方法，方法内部需要定义一个对象，可能是StringBuffer或StringBuilder，接下来会多次append操作，方法结束时，返回这个对象的toString()结果，并且这个线程会被多线程并发访问，请选择这个对象是被定义成StringBuffer或者StringBuilder？为什么？

  2. synchronized有什么用？如何使用？(伪代码，把所有使用方式都分别列出来)

  3. ReentranLock类有什么作用？它常用的方法有哪几个？分别有什么特点？

  4. 集群环境下多机器间进行同步操作有什么可选的解决方案？(最好用伪代码写出关键部分)

  5. 列出乐观锁的设计要点和使用方法？

  6. 何为幂等性控制？举一个例子说明你之前如何实现幂等性控制？(或在项目IDCM中如何实现幂等性控制？)

  7. spring实现aop用到的关键技术是什么？

  8. HashMap和ConcurrentHashMap有什么区别和特点？

  9. java.util.concurrent package下，你用过哪些类？分别有什么用途和特点？

  10. 如果一张表数据量较大，影响了查询性能，可以有哪些优化方案？建立索引有什么原则？

  11. 说一说数据库事务隔离级别的理解?(项目IDCM中是如何使用的？)

  12. Spring中注解@Component @Repository @Service @Controller的区别?(项目IDCM中context:component-scan注解扫描是如何配置的？)

 

 

 

1.StringBuffer和StringBuilder有什么区别？假设有一个方法，方法内部需要定义一个对象，可能是StringBuffer或StringBuilder，接下来会多次append操作，方法结束时，返回这个对象的toString()结果，并且这个线程会被多线程并发访问，请选择这个对象是被定义成StringBuffer或者StringBuilder？为什么？

　　答：StringBuffer是线程安全的；StringBuilder是线程不安全的。

复制代码

1.先来看String StringBuffer StringBuilder定义。final修饰的类不能被继承，即不能拥有子类。 
    public final class StringBuffer 
    public final class StringBuilder 
    public final class String 

2.关于appdend方法的源码如下： 
    public synchronized StringBuffer append(String str) {
             toStringCache = null; 
             super.append(str); 
             return this;
    } 

    public StringBuilder append(String str) { 
        super.append(str); 
        return this; 
    } 
3.对于经常变动的字符串才会考虑使用StringBuilder和StringBuffer，使用StringBuilder效率比StringBuffer高，StringBuffer可以保证线程安全，而StringBuilder不能。

复制代码

2.synchronized有什么用？如何使用？(伪代码，把所有使用方式都分别列出来)

　　答：synchronized是Java语言的关键字，同时也是一个可重入锁。当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。synchronized用于修饰方法和代码块。

复制代码

package basic;public final class TestSynchronized {    public static void main(String[] args) {        new Thread("线程A") {

            @Override            public void run() {                try {
                    print("线程A ...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {                try {
                    print("线程B ...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }    public static synchronized void print(String str) throws InterruptedException {
        System.out.println("当前线程：" + Thread.currentThread().getName() + "执行开始");        for (int i = 0; i < 10; i++) {
            System.out.println(str);
            Thread.sleep(2000);
        }
        System.out.println("当前线程：" + Thread.currentThread().getName() + "执行完毕");
    }
} 
// 代码执行结果： 
//当前线程：线程A执行开始 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//当前线程：线程A执行完毕//当前线程：线程B执行开始 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//当前线程：线程B执行完毕

复制代码

　　synchronized在修饰方法的同时，还可以修饰代码块，示例代码如下：

复制代码

package basic;public class SynchronizedExample {    public static void main(String[] args) {        new Thread("线程A") {

            @Override            public void run() {
                print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                print("线程B");
            }
        }.start();
    }    public static void print(String str) {
        System.out.println("线程： " + Thread.currentThread().getName() + "开始执行");        synchronized (SynchronizedExample.class) {            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "打印了信息：" + i);                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程： " + Thread.currentThread().getName() + "执行结束");
    }
}// 代码执行结果：// 线程： 线程A开始执行// 线程A打印了信息：0// 线程： 线程B开始执行// 线程A打印了信息：1// 线程A打印了信息：2// 线程A打印了信息：3// 线程A打印了信息：4// 线程A打印了信息：5// 线程A打印了信息：6// 线程A打印了信息：7// 线程A打印了信息：8// 线程A打印了信息：9// 线程： 线程A执行结束// 线程B打印了信息：0// 线程B打印了信息：1// 线程B打印了信息：2// 线程B打印了信息：3// 线程B打印了信息：4// 线程B打印了信息：5// 线程B打印了信息：6// 线程B打印了信息：7// 线程B打印了信息：8// 线程B打印了信息：9// 线程： 线程B执行结束

复制代码

　　接下来详细说明synchronized在修饰方法的时候的细节。synchronized是对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”，类的两个不同实例就没有这种约束了。那么static synchronized恰好就是要控制类的所有实例的访问了，static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码快。实际上，在类中某方法或某代码块中有synchronized，那么在生成一个该类实例后，该类也就有一个监视快，放置线程并发访问改实例synchronized保护快，而static synchronized则是所有该类的实例公用一个监视快了，也就是两个的区别了,也就是synchronized相当于this.synchronized，而static synchronized相当于Something.synchronized。

复制代码

package basic;public class SynchronizedExample {    public static void main(String[] args) {        final MySynchronized mySynchronized = new MySynchronized();        new Thread("线程A") {

            @Override            public void run() {
                mySynchronized.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                mySynchronized.print("线程B");
            }
        }.start();
    }
}class MySynchronized {    public synchronized void print(String str) {
        System.out.println("线程： " + Thread.currentThread().getName() + "开始执行");        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "打印了信息：" + i);            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("线程： " + Thread.currentThread().getName() + "执行结束");
    }
} 
// 代码运行结果： 
//线程： 线程A开始执行 
//线程A打印了信息：0 
//线程A打印了信息：1 
//线程A打印了信息：2 
//线程A打印了信息：3 
//线程A打印了信息：4 
//线程A打印了信息：5 
//线程A打印了信息：6 
//线程A打印了信息：7//线程A打印了信息：8 
//线程A打印了信息：9 
//线程： 线程A执行结束 
//线程： 线程B开始执行 
//线程B打印了信息：0 
//线程B打印了信息：1 
//线程B打印了信息：2 
//线程B打印了信息：3 
//线程B打印了信息：4 
//线程B打印了信息：5//线程B打印了信息：6 
//线程B打印了信息：7 
//线程B打印了信息：8 
//线程B打印了信息：9 
//线程： 线程B执行结束 package basic;public class SynchronizedExample {    public static void main(String[] args) {        final MySynchronized mySynchronized_first = new MySynchronized();        final MySynchronized mySynchronized_second = new MySynchronized();        new Thread("线程A") {

            @Override            public void run() {
                mySynchronized_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                mySynchronized_second.print("线程B");
            }
        }.start();
    }
}class MySynchronized {    public synchronized void print(String str) {
        System.out.println("线程： " + Thread.currentThread().getName() + "开始执行");        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "打印了信息：" + i);            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("线程： " + Thread.currentThread().getName() + "执行结束");
    }
}//代码运行结果： 
//线程： 线程A开始执行 
//线程A打印了信息：0 
//线程： 线程B开始执行 
//线程B打印了信息：0 
//线程A打印了信息：1 
//线程B打印了信息：1 
//线程A打印了信息：2 
//线程B打印了信息：2 
//线程A打印了信息：3//线程B打印了信息：3 
//线程A打印了信息：4 
//线程B打印了信息：4 
//线程A打印了信息：5 
//线程B打印了信息：5 
//线程A打印了信息：6 
//线程B打印了信息：6 
//线程A打印了信息：7 
//线程B打印了信息：7 
//线程A打印了信息：8//线程B打印了信息：8 
//线程A打印了信息：9 
//线程B打印了信息：9 
//线程： 线程A执行结束 
//线程： 线程B执行结束 package basic;public class SynchronizedExample {    public static void main(String[] args) {        final MySynchronized mySynchronized_first = new MySynchronized();        final MySynchronized mySynchronized_second = new MySynchronized();        new Thread("线程A") {

            @Override            public void run() {
                mySynchronized_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                mySynchronized_second.print("线程B");
            }
        }.start();
    }
}class MySynchronized {    public static synchronized void print(String str) {
        System.out.println("线程： " + Thread.currentThread().getName() + "开始执行");        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "打印了信息：" + i);            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("线程： " + Thread.currentThread().getName() + "执行结束");
    }
}//代码运行结果： 
//线程： 线程A开始执行 
//线程A打印了信息：0//线程A打印了信息：1 
//线程A打印了信息：2 
//线程A打印了信息：3 
//线程A打印了信息：4 
//线程A打印了信息：5 
//线程A打印了信息：6 
//线程A打印了信息：7//线程A打印了信息：8 
//线程A打印了信息：9 
//线程： 线程A执行结束 
//线程： 线程B开始执行 
//线程B打印了信息：0 
//线程B打印了信息：1 
//线程B打印了信息：2 
//线程B打印了信息：3 
//线程B打印了信息：4 
//线程B打印了信息：5//线程B打印了信息：6 
//线程B打印了信息：7 
//线程B打印了信息：8 
//线程B打印了信息：9 
//线程： 线程B执行结束

复制代码

　　上述代码完整的展示了static synchronized和synchronized的用法。synchronized针对同一个实例不能访问，针对不同的实例可以同时访问。static synchronized针对所有的实例均不能同时访问。synchronized本来就是修饰方法的，后来引申出synchronized修饰代码块，只是为了可以更精确的控制冲突限制的访问区域，使得表现更加高效率。synchronized方法只能锁定现阶段的对象，而synchronized区块可以锁定指定的对象，指定的对象直接跟在synchronized()括号之后。此外，synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。还有synchronized不能被继承，继承时子类的覆盖方法必须显示定义成synchronized。

　　除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(object){/*区块*/}，它的作用域是object对象。当一个线程执行时，将object对象锁住，另一个线程就不能执行对应的块。synchronized方法实际上等同于用一个synchronized块包住方法中的所有语句，然后在synchronized块的括号中传入this关键字。当然，如果是静态方法，需要锁定的则是class对象。可能一个方法中只有几行代码会涉及到线程同步问题，所以synchronized块比synchronized方法更加细粒度地控制了多个线程的访问，只有synchronized块中的内容不能同时被多个线程所访问，方法中的其他语句仍然可以同时被多个线程所访问（包括synchronized块之前的和之后的）。

复制代码

package basic;public class TestSynchronizedObject {    public static void main(String[] args) {        final MyObject myObject_first = new MyObject();        final MyObject myObject_seconde = new MyObject();        new Thread("线程A") {

            @Override            public void run() {
                myObject_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() { /* * 同一个实例，实现了互斥访问 */
                myObject_first.print("线程B"); /* * 不同的实例，并不能够实现互斥访问 */
                myObject_seconde.print("线程B");
            }
        }.start();
    }
}class MyObject {    /**
     * * synchronized(this)的用法相当于synchronized直接修饰方法<br/>
     * * 只针对一个实例的时候有效，针对多个实例的时候无效     */
    public void print(String str) {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");        synchronized (this) {            for (int i = 0; i < 10; i++) {
                System.out.println(str + " ." + i + ". ");                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "执行结束");
    }
}package basic;public class TestSynchronizedObject {    public static void main(String[] args) {        final MyObject myObject_first = new MyObject();        final MyObject myObject_seconde = new MyObject();        new Thread("线程A") {

            @Override            public void run() {
                myObject_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                myObject_seconde.print("线程B");
            }
        }.start();
    }
}class MyObject {    /**
     * * synchronized(MyObject.class)的用法相当于static synchronized修饰方法<br/>
     * * 在针对多个实例的情况下,互斥有效,但是synchronized括号后面要指定正确的对象信息     */
    public void print(String str) {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");        /*
         * 1、synchronized(MyObjcet.class)可以正确的实现互斥效果 ,因为调用的是MyObject的对象。         */
        synchronized (MyObject.class) {            for (int i = 0; i < 10; i++) {
                System.out.println(str + " ." + i + ". ");                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "执行结束");
    }
}

复制代码

　　总结：synchronized方法是一种粗粒度的并发控制，在某一时刻，只能有一个线程执行该synchronized方法。synchronized块则是一种细粒度的鬓发控制，只会将块中的代码同步，位于方法内，synchronized块之外的代码是可以被多个线程同时访问到的。关于synchronized修饰代码块的详细细节可以参考附录[1]和附录[2]。

3.ReentrantLock类有什么作用？它常用的方法有哪几个？分别有什么特点？（读法：Re-entrantLock）

　　上面的的synchronized和ReentranLock是最经典的可重入锁，在面试中经常有问到两种锁的对比。先介绍ReentranLock的使用和代码示例，接着再分析ReentranLock和synchronized的具体区别。

4.集群环境下多机器间进行同步操作有什么可选的解决方案？(最好用伪代码写出关键部分)

　　reids

5.列出乐观锁的设计要点和使用方法？

6.何为幂等性控制？举一个例子说明你之前如何实现幂等性控制？(或在项目IDCM中如何实现幂等性控制？)

7.spring实现aop用到的关键技术是什么？

8.HashMap和ConcurrentHashMap有什么区别和特点？

9.java.util.concurrent package下，你用过哪些类？分别有什么用途和特点？

10.如果一张表数据量较大，影响了查询性能，可以有哪些优化方案？建立索引有什么原则？

11.说一说数据库事务隔离级别的理解?(项目IDCM中是如何使用的？)

12.Spring中注解@Component @Repository @Service @Controller的区别?(项目IDCM中context:component-scan注解扫描是如何配置的？)

 

附录：

[1] https://segmentfault.com/q/1010000005945389?_ea=960340 

[2] https://segmentfault.com/q/1010000005944096?_ea=959633

aedvance
关注
专栏目录
Java面试资料-高清完整PDF版(集合、IO、多线程、反射前端知识、框架).rar
06-21
Java常见面试题集合，详细版，包含面向对象基础、集合、IO、多线程、反射、前端知识、框架等。
阿里内部10万字java面试题pdf.zip
01-05
包括各大厂最新面试题以及面经，还有涉及JVM，Mysql，并发，Spring，Mybatis，Redis，MQ，Zookeeper，Netty，Dubbo，Spring Boot，Spring Cloud，数据结构与算法，设计模式，网络与操作系统等相关技术领域的大厂面试...
K8S+Docker理论与实践深度集成
m0_57081562的博客
06-26 118
前言： 这篇文章主要介绍了26道Spring经典面试题总结(附带答案)的相关资料,小编在网上看到的觉得挺不错的，现在分享给大家，希望对你们有所帮助。 另外本人整理收藏了多家公司面试知识点整理 ，以及各种Java核心知识点免费分享给大家，下方只是部分截图 想要资料的话也可以在文末领取 汇总技术架构路线，梳理技术盲区（条理清晰，一清二楚） 在技术汇总中，可以看到有一些是自己常用的，也有一些是当前工作经历下没用接触过的。那么这些以上的技术栈，你有想过他们是怎么互相配合，组装出一张技术架构图吗?每一个地方用什么技
IO流面试题
t0404的博客
07-12 3万+
1.什么是比特(Bit),什么是字节(Byte),什么是字符(Char),它们长度是多少,各有什么区别 答案 Bit最小的二进制单位 ，是计算机的操作部分 取值0或者1 Byte是计算机操作数据的最小单位由8位bit组成 取值（-128-127） Char是用户的可读写的最小单位，在java里面由16位bit组成 取值（0-65535） Bit 是最小单位 计算机 只能认识 0或者1  8...
Java 面试考点(三)------IO篇
qq_34828100的博客
07-29 148
3.IO Java IO流详解（面试不要再问我IO流）/Java常见面试题汇总-----------Java基础（NIO与IO的区别） Java IO面试知识点/转BIO，NIO和AIO讲的很明白的文章/java BIO、NIO、AIO详解
程序员们疯传的阿里P8呕心沥血总结:10万字JAVA面试总结分享《10万字总结.pdf》
03-20
在阿里内部上班，直接去取经，然后就得到了这个号称：《阿里P8呕心沥血10万字的JAVA面试资料》 里面总共含了基础篇、JVM 篇、多线程 &并发篇、Spring 篇、MyBatis 篇、Spring Boot 篇、MySQL 篇、Redis 篇、Spring ...
阿里巴巴技术面试总结
09-18
### 阿里巴巴技术面试总结 #### 关键知识点概览 - **Java技术要点** - **C语言技术** - **面试流程解析** - **面试经验分享** #### Java技术要点详解 1. **HTTP与HTTPS的区别** - **定义**： - **HTTP ...
阿里面试问题总结.docx
07-01
根据提供的文档信息，以下是对阿里巴巴面试中出现的关键知识点的详细解析： ### 1. 阿里巴巴面试问题概述 #### 项目介绍 - **主要内容**：面试官通常会让候选人详细介绍自己的项目经历，特别是那些与应聘职位密切...
【吐血整理】阿里前端面试题总结（1）【超全超细带答案！！】
10-12
本文汇总了大量阿里前端面试中可能遇到的问题，并附有详细解答，涵盖了HTML、CSS、浏览器机制、性能优化等多个前端知识点。下面将重点知识进行详细解读。 1. HTML知识部分 - DOCTYPE的作用是声明文档类型，防止...
Java面试IO篇（四）
weixin_44802301的博客
02-09 252
IO中的流分为几种？ 按照流的流向分：可以分为输入流和输出流； 按照流的单元划分：可以分为字节流和字符流； 按照流的角色划分：可以分为处理流和节点流。 JavaIO流设计40多个类，看起来非常杂乱，实则非常规则，类与类之间有极强的联系，JavaIO流的这40个类基本都时由以下四个抽象类基类派生出来的。 InputStream/Reader：所有输入流的基类，前者是字节输入流，后者是字符输入流； OutputStream/Writer：所有输出流的基类，前者是字节输出流，后者是字符输出流；
java IO流面试题和选择题
Bubble1210的博客
03-09 5万+
1.PrintStream、BufferedWriter、PrintWriter的比较?  PrintStream类的输出功能非常强大，通常如果需要输出文本内容，都应该将输出流包装成PrintStream后进行输出。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了
java 可重入锁ReentrantLock的介绍
weixin_30628801的博客
09-15 778
java 可重入锁ReentrantLock的介绍 一个小例子帮助理解（我们常用的synchronized也是可重入锁） 话说从前有一个村子，在这个村子中有一口水井，家家户户都需要到这口井里打水喝。由于井水有限，大家只能依次打水。为了实现家家有水喝，户户有水用的目标，村长绞尽脑汁，最终想出了一个比较合理的方案。 首先，在水井边上安排一个看井人，...
BIO,NIO,AIO 简要总结
VicterTian的博客
02-23 1495
文章目录BIO,NIO,AIO 总结1. BIO (Blocking I/O)1.1 传统 BIO1.2 伪异步 IO1.3 代码示例1.4 总结2. NIO (New I/O)2.1 NIO 简介2.2 NIO的特性/NIO与IO区别1)Non-blocking IO（非阻塞IO）2)Buffer(缓冲区)3)Channel (通道)4)Selectors(选择器)2.3 NIO 读数据和写数据...
Java基础知识面试题（2020最新版）
热门推荐
ThinkWon的博客
02-19 131万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
Java IO流处理 面试题汇总
程裕强的专栏
01-27 10万+
说明：本节内容来源于网络汇总 输入输出流是相对于内存而言的！ 1、面试题汇总 （1）java中有几种类型的流？ 字符流和字节流。字节流继承inputStream和OutputStream,字符流继承自InputSteamReader和OutputStreamWriter。 （2）谈谈Java IO里面的常见类，字节流，字符流、接口、实现类、方法阻塞 答：输入流就...
一线互联网常见的 14 个 Java 面试题，你颤抖了吗程序员
weixin_33955681的博客
07-25 98
跳槽不算频繁，但参加过不少面试（电话面试、face to face 面试），面过大 / 小公司、互联网 / 传统软件公司，面糊过（眼高手低，缺乏实战经验，挂掉），也面过人，所幸未因失败而气馁，在此过程中不断查缺补漏，养成了踏实、追本溯源、持续改进的习惯，特此将自己经历过、构思过的一些面试题记录下来，如果答案有问题，欢迎拍砖讨论，希望能对找...
java IO、 NIO面试题
zhangxiaoyang0的专栏
01-30 1万+
Java 中，直接缓冲区与非直接缓冲器有什么区别 物理磁盘->内核地址空间->用户地址空间->应用程序 OS -> JVM 直接缓冲区：内核地址空间和用户地址空间之间形成了一个物理内存映射文件，减少了之间的copy过程。 存在风险：用户不易控制、GC 非直接缓冲区：通过allo
Java面试必备：10万字阿里内部资料解析
这份资料特别提到了阿里内部的面试题，强调了在实际面试中可能会遇到的问题。 Java语言的特点： 1. 简单易学：Java的设计目标之一就是易于学习和使用，它吸收了C++的优点，同时去除了C++中复杂的指针操作。 2. 面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值