Java面试题笔记 -------- 基础篇查找和排序

已于 2022-11-10 16:44:18 修改
阅读量250 收藏
点赞数
分类专栏： 后端面试题 文章标签： 面试 java
于 2022-06-06 20:36:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68021935/article/details/124908046
版权

目录

1、二分查找

2、冒泡排序

3、选择排序

4、插入排序

5、希尔排序

6、快速排序

7、设计模式

1、二分查找

学习目标：

  • 掌握手写二分查找的代码和细节
  • 快速解答二分查找的选择题

二分查找步骤分析：

1. 前提：有已经排好序的数组A

2. 定义左边界L，有边界R，确定搜素范围，循环执行二分查找

3. 获取中间索引M=Floor((L+R)/2)

4. 中间索引的值 A[M]与待搜索的值T比较

  1. A[M]==T，返回中间索引
  2. A[M] > T，中间值右侧的其它元素大于T，中间索引左边去找，R=M-1 设置有边界，重新查找
  3. A[M] < T，中间值左侧的其它元素都小于T，中间索引右边去找，L=M+1 设置左边界，重新查找

5. 当L > R时，表示没有找到，结束循环。

算法代码分析:

public class BinarySearch {
    public static void main(String[] args){
        int[] array = {1,5,8,11,19,22,31,35,40,45,48,49,50};
        int target = 48;
        int idx = binarySearch(array, target);
        System.out.println(idx);
    }


    //二分查找找到返回元素的索引
    public static int binarySearch (int[] a, int t) {
        int l = 0, r = a.length -1, m;
        while (l <= r){
            m = (l + r) / 2;
            if (a[m] == t) {
                return a[m];
            } else if (a[m] > t){
                return r = m - 1;
            } else {
                return l = m + 1;
            }
        }
        return -1;
    }

}

如何避免中间索引整数溢出的问题？

public class IntegerOverflow {
    public static void main(String[] args) {
        int l = 0;
        int r = Integer.MAX_VALUE - 1;

        int m = (l + r) / 2;  //l/2 + r/2 ====> l + (-l/2 + r/2) ===>l + (r-l)/2
        int m = l + (r-l)/2;   //方法一：解决溢出问题

        int m = (l + r) >>> 1;  //方法二：无符号右移位1位
        System.out.println(m);

        //在右侧;溢出
        l = m + 1;
        m = l + (r-l)/2;

        m = (l + r) >>> 1;
        System.out.println(m);

        System.out.println(126 + 63);
        System.out.println((126 + 63)/2);
        System.out.println((126 + 63) >>> 1);

    }
}

面试真题：

1. 有一个有序表1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找48时，查找成功需要比较的次数（4次）？(京东实习生招聘)

2.使用二分法在序列1,4,6,7,15,33,39,50,64,78,75,81,89,96 查找81需要经过（4）次查找？(美团点评校招)

奇数二分取中间；偶数二分取中间靠左

3. 在已经的128个数组中二分查找一个数，需要比较的次数最多不超过多少次？（北京易道博识社招）

2、冒泡排序

学习目标：

  • 掌握常见的排序算法（快排、冒泡、选择、插入等）的实现思路
  • 手写冒泡、快排的代码
  • 了解各个排序算法的特性，如时空复杂度、是否稳定

思路分析：

1. 依次比较数组中相邻两个元素大小，如果a[i] > a[i+1]，则交换两个元素，两两比较一遍称为一轮冒泡，结果让最大的元素排至最后

2. 重复以上步骤。

