JavaSE java对象的比较

news2024/11/25 20:21:28

目录

  • 1 问题提出
  • 2 元素的比较
    • 2.1 基本类型的比较
    • 2.2 对象的比较
  • 3 对象的比较
    • 3.1 覆写基类的equal
    • 3.2 基于Comparble接口类的比较
    • 3.3 基于比较器比较
    • 3.4 三种方式对比
  • 4 集合框架中PriorityQueue的比较方式
  • 5 总结

1 问题提出

上节课我们讲了优先级队列，优先级队列在插入元素时有个要求：插入的元素不能是null或者元素之间必须要能够进行比较，为了简单起见，我们只是插入了Integer类型，那优先级队列中能否插入自定义类型对象呢？
比如下面的代码会运行报错：

import java.util.*;
class Card {
   public int rank; // 数值
   public String suit; // 花色
   public Card(int rank, String suit) {
      this.rank = rank;
      this.suit = suit;
   }
    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Card card1 = new Card(1,"♦");
        Card card2 = new Card(2,"♦");
        Card card3 = new Card(3,"♦");
        PriorityQueue<Card> p = new PriorityQueue<>();
        p.offer(card2);
        p.offer(card1);
        System.out.println(p);
}
    }

报错原因：优先级队列底层使用堆，而向堆中插入元素时，为了满足堆的性质，必须要进行元素的比较，而此时Card是没有办法直接进行比较的，因此抛出异常。在这里插入图片描述

2 元素的比较

2.1 基本类型的比较

在Java中，基本类型的对象可以直接比较大小。具体代码示例如下所示：

import java.util.*;
public class TestDemo {
   public static void main(String[] args) {
      int a = 10;
      int b = 20;
      System.out.println(a > b);
      System.out.println(a < b);
      System.out.println(a == b);
      
      char c1 = 'A';
      char c2 = 'B';
      System.out.println(c1 > c2);
      System.out.println(c1 < c2);
      System.out.println(c1 == c2);
      
      boolean b1 = true;
      boolean b2 = false;
      System.out.println(b1 == b2);
      System.out.println(b1 != b2);
  
      PriorityQueue<Integer> qu = new PriorityQueue<>();
      qu.offer(1);
      qu.offer(2);
      }
}

2.2 对象的比较

具体代码示例如下所示：

import java.util.*;
class Card {
   public int rank; // 数值
   public String suit; // 花色
   public Card(int rank, String suit) {
      this.rank = rank;
      this.suit = suit;
   }
    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Card card1 = new Card(1,"♦");
        Card card2 = new Card(1,"♦");
        Card card3 = card1;
        //System.out.println(card1 > card3);编译报错
        System.out.println(card1 == card2);// 编译成功 ----> 打印false，因为card1和card2指向的是不同对象
        //System.out.println(card1 < card2); // 编译报错
        System.out.println(card1 == card3); // 编译成功 ----> 打印true，因为c1和c3指向的是同一个对象
 }
    }

其中card1、card2和card3分别是Card类型的引用变量，上述代码在比较编译时：c1 > c2 编译失败；c1== c2 编译成功；c1 < c2 编译失败。
从编译结果可以看出，Java中引用类型的变量不能直接按照 > 或者 < 方式进行比较。 那为什么== 可以比较？
因为对于用户实现自定义类型，都默认继承自Object类，而Object类中提供了equal方法，而==默认情况下调用的就是equal方法，但是该方法的比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，但有些情况下该种比较就不符合题意。
下面是Object中equal的实现代码：

// Object中equal的实现，可以看到：直接比较的是两个引用变量的地址
public boolean equals(Object obj) {
    return (this == obj);
}

3 对象的比较

有些情况下，需要比较的是对象中的内容，比如：向优先级队列中插入某个对象时，需要对按照对象中内容来调整堆，那该如何处理呢？

3.1 覆写基类的equal

具体代码示例如下所示：

import java.util.*;
class Card {
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Card card = (Card) o;
        return rank == card.rank &&
                Objects.equals(suit, card.suit);
    }

    @Override
    public int hashCode() {
        return Objects.hash(rank, suit);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Card card1 = new Card(1,"♦");
        Card card2 = new Card(1,"♦");
        Card card3 = new Card(3,"♦");
        //System.out.println(card21 > card23);编译报错
        System.out.println(card1 == card2);

        System.out.println(card1.equals(card2));//这里调用的是object的equals方法,所以这里比较的是引用所指向的对象是不是同一个,所以我们这里应该返回的是false,因为这是两个对象
        //但是在我们的认知中，此时的card1和card2应该是一样的，所以我们需要重写equals方法

//        String str = "fsafsa";
//        String str2 = "fsafsafasffa";
//        System.out.println(str.equals(str2));
    }
}

