JavaSE：Java常用类

最新推荐文章于 2024-06-01 06:00:00 发布
最新推荐文章于 2024-06-01 06:00:00 发布
阅读量150 收藏
点赞数
分类专栏： JavaSE 文章标签： java 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49825096/article/details/108479261
版权

JavaSE：Java常用类

字符串相关的类

String类

String 类：代表字符串。java程序中的所有字符串字面值（如：“abc”）都作为此类的实例实现。

String是一个final 类，代表不可变的字符序列。简称：不可变性。

String ：

  • 实现了serialzable接口：表示字符串是支持序列化的

  • 实现了Comparable 接口：表示String可以比较大小

String内部定义了 final char[] value ,String对象的字符内容是存储在这个**字符数组value[]**中的。

说明：

  1. 通过字面量的方式给一个字符串赋值，此时的字符串值声明在字符串常量池中。
  2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value 进行赋值。
  3. 当调用String的replace（）方法修改字符或字符串时，也必须重新指定内存区域赋值，不能使用原有的value 进行赋值。
  4. 字符串常量池中是不会存储相同内容的字符串的。

在这里插入图片描述
不可变性：

  1. 通过字面量的方式给一个字符串赋值，此时的字符串值声明在字符串常量池中。
  2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value 进行赋值。
  3. 当调用String的replace（）方法修改字符或字符串时，也必须重新指定内存区域赋值，不能使用原有的value 进行赋值。
  4. 字符串常量池中是不会存储相同内容的字符串的。

不同实例化方式的对比

方式一：通过字面量定义的方式

方式二：通过new + 构造器的方式

public void Test(){
    //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法去中的字符串常量池中。
    String s1 = "javaEE";
    String s2 = "javaEE";
    
    
    //通过new + 构造器的方式：此时s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
    String s3 = new String("javaEE");
    String s4 = new String("javaEE");
    
    
    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//false
    System.out.println(s1 == s4);//false
    System.out.println(s3 == s4);//false
    
    System.out.println("*********************");
    
    
    String ss1 = "javaEE";
    String ss2 = "hadoop";
    
    String ss3 = "javaEEhadoop";
    String ss4 = "javaEE" + "hadoop";
    String ss5 = s1 + "hadoop";
    String ss6 = "javaEE" + s2;
    String ss7 = s1 + s2;
    
    
    System.out.println(ss3 == ss4);//true
    System.out.println(ss3 == ss5);//false
    System.out.println(ss3 == ss6);//false
    System.out.println(ss3 == ss7);//false
    System.out.println(ss5 == ss6);//false
    System.out.println(ss5 == ss7);//false
    System.out.println(ss6 == ss7);//false
    
    String ss8 = s5.intern();
    System.out.println(ss3 == ss8);//true
}

  • 通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法去中的字符串常量池中

  • 通过new + 构造器的方式：此时s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。

  • 常量与常量的拼接，结果再常量池中，且常量池中不会存在相同内容那个 常量。

  • 只要其中有一个是变量，结果就再堆空间中

  • 如果拼接的结果调用intern方法，返回值就在常量池中

StringBuffer 类和 StringBuilder 类

  1. 使用 StringBuffer 的空参构造器创建对象，底层创建的是一个长度为16的字符型数组。
  2. 使用带参构造器创建对象，底层创建的则是str.length() + 16 的长度的字符型数组。
  3. 扩容问题：如果要添加的数据底层数组盛不下，那就要考虑扩容底层的数组。默认情况下扩容为原来的2倍再加2，同时将原有的数组中的元素复制到新的数组中。如果扩容为原本的2倍+2仍然不够的话，将使用要添加数据的长度为数组长度。
  4. StringBuilder为JDK1.5时新添加，相比于StringBuffer，StringBuilder底层没有使用Synchronized修饰，也就是说它是线程不安全的，因此，StringBuilder的效率也比StringBuffer的效率高。

String、StringBuffer和StringBulider 三者的异同

  1. String：不可变的字符序列；底层使用char[] 进行存储。
  2. StringBuffer：可变的字符序列；线程安全的，效率低底层使用char[] 进行存储。
  3. StringBulider：可变的字符序列；线程不安全，效率高；jdk5.0新增，底层使用char[] 进行存储。

JDK 8 前的日期API