算法代码分析：

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5,9,7,4,1,3,2,8};
//        int[] a = {1,2,3,4,5,6,7,8,9};
        bubble(a);
    }


    public static void bubble(int[] a) {

        /**
            原始冒泡代码
        */

        for (j=0; j < a.length-1; j++){
        //一轮冒泡后的结果
            for (int i = 0; i < a.length - 1;i++) {
                System.out.println("比较次数：" + i);
                if (a[i] > a[i+1]) {
                swap(a, i, i+1);
                }
            }
            System.out.println("第"+j+"轮冒泡"+Array.toString(a));
        }

        
          /**
              优化一轮的比较次数
          */
          for (j=0; j < a.length-1; j++){
        //一轮冒泡后的结果            
            for (int i = 0; i < a.length - 1 - j;i++) {
                System.out.println("比较次数：" + i);
                if (a[i] > a[i+1]) {
                swap(a, i, i+1);
                }
            }
            System.out.println("第"+j+"轮冒泡"+Array.toString(a));
        }

        /**
            优化需要经过几轮的冒泡次数
        */

        for (j=0; j < a.length-1; j++){
        //一轮冒泡后的结果
            boolean swaped = false;  //判断相邻两次是否发生交换
            for (int i = 0; i < a.length - 1 - j;i++) {
                System.out.println("比较次数：" + i);
                if (a[i] > a[i+1]) {
                swap(a, i, i+1);
                }
            }
            System.out.println("第"+j+"轮冒泡"+Array.toString(a));
            if (!swaped) {
                break;
            }

        }


        /**
            最终优化代码：当前索引作为下一轮的比较次数
        */
         int n = a.length - 1;
       while (true) {
        //一轮冒泡后的结果
            int last = 0;   //表示最后一次交换索引的位置            
            for (int i = 0; i < n;i++) {
                System.out.println("比较次数：" + i);
                if (a[i] > a[i+1]) {
                    swap(a, i, i+1);
                    n == last;
                }
            }
            System.out.println("第轮冒泡"+Array.toString(a));
            if (n == 0) {
                break;
            }

        }

    }


    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;

    }
}

3、选择排序

算法代码实现：

public class SelectSort {
    
    public static void main(String[] args) {
        int[] a = {5,3,7,2,1,9,8,4};
        selection(a);
    }


    public static void selection(int[] a) {
        for (int i = 0; i < a.length - 1; i++){
            //i 代表每轮选择最小元素要交换的目标索引
            int s = i;    //代表最小元素的索引
            for (int j = s + 1; j < a.length; j++){
                if (a[s] > a[j]){
                    s = j;
                }
            }
            if (s != i) {
                swap(a, s, i);
            }
            System.out.println("每轮选择排序"+Array.toString(a));
        }
    }

}

思路分析：

  1.  将数组分为两个子集，排序和未排序的，每一轮从未排序的子集中选出最小的元素，放入已排序的子集。
  2.  重复以上步骤，直到整个数组有序

冒泡排序和选择排序的比较：

1. 二者平均时间复杂度O(n^2)

2. 选择排序一般快于冒泡，因为交换次数少

3. 如果集合的有序度高，冒泡优于选择

4. 冒泡属于稳定的排序算法，而选择属于不稳定排序

4、插入排序

算法代码实现

public class InsertSort {
    public static void main(String[] args){
        int[] a = {9,3,7,2,5,8,1,4};
        insert(a);
        
    }

    private static void insert(int[] a){
        //i 代表待插入元素的索引
        for (int i = 1; i < a.length; i++){
            int t = a[i];  //临时变量，存待插入的元素值
            int j = i - 1; //代表已排序区域的元素索引
            while(j >= 0){
                if (t < a[j]){
                    a[j+1] = a[j];
                }else {
                    break;  //退出循环，减少比较次数
                }
                j--;
            }
            a[j+1] = t;
            System.out.println(Arrays.toString(a)); //打印每一轮循环的结果
        }
    }

}

思路分析

文字描述：

1. 将数组分为两个区域，已排序和未排序区域，每一轮从未排序区域中取出第一个元素，插入到排序区域

2. 重复以上步骤，直到整个数组有序

优化方式：

1. 待插入元素进行比较时，遇到比自己小的元素，就代表找到了插入位置，无需进行后续比较

2. 插入时可以直接移动元素，而不是交换元素

与选择排序进行比较：

1. 二者平均时间复杂度O(n^2)

2. 大部分情况下，插入都略优于选择