注意，一般覆写 equals 方法的套路就是上面演示的：

  1. 如果指向同一个对象，返回 true；
  2. 如果传入的为 null，返回 false；
  3. 如果传入的对象类型不是 Card，返回 false；
  4. 按照类的实现目标完成比较，例如这里只要花色和数值一样，就认为是相同的牌；
  5. 注意下调用其他引用类型的比较也需要 equals，例如这里的card1.equals(card2)比较覆写基类equal的方式虽然可以比较，但缺陷是：equal只能按照相等进行比较，不能按照大于、小于的方式进行比较。

3.2 基于Comparble接口类的比较

Comparble是JDK提供的泛型的比较接口类，源码实现具体如下：

public interface Comparable<E> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于 o 指向的对象
    // == 0: 表示 this 指向的对象等于 o 指向的对象
    // > 0: 表示 this 指向的对象等于 o 指向的对象
    int compareTo(E o);
}

对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现Comparble接口即可，然后在类中重写compareTo方法。
具体代码示例如下所示：

import java.util.*;
class Card implements Comparable<Card>{
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }

    @Override
    public int compareTo(Card o) {
        return this.rank-o.rank;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Card card1 = new Card(1,"♦");
        Card card2 = new Card(1,"♦");
        Card card3 = new Card(3,"♦");
 
        System.out.println(card1.compareTo(card2));
      }
    }

Compareble是java.lang中的接口类，可以直接使用。

3.3 基于比较器比较

按照比较器方式进行比较，具体步骤如下：

  1. 用户自定义比较器类，实现Comparator接口：
public interface Comparator<T> {
     // 返回值:
     // < 0: 表示 o1 指向的对象小于 o2 指向的对象
     // == 0: 表示 o1 指向的对象等于 o2 指向的对象
     // > 0: 表示 o1 指向的对象等于 o2 指向的对象
     int compare(T o1, T o2);
}

注意： 区分Comparable和Comparator。

  1. 覆写Comparator中的compare方法：
import java.util.*;
class Card {
   public int rank; // 数值
   public String suit; // 花色
   public Card(int rank, String suit) {
      this.rank = rank;
      this.suit = suit;
   }
    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
}
class RankComparator implements Comparator<Card2>{
    @Override
    public int compare(Card2 o1, Card2 o2) {
        return o1.rank-o2.rank;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Card2 card21 = new Card2(1,"♦");
        Card2 card22 = new Card2(2,"♦");
        Card2 card23 = new Card2(3,"♦");
        PriorityQueue<Card2> qu = new PriorityQueue<>(new RankComparator());
        qu.offer(card22);
        qu.offer(card21);
        qu.offer(card23);
        System.out.println(qu);
    }

注意： Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包。

3.4 三种方式对比

覆写的方法说明
Object.equals因为所有类都是继承自 Object 的，所以直接覆写即可，不过只能比较相等与否
Comparable.compareTo需要手动实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性强

对于Comparable接口和比较器Comparator可以借助博客https://blog.csdn.net/weixin_51312723/article/details/128290353中的8.3节“常见的接口实例”进行详细了解。

4 集合框架中PriorityQueue的比较方式

集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：Comparble和Comparator两种方式。

  1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法
  2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

下面是JDK中PriorityQueue实现的源代码：

// JDK中PriorityQueue的实现：
public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable {
     // ...
     // 默认容量
     private static final int DEFAULT_INITIAL_CAPACITY = 11;

     // 内部定义的比较器对象，用来接收用户实例化PriorityQueue对象时提供的比较器对象
     private final Comparator<? super E> comparator;

     // 用户如果没有提供比较器对象，使用默认的内部比较，将comparator置为null
     public PriorityQueue() {
           this(DEFAULT_INITIAL_CAPACITY, null);
      }
 
     // 如果用户提供了比较器，采用用户提供的比较器进行比较
     public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
          // Note: This restriction of at least one is not actually needed,
          // but continues for 1.5 compatibility
          if (initialCapacity < 1)
             throw new IllegalArgumentException();
          this.queue = new Object[initialCapacity];
          this.comparator = comparator;
        }