System类中currentTimeMillis();

返回一个double类型的变量，值为当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。成为时间戳。

public static void main(String[] args) {
    //system类中的currentTimeMillis()静态方法，获取当前时间到1970年1月1日0时0分0秒的毫秒数
    //也称为时间戳
    long timeMillis = System.currentTimeMillis();
    System.out.println(timeMillis);
}

java.util.Date 和子类 java.sql.Date

java API提供了两个Date类： java.util.Date 以及其子类 java.sql.Date。

public static void main(String[] args) {
    //实例化 java.util.Date
    //方式一：获取当前时间
    Date date = new Date();
    System.out.println(date);// Fri Oct 02 11:29:40 CST 2020
    //方式二： 获取指定时间戳的日期
    Date date1 = new Date(16043425244L);
    System.out.println(date1);// Mon Jul 06 00:30:25 CST 1970

    //调用getTime方法获取时间戳
    long time = date.getTime();
    System.out.println(time);//1601609575244
    //实例化java.sql.Date
    java.sql.Date date2 = new java.sql.Date(time);
    System.out.println(date2);//2020-10-02
}

SimpleDateFormat

simpleDateFormat 用于对Date类的格式化和解析

public static void main(String[] args) throws ParseException {

    //simpleDateFormat 用于对Date类的格式化和解析
    //实例化SimpleDateFormat
    SimpleDateFormat sdf = new SimpleDateFormat();
    Date date = new Date();
    System.out.println(date);//Fri Oct 02 11:41:15 CST 2020
    String s = sdf.format(date);//格式化：将Date类型转换为String类
    System.out.println(s);//20-10-2 上午11:41 ---- 若不指定格式化格式，此为格式化的默认格式。

    Date date1 = sdf.parse("98-05-14 上午11:41");//解析：将相应格式的String类转换为Date
    System.out.println(date1);//Thu May 14 11:41:00 CST 1998

    //创建指定格式的simpleDateFormat 对象。
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");
    String format = sdf1.format(new Date());//格式化
    System.out.println("指定格式格式化：" + format);//2020-10-02 12-13-50

    //解析
    Date date2 = sdf1.parse("2008-7-29 16-25-31");
    System.out.println("指定格式解析：" + date2);//Tue Jul 29 16:25:31 CST 2008
    
}

运行结果：
在这里插入图片描述

Calendar

public static void main(String[] args) {
    //实例化:calendar是一个抽象类，但有一个静态方法，一般使用此方法直接获取Calendar对象
    Calendar instance = Calendar.getInstance();
    System.out.println(instance.getClass());//class java.util.GregorianCalendar

    //也可以直接new其子类GregorianCalendar 获取对象
    GregorianCalendar gc = new GregorianCalendar();

    //常用方法
    //get()
    int dayOfYear = instance.get(Calendar.DAY_OF_YEAR);//获取今天为今年的第几天
    int dayOfWeek = instance.get(Calendar.DAY_OF_WEEK);//获取今天为这周的第几天
    int dayOfWeekInMonth = instance.get(Calendar.DAY_OF_WEEK_IN_MONTH);//获取本周是这个月的第几天

    //set 此方法返回值为void，修改是再原本数据上修改，并非生成另外一个对象
    instance.set(Calendar.DAY_OF_YEAR,250);//instance.DAY_OF_YEAR 设置为本年的第250天
    System.out.println(instance.get(Calendar.DAY_OF_YEAR));//250


    //add 返回值为void
    instance.add(Calendar.DAY_OF_YEAR,30);
    System.out.println(instance.get(Calendar.DAY_OF_YEAR));//280

    //getTime  Calendar --> Date
    Date date = instance.getTime();
    System.out.println(date);

    //setTime   Date --> Calendar
    instance.setTime(new Date());

}

在这里插入图片描述

JDK 8 中新日期时间API

LocalDate、LocalTime、LocalDateTime