3. 有序集合插入的时间复杂度O(n)

4. 插入排序是稳定的，选择是不稳定的

5、希尔排序

1. 数组中间隙相同的划分一组，同一组的元素进行插入排序。较大的元素在右边，较小的元素在左边。

2. 改变间隙序列，重复以上步骤。

间隙序列：[N/2],[N/4],...,1

面试真题

1. 使用直接插入排序算法对序列18,23,19,9,23,15进行排序，第三趟的排序结果（）

18, 23, 19, 9, 23, 15

18, 19, 23, 9, 23, 15

9, 18, 19, 23, 23, 15

2. 使用直接选择排序算法对序列18,23,19,9,23,15进行排序，第三趟排序后的结果（）

9,23,19,18,23,15

9,15,19,18,23,23

9,15,18,19,23,23

6、快速排序

思路描述：

1. 每一轮排序选择一个基准点（pivot）进行分区

        1）让小于基准点的元素的进入一个分区，大于基准点的元素进入另一个分区

        2）当分区完成时，基准点元素的位置就是其最终位置

2. 在子分区内重复以上过程，直至子分区元素个数小于等于1(divide-and-conquer)

实现方式：

1. 单边循环(lomuto分区) ------- 洛穆托算法

        选择最右元素作为基准点元素

        j指针负责找到比基准点小的元素，一旦找到则与i进行交换

        i指针维护小于基准点元素的边界，也是每次交换的目标索引

        最后基准点与i交换，i即是分区位置

2. 双边循环 ------ 霍尔分区算法

        选择最左元素作为基准点元素

        j指针负责从右向左找比基准点小的元素，i指针负责从左向右找比基准点大的元素，一旦找到交换，直至i, j相交

        最后基准点与i（此时 i 和 j 相等）交换，i 是分区位置

单边循环快排： 

public class QuickSort {
    public static void main(String[] args){
        int[] a = {5,3,7,2,9,8,1,4};
        partition(a, l=0, h=a.length - 1);
    }


    public static int partition (int[] a, int l, int h){
        int pv = a[h];  //基准点元素
        int i = l;
        for (int j = l; j < h; j++){
            if (a[j] < pv){
                swap(a, i, j);
                i++;
            }
        }
        swap(a, h, i);
        System.out.println(Array.toString(a) + "i=" + i);
        //返回值代表基准点元素所在的正确索引，用它确定下一轮分区的边界
        return i;  
    }
}

递归实现单边快排

public class QuickSort {
    public static void main(String[] args){
        int[] a = {5,3,7,2,9,8,1,4};
        quick(a, l=0, h=a.length - 1);
    }


    public static void quick(int[] a, int l, int h){

        if (l >= h){
            return;
        }
        int p = partition(a, l, h);  //基准点所指的正确索引值
        quick(a, l, p - 1);  //左边界分区
        quick(a, p + 1, h);  //右边界分区
    }


    public static int partition (int[] a, int l, int h){
        int pv = a[h];  //基准点元素
        int i = l;
        for (int j = l; j < h; j++){
            if (a[j] < pv){
                if (i != j){
                swap(a, i, j);
                }
                i++;
            }
        }

        if (i != h){
            swap(a, h, i);
        }
        
        System.out.println(Array.toString(a) + "i=" + i);
        //返回值代表基准点元素所在的正确索引，用它确定下一轮分区的边界
        return i;  
    }
}

递归实现双边循环快排：

//双边循环快排
@SuppressWarnings("all")
public class QuickSort2 {
    public static void main(String[] args){
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};
        System.out.println(Arrays.toString(a));
        quick(a, 0, a.length - 1);
    }

    public static void quick(int[] a, int l, int h){
        if (l >= h){
            return ;
        }
        int p = partition(a, l, h);
        quick(a, l, p - 1);
        quick(a, p + 1, h);
    }

    public static int partition(int[] a, int l, int h){
        int pv = a[l];  //选择最左的元素作为基准点
        int i = l;
        int j = h;
        while (i < j) {
            //j 从右向左找比基准点小的元素
            while (i < j && a[j] > pv) {
                j--;
            }
            //i 从左向右找比基准点大的元素
            while (i < j && a[i] <= pv){
                i++;
            }
            swap(a, i, j);
        }
        swap(a, l, j);
        System.out.println(Arrays.toString(a) + "j = " + j);
        return j;

    }
}