     // ...
     // 向上调整：
     // 如果用户没有提供比较器对象，采用Comparable进行比较
     // 否则使用用户提供的比较器对象进行比较
     private void siftUp(int k, E x) {
         if (comparator != null)
            siftUpUsingComparator(k, x);
         else
            siftUpComparable(k, x);
      }

     // 使用Comparable
     @SuppressWarnings("unchecked")
     private void siftUpComparable(int k, E x) {
          Comparable<? super E> key = (Comparable<? super E>) x;
          while (k > 0) {
              int parent = (k - 1) >>> 1;
              Object e = queue[parent];
              if (key.compareTo((E) e) >= 0)
                 break;
              queue[k] = e;
              k = parent;
        }
              queue[k] = key;
        }

      // 使用用户提供的比较器对象进行比较
      @SuppressWarnings("unchecked")
      private void siftUpUsingComparator(int k, E x) {
          while (k > 0) {
             int parent = (k - 1) >>> 1;
             Object e = queue[parent];
             if (comparator.compare(x, (E) e) >= 0)
                 break;
             queue[k] = e;
             k = parent;
        }
             queue[k] = x;
       }}

5 总结

这篇内容的所有代码如下所示：

import java.util.*;
class Card implements Comparable<Card>{
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }

    @Override
    public int compareTo(Card o) {
        return this.rank-o.rank;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Card card = (Card) o;
        return rank == card.rank &&
                Objects.equals(suit, card.suit);
    }

    @Override
    public int hashCode() {
        return Objects.hash(rank, suit);
    }
}