public static void main(String[] args) {
    //LocalDate、LocalTime、LocalDateTime
    //now 获取现在的的日期/时间/日期和时间
    LocalDate localDate = LocalDate.now();
    LocalTime localTime = LocalTime.now();
    LocalDateTime localDateTime = LocalDateTime.now();

    System.out.println(localDate);//2020-10-02
    System.out.println(localTime);//12:49:05.972
    System.out.println(localDateTime);//2020-10-02T12:49:05.972

    //of 设置指定年月日时分秒，且没有偏移量
    LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 1, 12, 0, 0);
    System.out.println(localDateTime1);//2020-10-01T12:00

    //常用方法
    //getXxx
    int dayOfYear = localDateTime1.getDayOfYear();
    int dayOfMonth = localDateTime1.getDayOfMonth();
    int monthValue = localDateTime1.getMonthValue();
    Month month = localDateTime1.getMonth();
    System.out.println(dayOfYear);//275
    System.out.println(dayOfMonth);//1
    System.out.println(monthValue);//10
    System.out.println(month);//OCTOBER


    //withXxx
    LocalDateTime localDateTime2 = localDateTime1.withDayOfYear(250);
    LocalDateTime localDateTime3 = localDateTime1.withDayOfMonth(2);
    LocalDateTime localDateTime4 = localDateTime1.withMonth(5);
    System.out.println(localDateTime2.getDayOfYear());
    System.out.println(localDateTime3.getDayOfMonth());
    System.out.println(localDateTime4.getMonth());

    //plusXxx
    LocalDateTime localDateTime5 = localDateTime4.plusMonths(3);
    System.out.println(localDateTime5.getMonthValue());
    //minusXxx
    LocalDateTime localDateTime6 = localDateTime5.minusMonths(4);
    System.out.println(localDateTime6.getMonthValue());
    

}

DateTimeFormatter

对 LocalDate、LocalTime、LocalDateTime 的格式化和解析，和SimpleDateFormat相似

public static void main(String[] args) {

    //方式一：预定义的标准格式：如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
    DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    LocalDateTime localDateTime = LocalDateTime.now();
    String s = formatter.format(localDateTime);
    System.out.println(localDateTime);//2020-10-02T16:03:03.315
    System.out.println(s);//2020-10-02T16:03:03.315

    TemporalAccessor parse = formatter.parse("2020-10-02T16:03:03.315");
    System.out.println(parse);//{},ISO resolved to 2020-10-02T16:03:03.315

    //方式二
    //本地相关的格式：如：ofLocalizedDateTime()
    //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
    DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
    String s1 = formatter1.format(localDateTime);
    System.out.println(s1);//2020年10月2日 下午04时09分07秒

    TemporalAccessor parse1 = formatter1.parse("2020年10月2日 下午04时09分07秒");
    System.out.println(parse1);//{},ISO resolved to 2020-10-02T16:09:07

    //本地相关的格式：如：ofLocalizedDate()
    //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDate
    DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
    String s2 = formatter2.format(localDateTime);
    System.out.println(s2);//2020年10月2日 星期五
    TemporalAccessor parse2 = formatter2.parse("2020年10月2日 星期五");
    System.out.println(parse2);//{},ISO resolved to 2020-10-02

    //方式三：自定义格式。如：ofPatten("yyyy-MM-dd hh-mm-dd");
    DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-dd");
    String s3 = formatter3.format(localDateTime);
    System.out.println(s3);//2020-10-02 04-26-02

    TemporalAccessor parse3 = formatter3.parse("2020-10-02 04-26-02");
    System.out.println(parse3);//{HourOfAmPm=4, MinuteOfHour=26},ISO resolved to 2020-10-02
}

在这里插入图片描述

Java比较器

说明：java 中的对象，正常情况下，只能进行比较： == 或 ！= 。不能使用 > 或 < 的，但是开发场景中，我们需要对多个对象进行排序，也就是说，需要对对象进行排序。

comparable 的使用：自然排序
  1. 像String、包装类等实现了Comparable接口，重写了compareTo（）方法，给出了比较两个对象大小的方法
  2. 像String、包装类重写compareTo（）方法以后，进行了从小到大的排序。
  3. 重写compareTo（）的规则：
    1. 如果当前对象this大于形参对象obj，则返回正整数。
    2. 如果当前对象this小于形参对象obj，则返回负整数。
    3. 如果当前对象this等于形参对象obj，则返回0。
  4. 对于自定义类来说，如果需要排序，可以让自定义类实现Comparable接口，重写compareTo（）方法。在compareTo（）方法中指定如何排序

自定义类

public class Goods implements Comparable{
    private String GoodsName;
    private int price;

    public Goods() {
    }