双边循环注意的要点：

1. 基准点在左边，并且先 j 从右向左 后 i 从左向右

2. while(i < j && a[j] > pv) j--

3. while(i < j && a[i] <= pv) i++

 快速排序的特点：

1. 平均时间复杂度是O(nlog2N)，最坏时间复杂度O(n^2)

2. 数据量较大时，优势非常明显

3. 不稳定排序

7、设计模式

单例模式

目标：

1. 掌握单例模式常见的五种实现方式;

2. 了解JDK中有哪些地方体现了单例模式;

//1. 饿汉式：提前创建静态成员变量
public class SingletonMode1 implements Serializable {

    //构造私有
    private SingletonMode1 (){
        System.out.println("private SingletonMode1");
    }

    //静态成员变量
    private static final SingletonMode1 INSTANCE = new SingletonMode1();

    //公共的静态方法访问静态成员变量
    public static SingletonMode1 getInstance(){
        return INSTANCE;
    }

    public static void otherMethod(){
        System.out.println("otherMethod() .....");
    }

}
public static void main(String[] args) {
        SingletonMode1.otherMethod();
        System.out.println("======================");
        System.out.println(SingletonMode1.getInstance());
        System.out.println(SingletonMode1.getInstance());
        
    }

//反射破坏单例
reflectiion(SingletonMode1.class);

private static void reflectiion(Class<?> clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //无参构造私有化
        Constructor<?> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        System.out.println("反射创建的实例："+constructor.newInstance());
    }

 预防反射破坏单例

//构造私有
    private SingletonMode1 (){
        if (INSTANCE != null){
            throw new RuntimeException("单例对象不能重复创建~~~");
        }
        System.out.println("private SingletonMode1");
    }

//反序列化破坏单例
serializable(SingletonMode1.getInstance());


private static void serializable(Object instance) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(instance);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        System.out.println("反序列化创建实例："+ois.readObject());
    }

 预防反序列化破坏单例

public Object readResolve(){
        return INSTANCE;
    }

//Unsafe破坏单例
unsafe(SingletonMode1.class);


private static void unsafe(Class<?> clazz) throws InstantiationException {
        Object o = Unsafe.getUnsafe().allocateInstance(clazz);
        System.out.println("unsafe 创建实例："+ o);
    }
//2. 枚举类饿汉式单例
public enum SingletonMode2 {
    //枚举类实例变量
    INSTANCE;

    SingletonMode2(){
        System.out.println("private singleton2");
    }

    @Override
    public String toString(){
        return getClass().getName() + "@" +Integer.toHexString(hashCode());
    }

    public static SingletonMode2 getInstance() {
        return INSTANCE;
    }

    public static void otherMethod(){
        System.out.println("otherMethod");
    }
    
}
//反序列化破坏单例     
serializable(SingletonMode2.getInstance());

反序列化不会破坏枚举单例。

//反射破坏单例
reflectiion(SingletonMode2.class);

private static void reflectiion(Class<?> clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //无参构造私有化
        //Constructor<?> constructor = clazz.getDeclaredConstructor();
        Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        System.out.println("反射创建的实例："+constructor.newInstance("other", 2));
    }

 反射不会破坏枚举对象。

//3. 懒汉式单例模式
public class SingletonMode3 implements Serializable {

    private SingletonMode3 (){
        System.out.println("private singleton3");
    }

    private static SingletonMode3 INSTANCE = null;

    public static synchronized SingletonMode3 getInstance() {
        if (INSTANCE == null){
            INSTANCE = new SingletonMode3();
        }
        return INSTANCE;
    }