class Card2{
    public int rank; // 数值
    public String suit; // 花色
    public Card2(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public String toString() {
        return "Card2{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
}

class RankComparator implements Comparator<Card2>{
    @Override
    public int compare(Card2 o1, Card2 o2) {
        return o1.rank-o2.rank;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Card card1 = new Card(1,"♦");
        Card card2 = new Card(1,"♦");
        Card card3 = new Card(3,"♦");
        //System.out.println(card21 > card23);编译报错
        System.out.println(card1.compareTo(card2));
        System.out.println(card1 == card2);

        System.out.println(card1.equals(card2));//这里调用的是object的equals方法,所以这里比较的是引用所指向的对象是不是同一个,所以我们这里应该返回的是false,因为这是两个对象
        //但是在我们的认知中，此时的card1和card2应该是一样的，所以我们需要重写equals方法

//        String str = "fsafsa";
//        String str2 = "fsafsafasffa";
//        System.out.println(str.equals(str2));
    }
    public static void main13(String[] args) {
        PriorityQueue<Integer> qu = new PriorityQueue<>();
        qu.offer(1);
        qu.offer(2);
    }
    public static void main12(String[] args) {
        Card2 card21 = new Card2(1,"♦");
        Card2 card22 = new Card2(2,"♦");
        Card2 card23 = new Card2(3,"♦");
        PriorityQueue<Card2> qu = new PriorityQueue<>(new RankComparator());
        qu.offer(card22);
        qu.offer(card21);
        qu.offer(card23);
        System.out.println(qu);
    }
    public static void main11(String[] args) {
        Card card1 = new Card(1,"♦");
        Card card2 = new Card(2,"♦");
        Card card3 = new Card(3,"♦");
        PriorityQueue<Card> p = new PriorityQueue<>();
        p.offer(card2);
        p.offer(card1);
        System.out.println(p);

        Card2 card21 = new Card2(1,"♦");
        Card2 card22 = new Card2(2,"♦");
        Card2 card23 = new Card2(3,"♦");
        PriorityQueue<Card2> qu = new PriorityQueue<>(new Comparator<Card2>() {
            @Override
            public int compare(Card2 o1, Card2 o2) {
                return o1.rank-o2.rank;
            }
        });
        qu.offer(card22);
        qu.offer(card21);
        qu.offer(card23);
        System.out.println(qu);
    }}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1167473.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

汇编-字符串

汇编-字符串

字符串常量是用单引号或双引号括起来的一个字符序列 当以下面例子中的方式使用时&#xff0c;嵌入引号也是允许的&#xff1a; 正如字符常量以整数形式存放一样&#xff0c;字符串常量在内存中的存储形式为整数字节值的序列。例如&#xff0c; 字符串字面量“ABCD”包含四个字…
阅读更多...
SPSS单样本K-S检验

SPSS单样本K-S检验

前言&#xff1a; 本专栏参考教材为《SPSS22.0从入门到精通》&#xff0c;由于软件版本原因&#xff0c;部分内容有所改变&#xff0c;为适应软件版本的变化&#xff0c;特此创作此专栏便于大家学习。本专栏使用软件为&#xff1a;SPSS25.0 本专栏所有的数据文件请点击此链接下…
阅读更多...
第25期 | GPTSecurity周报

第25期 | GPTSecurity周报

GPTSecurity是一个涵盖了前沿学术研究和实践经验分享的社区&#xff0c;集成了生成预训练 Transformer&#xff08;GPT&#xff09;、人工智能生成内容&#xff08;AIGC&#xff09;以及大型语言模型&#xff08;LLM&#xff09;等安全领域应用的知识。在这里&#xff0c;您可以…
阅读更多...
GEE：GEE中实现简单计算器

GEE：GEE中实现简单计算器

作者&#xff1a;CSDN _养乐多_ 本文记录了在 Google Earth Engine&#xff08;GEE&#xff09;上实现简单计算器的代码。 APP链接&#xff1a;https://949384116.users.earthengine.app/view/simplecalculator 文章目录 一、完整代码二、代码链接 一、完整代码 // 定义初始…
阅读更多...
二十、泛型（1）

二十、泛型（1）

本章概要 基本概念 与 C 的比较 简单泛型 一个元组类库一个堆栈类RandomList 基本概念 普通的类和方法只能使用特定的类型&#xff1a;基本数据类型或类类型。如果编写的代码需要应用于多种类型&#xff0c;这种严苛的限制对代码的束缚就会很大。 多态是一种面向对象思想的泛…
阅读更多...
预制构建生产管理系统

预制构建生产管理系统

在建筑施工领域&#xff0c;预制构件的使用越来越广泛&#xff0c;它能够提高工程质量和施工效率&#xff0c;减少施工现场对环境的影响。通过凡尔码的二维码管理平台&#xff0c;系统从&#xff1a;生产过程、生产数据、生产计划、生产管理、成品交付等多个环节、工序和流程进…
阅读更多...
mermaid学习第一天/更改主题颜色和边框颜色/《需求解释流程图》

mermaid学习第一天/更改主题颜色和边框颜色/《需求解释流程图》

mermaid 在线官网&#xff1a; https://mermaid-js.github.io/ 在线学习文件&#xff1a; https://mermaid.js.org/syntax/quadrantChart.html 1、今天主要是想做需求解释的流程图&#xff0c;又不想自己画&#xff0c;就用了&#xff0c;框框不能直接进行全局配置&#xff0…
阅读更多...
如何助力机构单位提升运营效率？有什么靠谱的大数据管理平台？

如何助力机构单位提升运营效率？有什么靠谱的大数据管理平台？

随着数字化时代的到来&#xff0c;大数据管理平台已成为机构单位提高效率、优化资源配置的关键工具。其中&#xff0c;工单管理系统作为大数据管理平台的重要组成部分&#xff0c;对于机构单位运营的优化和提升具有举足轻重的地位。本文小编将为您介绍一款优秀的工单管理系统—…
阅读更多...
Zygote进程通信为什么用Socket而不是Binder?

Zygote进程通信为什么用Socket而不是Binder?

Zygote进程是Android系统中的一个特殊进程&#xff0c;它在系统启动时被创建&#xff0c;并负责孵化其他应用进程。它的主要作用是预加载和共享应用进程的资源&#xff0c;以提高应用启动的速度。 在Android系统中&#xff0c;常用的进程通信方式有以下几种&#xff1a; Intent…
阅读更多...
概率论和数理统计(一)基本概念

概率论和数理统计(一)基本概念

前言 生活中对于事件的发生,可以概括为 确定现象&#xff1a;在一定条件下必然发生&#xff0c;如日出随机现象&#xff1a;在个别试验中其结果呈现出不确定性&#xff0c;在大量重复试验中其结果又具有统计规律的现象&#xff0c;称之为随机现象。 随机现象的特点&#xff…
阅读更多...
独家分享 | BI零售数据分析模板，可视化，更易懂

独家分享 | BI零售数据分析模板，可视化，更易懂

“人、货、场”是零售数据分析的三大关键&#xff0c;只要能又快又透彻地掌握这三大关键的数据情况&#xff0c;即可为零售运营决策提供关键的数据支持&#xff0c;提高盈利、降低成本、优化采购库存结构等。奥威BI软件这套BI零售数据分析模板套装围绕“人、货、场”预设了数十…
阅读更多...
低代码平台如火如荼，告诉我它具体能做什么？

低代码平台如火如荼，告诉我它具体能做什么？

目录 一、前言 二、低代码平台 三、低代码平台的优劣 四、低代码能解决哪些问题&#xff1f; 五、好用且强大的低代码平台 六、结语 一、前言 目前低代码平台如火如荼。这一新兴技术为企业提供了一种高效、灵活、快速开发应用程序的方法&#xff0c;并在短时间内取得了巨大成功…
阅读更多...
游戏中找不到d3dx9_43.dll怎么办,教你快速解决方法

游戏中找不到d3dx9_43.dll怎么办,教你快速解决方法

在计算机的世界里&#xff0c;我们经常会遇到一些让人头疼的问题。比如&#xff0c;有一天&#xff0c;小明正在玩他最喜欢的游戏&#xff0c;突然弹出了一个错误提示&#xff1a;“由于找不到d3dx9_43.dll,无法继续执行代码”。小明感到非常困惑&#xff0c;不知道这是什么意思…
阅读更多...
【python VS vba】(5) 在python中使用xlwt操作Excel（待完善ing）

【python VS vba】(5) 在python中使用xlwt操作Excel（待完善ing）

目录 1 什么是xlwt 2 导入xlwt 3 相关语法 3.1 创建新的workbook 3.2 创建新的sheet 3.3 保存workbook 4 python里表格的形式 4.1 矩阵 4.2 EXCEL的数据形式 完全等于矩阵的数字结构 4.3 python里矩阵 5 具体代码 5.1 代码 5.2 结果 5.3 要注意的问题 5.3.1 不能…
阅读更多...
PostgreSQL manual

PostgreSQL manual

set path D:\DB\PostgreSQL\16\binconnect to database –h is host name -p is port number -d is database name -U is for user name psql -h localhost -p 5432 -d postgres -U postgresexport dump file 參考 pg_dump -h 192.168.1.1 -U uesername dbname > dbna…
阅读更多...
项目实现思路-建设工程监理现场用表管理系统

项目实现思路-建设工程监理现场用表管理系统

项目实现思路-建设工程监理现场用表管理系统 文章目录 项目实现思路-建设工程监理现场用表管理系统1.架构&#xff08;B/S&#xff09;2.主要功能3.**技术细节**3.1 总体概要3.2 **技术细节之流程审批**3.3 **技术细节之电子签名和公章** 1.架构&#xff08;B/S&#xff09; 系…
阅读更多...
期中成绩怎么发布？

期中成绩怎么发布？

作为一名老师&#xff0c;期中考试结束后&#xff0c;你可能正在为如何发布成绩而烦恼。传统的纸质方式不仅耗时而且容易出错&#xff0c;那么有没有一种方式可以让学生自助查询成绩呢&#xff1f;答案是肯定的。下面就为你介绍几种实用的方法&#xff0c;让成绩发布变得轻松又…
阅读更多...
2024天津理工大学中环信息学院专升本机械设计制造自动化专业考纲

2024天津理工大学中环信息学院专升本机械设计制造自动化专业考纲

2024年天津理工大学中环信息学院高职升本科《机械设计制造及其自动化》专业课考试大纲《机械设计》《机械制图》 《机械设计》考试大纲 教 材&#xff1a;《机械设计》&#xff08;第十版&#xff09;&#xff0c;高等教育出版社&#xff0c;濮良贵、陈国定、吴立言主编&#…
阅读更多...
代码随想录算法训练营第四十二天 | LeetCode 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零

代码随想录算法训练营第四十二天 | LeetCode 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零

代码随想录算法训练营第四十二天 | LeetCode 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零 文章链接&#xff1a;最后一块石头的重量 II 目标和 一和零 视频链接&#xff1a;最后一块石头的重量 II 目标和 一和零 1. LeetCode 1049. 最后一块石头的重量 II 1.1 思路…
阅读更多...
四川天蝶电子商务有限公司：短视频运营怎么样？

四川天蝶电子商务有限公司：短视频运营怎么样？

短视频是一种以短小精悍的内容来吸引用户的新型媒体形式&#xff0c;近年来在社交网络平台上迅速走红&#xff0c;成为当今互联网世界的新宠。然而&#xff0c;要想成功运营短视频&#xff0c;需要借助一系列的策略和技巧&#xff0c;通过精心的规划和执行&#xff0c;才能够吸…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023