    public Goods(String goodsName, int price) {
        GoodsName = goodsName;
        this.price = price;
    }

    public String getGoodsName() {
        return GoodsName;
    }

    public void setGoodsName(String goodsName) {
        GoodsName = goodsName;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
    
    //按照价格从低到高排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods goods = (Goods) o;
            if (this.price > goods.price){
                return 1;
            }else if (this.price < goods.price){
                return -1;
            }else{
                return 0;
            }
        }
        throw new RuntimeException("类型数据不匹配！");
    }

    @Override
    public String toString() {
        return "Goods{" +
                "GoodsName='" + GoodsName + '\'' +
                ", price=" + price +
                '}';
    }
}

使用比较器，进行排序

public static void main(String[] args) {
    Goods[] goods = new Goods[5];
    goods[0] = new Goods("ASUS",2060);
    goods[1] = new Goods("Lenovo",2020);
    goods[2] = new Goods("Dell",1998);
    goods[3] = new Goods("Mac",3090);
    goods[4] = new Goods("HP",2080);

    //遍历
    for(Goods goods1:goods){
        System.out.println(goods1);
    }

    Arrays.sort(goods);

    System.out.println("*********** 自然排序后 *************");
    //按照价格从小到大排序
    //遍历
    for(Goods goods1:goods){
        System.out.println(goods1);
    }
}

打印结果
在这里插入图片描述

comparator 的使用：自定义排序

public static void main(String[] args) {
    Goods[] goods = new Goods[5];
    goods[0] = new Goods("ASUS",2060);
    goods[1] = new Goods("Lenovo",2020);
    goods[2] = new Goods("Dell",1998);
    goods[3] = new Goods("Mac",3090);
    goods[4] = new Goods("HP",2080);

    //遍历
    for(Goods goods1:goods){
        System.out.println(goods1);
    }
    
    System.out.println("*********** 定制排序后 *************");
    //按照价格从大到小排序
    Arrays.sort(goods, new Comparator<Goods>() {
        @Override
        public int compare(Goods o1, Goods o2) {
            if (o1.getPrice() > o2.getPrice()){
                return -1;
            }else if (o1.getPrice() < o2.getPrice()){
                return 1;
            }else{
                return 0;
            }
        }
    });

    //遍历
    for(Goods goods1:goods){
        System.out.println(goods1);
    }

}

运行结果
在这里插入图片描述

comparable 和 comparator 接口对比

  • Comparable 接口的方式一旦定义，保证Comparable接口实现类的对象再任何位置都可以比较大小。
  • Comparator接口属于临时性的比较。