    public static void otherMethod(){
        System.out.println("otherMethod");
    }

}

 懒汉式单例模式考虑多线程调用getInstance()，保护线程安全。

public static synchronized SingletonMode3 getInstance() {
        if (INSTANCE == null){
            INSTANCE = new SingletonMode3();
        }
        return INSTANCE;
    }
//3. 懒汉式单例模式 - DCL (双检锁)
public class SingletonMode4 implements Serializable {

    private SingletonMode4(){
        System.out.println("private singleton4");
    }

    //volatile 线程共享变量：可见性和有序性
    private static volatile SingletonMode4 INSTANCE = null;

    public static SingletonMode4 getInstance() {
        if (INSTANCE == null){
            synchronized (SingletonMode4.class){
                if (INSTANCE == null){
                    INSTANCE= new SingletonMode4();
                }
            }
        }

        return INSTANCE;
    }

    public static void otherMethod(){
        System.out.println("otherMethod");
    }

}
//5. 懒汉式单例模式 - 内部类
public class SingletonMode5 implements Serializable {

    private SingletonMode5(){
        System.out.println("private singleton5");
    }

    //静态内部类  线程安全
    private static class Holder{
        static SingletonMode5 INSTANCE = new SingletonMode5();
    }

    public static SingletonMode5 getInstance(){
        return Holder.INSTANCE;
    }

    public static void otherMethod(){
        System.out.println("otherMethod");
    }

}

在jdk中体现单例模式

 

 

 

 

 

 

以上是个人在基础数据结构中查找和排序的算法学习总结。需要自己理解原理！自己在不看笔记的情况下才能自己写出来。尤其是重点的算法代码！！！

Husp0707
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
易道博识3D人脸识别技术文档
07-11
3D人脸技术规格说明书 包括3D人脸技术介绍，3D技术参数，关键技术等
java排序 面试题_java【排序】面试题
weixin_33771582的博客
02-12 167
排序选择排序基本思想每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。简单理解:每个元素都和它后面的元素比较,只要后面的元素比它大就交换选择排序的最终代码以上4个for循环代码重复性较高,唯独不一样的地方就是每个for循环中都有一个使用多次的固定数字,第一个for的数字0,第二个for的数字是1,第3个for的数字是2,第4个for的数字是...
美团2019校招后台开发题目总结
分不清东西南北的Laffey
08-07 1152
1.关于Java线程说法正确的是 A.线程创建后，调用start()方法进入就绪状态 B.线程创建后，调用run()方法进入就绪状态 C.在同一Thread对象上不允许两次调用start()方法 D.线程调用stop()后进入终止状态 B 调用run方法进入运行状态，被线程调度程序设置为当前线程 C同一Thread对象即同一线程，在线程的整个生命过程中，只会调用一次start() 2.Java Set中对象具有一下哪些特点 A.不能重复 B.每个对象包含一对键、值 C.按特定方式排序 D.无序 Set
为冬奥会提供OCR识别，易道博识OCR能力胜任国际赛事考验
qq_42133955的博客
03-24 336
护照识别技术，可以实现对用户护照信息的结构化识别和录入，可应用于境外旅游产品预订、酒店入住登记等场景，满足护照信息自动录入的需求，有效提升信息录入效率，降低用户输入成本，提升用户使用体验。
python调用易道博识文字识别API接口
jiang_ming_的博客
07-16 1160
有时候工作需要或者学习需要，总需要调用到一些企业开放的API接口，虽然开放，但大多数并不免费，有些会有每天的调用限额，比如百度的行驶证识别每天好像是100次的免费试用额度，超过就得收钱了，本文主要是利用python调用易道博识的文字识别中的行驶证识别，其他识别估计也差不多，废话不多说，开始干正事儿哈哈：先附上易道博识的行驶证识别的地址：http://ai.exocr.com/veCardDetai...
Java 数组常见的排序和查找算法
friend18750230725的博客
01-13 542
1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。2、核心：拿着左边的数字和右边的数字比对，当左边＞右边的时候，交换位置。2，3，7，6，8（虽然不需要交换位置：但是3 和7 还需要比较一次。2，3，6，7，8（虽然不需要交换位置：但是7 和8 还需要比较一次。（没有排序的数据是无法查找的。二分法查找的终止条件：一直折半，直到中间的那个元素恰好是被查找的元素。2，3，7，6，8（3和2比较，2<3，所以2和3交换位置）(5 + 9) / 2 --> 7（中间元素的下标）
java面试题之排序
m0_37775035的博客
12-16 276
/*** @author 罗老师&lt;br&gt;* 课程《Java零基础至高级应用》提供全套【代码+笔记+相关开发工具+答疑服务】*/public class LianXi_04 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub /* ...
JAVA常见查找和排序算法
m0_52563512的博客
09-08 1240
Java面试题解析
Java-基础算法-查找与排序
ZEALERHE的博客
04-14 136
【代码】Java-基础算法-查找与排序。
Java面试题大全（整理版）1000+面试题附答案详解，最全面详细，看完稳了
热门推荐
m0_67322837的博客
05-11 6万+
进大厂是大部分程序员的梦想，而进大厂的门槛也是比较高的，所以这里整理了一份阿里、美团、滴滴、头条等大厂面试大全，其中概括的知识点有：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、 Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux 等技术栈共有1000+道面试题。 对于Java后端的朋友来说应该是最全面最完整的面试备战仓库，为了更好地整理每个模块，我也参考了很多网上的
面试最常见的问题（java各种排序法）
11-11
排序是本人写的，有word文档形式，也有源代码，注解清晰，保你十分钟搞定各种排序。
java 排序 面试题
12-07
java 排序方法 面试的时候会碰到 下载学习吧
JAVA-SSH面试题.doc
01-25
JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA-SSH面试题JAVA...
Java面试题及答案-共8道.docx
07-18
Java面试题及答案-共8道.docx Java面试题及答案-共8道.docx Java面试题及答案-共8道.docx Java面试题及答案-共8道.docx Java面试题及答案-共8道.docx Java面试题及答案-共8道.docx Java面试题及答案-共8道.docx Java...
Java面试题及答案-共30道.docx
07-18
Java面试题及答案-共30道.docx
Java面试题-分布式相关.pdf
06-12
Java面试题-分布式相关
Java面试题-Web相关.pdf
06-12
Java面试题-Web相关
Java面试八股之marshalling和demarshalling
u012151345的博客
04-21 466
Marshalling（序列化）是将内存中的对象状态转化为适合传输或存储的格式（如字节流、JSON、XML），以便进行网络通信、持久化存储或跨平台/语言交互操作。- JSON、XML绑定库：如Jackson、Gson（JSON）和JAXB、XMLBeans（XML），实现对象与数据格式的互转。- 第三方库：如protobuf、Avro、Jackson、Gson，提供更灵活、高效的解决方案。3. 优化性能，减少传输量、提升速度，合理设计降低CPU和内存使用。2. 保证数据安全，通过加密、压缩、校验等手段。
面试ssss
最新发布
qq_51685537的博客
04-23 935
数据劫持（Data Observation）：Vue 使用了一种称为「数据劫持」的技术来追踪数据的变化。它通过使用 Object.defineProperty() 方法，将数据对象的属性转换为 getter 和 setter。当访问或修改属性时，Vue 能够捕获到这些操作，并触发相应的更新。监听器（Watcher）：在 Vue 中，每个数据属性都有一个对应的监听器对象。监听器会订阅数据的变化，并根据变化触发相应的更新操作。当数据发生变化时，监听器会通知相关的视图进行更新。
java面试题--(真
10-16
java面试题真的很多，下面我来回答一个有关多线程的问题。 在Java中实现多线程有两种方式，一种是继承Thread类，另一种是实现Runnable接口。这两种方式有何区别？ 继承Thread类的方式是直接定义一个类继承Thread，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Husp0707

你的小小点赞、关注是我的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值