merlin梅林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
8、JavaSE：常用类.pdf
04-24
看B站视频项目总结的系列文档，仅供个人学习使用
javaSE基础常用类使用归纳总结
09-17
对java基础的常用类汇总了一下，每一种常用类都对应有对应的案例，方便理解与使用
JavaSE：第八章：java常用类
Java程序员廖志伟
10-07 877
史上最全的知识体系脑图，覆盖所有知识点，所有细节，注意事项。 java常用类：包含包装类，字符串相关的类，JDK 8之前时间日期API， Math类，BigInteger 类与BigDecimal类，StringBuffer，String,StringBuffer,StringBuilder区别。 ...
JavaSE入门学习30：Java常用类之包装类
life is wonderful
03-14 2182
一包装类       我们对基本数据类型都非常熟悉，例如int、float、double、boolean、char等。基本数据类型是不具备对象的特性 的，比如基本类型不能调用方法、功能简单。为了让基本数据类型也具备对象的特性，Java为每个基本数据类型都提 供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。        包装类(如：Integer，Double等)这些类封装
JavaSE：第一章：java语言概述知识脑图
RunningCodeMonkey的博客
12-27 238
JavaSE：第一章：java语言概述 史上最全的JavaSe知识体系脑图，覆盖所有知识点，所有细节，注意事项。 java语言概述：包含基础常识，java语言介绍，java语言运行机制以及运行过程，java语言环境搭建，第一个java程序总结,JAVA注释，java API文档,常用的dos命令。 ...
JavaSE入门学习31：Java常用类之Math类
life is wonderful
03-22 1719
这个Math类一般情况下我们使用不到的，但是为了以后的使用还是要了解一下的。        一使用Math类操作数据        Math类位于java.lang包中，包含用于执行基本数学运算的方法，Math类的所有方法都是静态方法，所以使用该类 中的方法时，可以直接使用类名.方法名，如：Math.round();        常用的方法：         依照上面四个常用方
【JavaSE】之Java常用类
小新要变强的博客
10-08 2461
Java常用类介绍，列举了常用的Java类以及它们的基本用法~
JavaSE：Java基础7：java8新特性
Object的博客
04-30 1207
java8新特性 新特性推出原因：速度更快 ，代码更少，强大的Stream API，便于并行，最大化减少空指针异常Optional。 Lambda表达式：Lambda 是一个 匿名函数，我们可以把 Lambda表达式理解为是 一段可以传递的代码（将代码 像数据一样进行传递）。可以写出更简洁、更灵活的代码。 上两个demo demo1 demo2 ...
JavaSE：SE知识整体总结
最新发布
2401_83595513的博客
06-01 1110
JavaSE学习完毕，知识整体总结
JavaSE入门学习27：Java常用类之String类(上)
life is wonderful
03-07 1721
一String类         字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。在程序开 发中字符串无处不在，如用户登陆时输入的用户名、密码等使用的就是字符串。其实，在前面的章节中我们就已经使 用了字符串，例如我们在控制台中输出的 "Hello World"等。        在Java中，字符串被作为 String 类型的
JavaSE入门学习32：Java常用类之时间日期相关类
life is wonderful
03-28 2278
在Java程序中与日期相关的类包括java.util.Date类、java.text.SimpleDateFormat类、java.util.calendar类和 java.util.GregorianCalendar类。在这里我们只是简单地介绍Date类、SimpleDateFormat类和calendar类的使用。        一Date类表示时间        (1)认识Date
JavaSE目录
热门推荐
本人主攻Java，希望自己能成为出色的程序员。
02-04 34万+
跳转到总目录 01、版本一：视频教程笔记 这个版本是我跟着视频教程做的笔记 教程来源：java基础到高级_零基础自学Java–尚硅谷–宋红康 教程视频地址：https://www.bilibili.com/video/BV1ny4y1Y7CW 名称 笔记地址 一：Java语言概述 二：变量、标识符、保留字、变量 三：运算符 四：程序流程控制 五：数组 六：面向对象（上） 七：面向对象（下） 八：面向对象（中） 九：异常 十：多线程
java常用系统类
04-22
本文档是一个小编在学习javaSE常用系统类中所使用的PPT文档，很实用
java8源码-javaSE:JavaSE是在日常工作中整理的功能demo（如Java操作Excel表格、冒泡算法等）总结这些JavaSE常用
06-04
总结这些JavaSE常用demo，记录工作中常用的方法并方便日后复用。 功能简介 Introduction 1.adapter 设计模式-适配器 2.algorithm 常用算法 2.1 sort 排序算法 2.1.1 冒泡排序 2.2 maxCommonDivisor 求两数最大公约数...
JavaSE_3_Java常用类库
02-09
StringBuffer类，国际化程序，日期操作类，比较器
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 892
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 900
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1209
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 671
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java主要内容_javase主要内容
05-19
JavaSE（Java Standard Edition）是Java平台的标准版，主要用于桌面应用程序、嵌入式系统和服务器端开发等领域。JavaSE包括了Java语言基础、Java核心类库和Java虚拟机等方面的内容，是Java开发的基础。 JavaSE主要内容如下： 1. Java语言基础：Java语言特性、数据类型、运算符、流程控制、数组、异常处理、类和对象、继承、接口、多态等基础知识。 2. Java核心类库：包括了大量的类和接口，如字符串、集合、IO、多线程、网络编程、反射、注解、序列化等。 3. Java虚拟机：Java程序在执行时需要运行在虚拟机上，Java虚拟机负责将Java代码转换为计算机能够理解的机器码，并提供垃圾回收、内存管理等功能。 4. 开发工具和框架：JavaSE开发工具包括JDK、Eclipse、IntelliJ IDEA等，常用的Java框架有Spring、Hibernate、MyBatis等。 总的来说，JavaSE是Java开发的基础和核心，掌握了JavaSE的基本知识和技能，可以进行桌面应用程序、嵌入式系统和服务器端开发等领域的开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值