Java基础--工具类（Collections、Arrays）及其他常用类

最新推荐文章于 2024-08-15 00:08:17 发布
最新推荐文章于 2024-08-15 00:08:17 发布
阅读量2k 收藏 7
点赞数
分类专栏： java基础 文章标签： java 工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/junior8289/article/details/50373068
版权

工具类

集合工具类Collections

  1. Collections类中的方法可对集合进行操作，该类中的方法都是静态的，调用该类的方法时，不需要建立Collections对象，直接调用；
  2. Collections类中的常用方法：
方法功能描述
sort(List< T> list)根据自然顺序对指定列表排序，用法：参数中传入集合
sort(List< T> list,Comparator< ? super T> c)list-集合;c比较器；按指定比较器c为list排序。
max(Collection< ? extends T> coll)根据自然顺序排序，返回collection的最大元素；
max(collection< ? extends T>,Comparator< ? super T>com)根据指定比较器排序，返回Collection的最大元素；
binarySearch(List<>list,T key)根据二分法搜索指定列表，获取指定对象；list-集合；key-指定对象；
binarySearch(List list,T key,Comparator comp)二分法搜索指定列表，获取指定对象，list-集合，key-指定对象，comp-指定比较器；
fill(List list,T obj)使用指定元素替换指定列表中的所有元素；obj-指定元素，list-指定集合
replaceAll(List list,T oldValue,T newVaule)使用一个新值替换指定列表中的旧值
reverse(List list)反转指定列表中元素的顺序，反转比较器；
reverseOlder()返回一个比较器，它强行逆转Comparable接口的对象collection的自然顺序，该方法自身可作为一个比较器传入集合的对象中；
reverseOlder(Comparator< T> comp)返回一个比较器，它强行逆转了指定比较器的顺序，comp-指定比较器
synchronizedList(List list)返回由指定集合支持的同步的集合
SynchronizedSet(Set< T> s)返回由指定集合支持的同步的集合
SynchronizedMap(Map< k,v>m)返回由指定集合支持的同步的集合
shuffle(List list)使用默认随机源对指定列表进行置换
shuffle(List list,Random rnd)使用指定的随机源对指定列表进行置换

集合工具类示例代码：

import java.util.*;
class  CollectionsDemo{
    public static void main(String[] args) {
        sortDemo();
    }
    public static void binarySearchDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        Collections.sort(list,new StrLenComparator());
        sop(list);
        //int index = Collections.binarySearch(list,"aaaa");
        //int index = halfSearch(list,"cc");
        int index = halfSearch2(list,"aaaa",new StrLenComparator());
        sop("index="+index);
    }
    public static int halfSearch(List<String> list,String key){
        int max,min,mid;
        max = list.size()-1;
        min = 0;
        while(min<=max){
            mid = (max+min)>>1;//  /2;
            String str = list.get(mid);
            int num = str.compareTo(key);
            if(num>0)
                max = mid -1;
            else if(num<0)
                min = mid + 1;
            else
                return mid;
        }
        return -min-1;
    }
    public static int halfSearch2(List<String> list,String key,Comparator<String> cmp){
        int max,min,mid;
        max = list.size()-1;
        min = 0;
        while(min<=max){
            mid = (max+min)>>1;//  /2;
            String str = list.get(mid);
            int num = cmp.compare(str,key);
            if(num>0)
                max = mid -1;
            else if(num<0)
                min = mid + 1;
            else
                return mid;
        }
        return -min-1;
    }
    public static void maxDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        Collections.sort(list);
        sop(list);
        String max = Collections.max(list/*,new StrLenComparator()*/);
        sop("max="+max);
    }
    public static void sortDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");  
        sop(list);
        //Collections.sort(list);
        Collections.sort(list,new StrLenComparator());
        //Collections.swap(list,1,2);
        sop(list);  
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
class StrLenComparator implements Comparator<String>{
    public int compare(String s1,String s2){
        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;
        return s1.compareTo(s2);
    }
}

数组工具类

  1. Arrays：数组工具类用于操作数组的工具类，里面都是静态方法，不用建立对象可直接使用：Arrays.方法名()；的方式调用；
  2. Arrays类中的常用方法
方法功能描述
binarySearch(int[] a,int key)使用二分法搜索指定的基本数据类型数组，以获得指定的值，a-数组；key-值
deepEquals(Object[]a1,Object[] a2)深度比较，如果两数组是深层次相等的，则返回true；
deepHashCode(Object[] a)返回指定数组的深层内容的哈希值
deepToString(Object[] a)返回指定数组深层内容的字符串表示形式
equals(int[] a,int[] a1)如果两个指定的基本数据类型数组相等返回true
fill(int[] a,int[] val)将指定的基本数据类型值分配给指定数组的所有元素
fill(int[] a,int fromIndex,int toIndex,int val)将指定的基本数据类型值分配给基本数据类型数组中指定范围的每个元素
hashCode(int[] a)返回指定数组a的哈希码
sort(int[] a)对指定的基本数据类型数组按升序排列
sort(int[] a,int fromIndex,int toIndex)对指定的基本数据类型数组的指定范围按升序排列
toString(int[] a)返回指定基本数据类型数组内容的字符串表示形式
asList(T… a)返回一个集合，该方法可以将数组转换成List集合，a-支持列表的数组，将数组转成集合后可使用集合的思想和方法操作数组的元素；（注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的；如果数组中的元素都是引用类型，那么变成集合时，数组中的元素就直接转成集合中的元素，如果数组中元素都是基本数据类型，那么会将数组作为集合中的元素存储）
toArray(T[] a)返回一个指定类型的数组，该数组中包含collection中所有元素，a-指定数组；1.当指定数组a的长度小于集合的size，则该方法内部会创建一个新的数组，长度为集合的size，当指定类型的数组长度大于集合的size，则不会创建而是使用传递进来的数组，多余的位置为null，所以创建一个集合.size()长度的数组最优；2.集合变数组是为了限定对元素的操作，不需要进行增删；

数组工具类示例代码：

import java.util.*;
class  ArraysDemo{
    public static void main(String[] args) {
        String[] arr = {"abc","cc","kkkk"};
        //把数组变成list集合有什么好处？
        /*
        可以使用集合的思想和方法来操作数组中的元素。
        注意：将数组变成集合，不可以使用集合的增删方法。
        因为数组的长度是固定。
        contains。
        get
        indexOf()
        subList();
        如果你增删。那么会反生UnsupportedOperationException,
        */
        List<String> list = Arrays.asList(arr);
        //sop("contains:"+list.contains("cc"));
        //list.add("qq");//UnsupportedOperationException,
        //sop(list);
        //int[] nums = {2,4,5};
        Integer[] nums = {2,4,5};   
        List<Integer> li = Arrays.asList(nums);
        /*
        如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
        如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
        */
        sop(li);
    }
    public static boolean myContains(String[] arr,String key){
        for(int x=0;x<arr.length; x++){
            if(arr[x].equals(key))
                return true;
        }
        return false;
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
//集合变数组；
import java.util.*;
class  CollectionToArray
{
    public static void main(String[] args) 
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        String[] arr = al.toArray(new String[al.size()]);
        System.out.println(Arrays.toString(arr));
    }
}

高级for循环

  1. 格式：
for(数据类型  变量名:被遍历的集合(Collection)或数组)
{
    执行语句；
}
  1. 对集合进行遍历，只能获取集合元素，但是不能对集合进行操作，迭代器除了遍历，还可以进行remove集合中元素的动作，如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作；
  2. 与传动for的区别：高级for有一个局限性，必须有被遍历的目标，建议在遍历数组的时候，还是使用传统for，因为传统for可以定义角标；

示例代码：

import java.util.*;
class ForEachDemo {
    public static void main(String[] args) {    
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        for(String s : al){
            //s = "kk";
            System.out.println(s);
        }
        System.out.println(al);
        /*
        Iterator<String> it = al.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        */
        int[] arr = {3,5,1};
        for(int x=0; x<arr.length; x++){
            System.out.println(arr[x]);
        }
        for(int i : arr){
            System.out.println("i:"+i);
        }
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"a");
        hm.put(2,"b");
        hm.put(3,"c");
        Set<Integer> keySet = hm.keySet();
        for(Integer i : keySet){
            System.out.println(i+"::"+hm.get(i));
        }
//      Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
//      for(Map.Entry<Integer,String> me : entrySet)
        for(Map.Entry<Integer,String> me : hm.entrySet()){
            System.out.println(me.getKey()+"------"+me.getValue());
        }
    }
}

可变参数

  1. 概述：可变参数是函数的另一种表现形式，传递的参数个数可变；
  2. 格式：
返回值类型  函数名(参数类型...形式参数)
{
    执行语句；
}
  1. 可变参数其实接收的是一个数组，可以指定实际参数个数；
  2. 可变参数一定要定义在参数列表最后面，因为当传入的参数有多种类型时，会将前面的先匹配完，剩下的参数封装成数组，如果在前面将会出现类型匹配异常；
    例：定义一个函数
public static void show(String str,int... arr)
{
    语句；
}

调用show函数：
show(“hahaha”,2,3,4,5…);该函数在调用时,第一个参数为String类型(只能有一个，因为形式参数String只有一个)匹配给str，后面的2，3,4,5…为int类型自动封装为数组传递给arr，因为arr为可变参数的，所以函数调用传递时int形式参数不固定，传多少就是多少，注：可变参数必须是同一数据类型，有形参类型决定；

静态导入

  1. 当import后边跟static的时候，导入的是某一个类中的所有的静态成员，故：当某一类中的方法都是静态的时候可以使用静态导入该类，那么在调用该类中的方法时就不用再在前面加上“类名.”了；
  2. 静态导入可简化书写；
  3. 静态导入的格式：
    import static java.包名.类名.*；
    例：导入Arrays类中的所有静态成员；
    import static java.util.Arrays.*;
  4. 注意：
    • 当类名重名时，需要指定具体的包名；
    • 当方法重名时，指定具备所属的对象或者类；
      例：toString()方法，所有类中都有，使用时需注明类名或对象；
  5. 常用如：Collections，Arrays，System类都可使用静态导入方式简化书写；

静态导入示例代码：

import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
import static  java.lang.System.*;//导入了System类中所有静态成员。
class  StaticImport //extends Object{
    public static void main(String[] args) {
        out.println("haha");
        int[] arr = {3,1,5};
        sort(arr);
        int index = binarySearch(arr,1);
        out.println(Arrays.toString(arr));
        System.out.println("Index="+index);
        ArrayList al = new ArrayList();
        al.add(1);
        al.add(3);
        al.add(2);
        out.println(al);
        sort(al);
        out.println(al);
    }
}

其他对象

System类

  1. System类中的方法和属性都是静态的；
    • out：标准输出，默认是控制台；
    • in：标准输入，默认是键盘；
  2. System类中一些常用方法：
方法功能描述
getProperties()获取系统属性信息，返回一个Properties类型的集合，Properties是Hashtable的子类，故可以通过Map的方法对其操作，该集合中都是字符串，没有泛型定义
getProperty(String key)获取指定键指示的系统属性，没有返回null
setProperty(String key,String value)设置系统属性（自定义）
currentTimeMillis()返回以毫秒为单位的当前时间
exit(int status)退出JVM虚拟机，status退出状态
gc()运行垃圾回收器

3. JVM启动时可动态加载一些属性信息：
格式：java -D属性名称=属性值 类文件；

示例代码：

import java.util.*;
class SystemDemo {
    public static void main(String[] args) {
        Properties prop = System.getProperties();   
        //因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
        //那么可以通过map的方法取出该集合中的元素。
        //该集合中存储都是字符串。没有泛型定义。       
        //如何在系统中自定义一些特有信息呢？
        System.setProperty("mykey","myvalue");
        //获取指定属性信息。
        String value = System.getProperty("os.name");
        System.out.println("value="+value);
        //可不可以在jvm启动时，动态加载一些属性信息呢？
        String v = System.getProperty("haha");
        System.out.println("v="+v);
        /*//获取所有属性信息。
        for(Object obj : prop.keySet())
        {
            String value = (String)prop.get(obj);

            System.out.println(obj+"::"+value);
        }
        */
    }
}

Runtime类

1.Runtime类没有提供构造函数(构造函数被私有化)，不能创建对象，每个Java程序都有一个Runtime类实例，可通过getRuntime()方法获取：
static Runtime getRuntime()；//该方法返回本类对象；要想使用该类中的方法，可先调用该方法，获取对象；
2. 常用方法：

  • exec(String command)在单独的进程中执行指定的字符串命令，该方法可启动pc中的应用程序，command-程序名；
    • exec方法返回一个类型为Process的实例，该类有一个方法可以杀掉exec启动的程序，该方法为：
      destory()；杀掉子进程//Process类方法，谁调用杀谁；
  • exce(String command file)可由command程序打开file文件，command为打开程序，file为可由command程序打开的文件；
    例：Runtime r=Runtime.getRuntime()；//返回本类对象；
    Process p=r.exce(“notepad **.txt”)//用记事本打开**.txt文件；
    p.destroy();//杀掉notepad进程；

示例代码：

class  RuntimeDemo{
    public static void main(String[] args) throws Exception{
        Runtime r = Runtime.getRuntime();
        Process p = r.exec("notepad.exe  SystemDemo.java"); 
        //Thread.sleep(4000);
        //p.destroy();
    }
}

Date类（时间、日期）

  1. 创建一个Date类对象，打印可显示当前时间，通过SimpleDateFormat类的对象可设置指定格式，调用该父类中的format()方法并将时间对象传递，可按指定的模式格式化时间（将时间模式作为字符串传入SDF的构造函数，不传则为默认格式）；

  2. 设置时间模式定义了模式字母，常用的如：

    字符字符含义
    y年
    M年中的月份
    d月份中的天数
    E星期中的天数
    ham/pm中的小时数(1-12)
    H一天中的小时数(0-23)
    m小时中的分钟数
    s分钟的秒数
    S毫秒数

  3. 模式封装传入的是字符串：

//例：
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E hh：mm：ss");
String time=sdf.format(d);//该format(d)方法调用的是父类DateFormat中的方法，返回String；

示例代码：

import java.util.*;
import java.text.*;
class DateDemo {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);//打印的时间看不懂，希望有些格式。
        //将模式封装到SimpleDateformat对象中。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");   
        //调用format方法让模式格式化指定Date对象。
        String time = sdf.format(d);
        System.out.println("time="+time);
        long l = System.currentTimeMillis();
        Date d1 = new Date(l);
        System.out.println("d1:"+d1);
    }
}

注：SimpleDateForat类属Java.text包；该类继承DateFormat（抽象的）也属于Java.text包；

Calendar类

  1. 为操作日历字段提供了一些方法；
  2. 该类常用方法示例：
    • getInstance();以获得此类型的一个通用的对象，该方法返回一个Calendar对象；
      Calendar c=Calendar.getInstance();
      不传参数则使用默认时区和语言环境获得一个日历；
    • get(int field);通过调用该方法返回给定日历字段的值。例：
      c.get(Calendar.MONTH);
    • set(int year,int month,int date)；设置日历字段YEAR.MONTH和DAY_OF_MONTH的值。例：
      c.set(2012,2,23);
    • add(int field,int amount);根据日历的规则，为给定的日历字段添加或减去指定的时间量，例：
      c.add(MONTH,2)//当前月份+2个月；
      c.add(DAY_OF_MONTH,10)//当前日期+10天；
      参数：field-日历字段；amount-偏移量；
      常用字段：
字段字段含义
YEAR年
MONTH月(0-11)
DAY_OF_MONTH月中的某天
DAY_OF_WEEK星期中的某天(0-6)
HOUR时
MINUTE分
SECOND秒

示例代码：

class  CalendarDemo2{
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        //c.set(2012,2,23);
        c.add(Calendar.DAY_OF_MONTH,-18);   
        printCalendar(c);
    }
    public static void printCalendar(Calendar c){
        String[] mons = {"一月","二月","三月","四月"
                    ,"五月","六月","七月","八月"
                    ,"九月","十月","十一月","十二月"};
        String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};        
        int index = c.get(Calendar.MONTH);
        int index1 = c.get(Calendar.DAY_OF_WEEK);
        sop(c.get(Calendar.YEAR)+"年");
        //sop((c.get(Calendar.MONTH)+1)+"月");
        sop(mons[index]);
        sop(c.get(Calendar.DAY_OF_MONTH)+"日");
        //sop("星期"+c.get(Calendar.DAY_OF_WEEK));
        sop(weeks[index1]);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

Math类

  1. Math类中的包含用于执行基本数学运算的方法（全都是静态方法）；
  2. 常用方法：
方法功能描述
ceil(double a)返回大于指定数据的最小整数，类型double
floor(double a)返回小于指定数据的最大整数，返回类型为double
round(float a)四舍五入
pow(double a,double b)返回a的b次幂的值，返回类型double
ranom()返回一个0~1之间的随机数，返回类型为double
import java.util.*;
class  MathDemo{
    public static void main(String[] args) {        
        /*Random r = new Random();
        for(int x=0; x<10; x++){
            //int d = (int)(Math.random()*10+1);
            int d = r.nextInt(10)+1;
            sop(d);
        }*/
        saveTwo(12.3456,3,true);//12.34
    }
    public static void saveTwo(double d,int scale,boolean isRound){ 
        double base = Math.pow(10,scale);
        double num = isRound?Math.round(d*base)/base:((int)(d*base))/base;
        sop("num="+num);
        /*
        double d1 = d*100;
        sop("d1="+d1);
        d1 = d1+0.5;
        double d2 = (int)d1;
        sop("d2="+d2);
        double d3 = d2/100;
        sop("d3="+d3);
        */
    }
    public static void show(){
        double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
        double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。
        long l = Math.round(12.54);//四舍五入
        sop("d="+d);
        sop("d1="+d1);
        sop("l="+l);
        double d2 = Math.pow(2,3);
        sop("d2="+d2);
    }
    public static void sop(Object obj){ 
        System.out.println(obj);
    }
}
junior8289
关注
专栏目录
Java中的集合---------Collections 类---集合的工具类 Comparator比较器
norang的博客
03-27 232
Collections 2.1 常用功能 java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。 public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。 public static <T> void sort(Li
java常用的工具类整理28个
05-28
下面我们将详细探讨Java中28个常用的工具类，主要涉及`IO`相关的开发工具。 1. **java.lang.Math**：这个类提供了许多基础数学函数，如求平方根、最大值、最小值、随机数生成等。 2. **java.util.Arrays**：用于...
Java常用工具类
04-27
收集了Java开发中的常用工具类，帮助大家更快速的开发，省去这些小工具的烦恼
Java并发基础-并发工具类(一)
weixin_30371469的博客
09-06 133
并发工具类 本系列文章主要讲解Java并发相关的内容，包括同步、锁、信号量、阻塞队列、线程池等，整体思维导图如下： 系列文章列表： Java并发基础-并发模型、基础接口以及Thread Java并发基础-同步和锁 本文主要以实例讲解CountDownLatch、Semaphore、阻塞队列和线程池等内容。 CountDownLatch 基本概念和用途 CountDownLatch主要是在其...
【JAVA】Collections类 详解
最新发布
weixin_37559642的博客
08-15 1027
Collections类 详解
项目经验分享——Java常用工具类集合
热门推荐
DBA@Robin
03-09 1万+
写在前面   本文涉及的工具类部分是自己编写，另一部分是在项目里收集的。工具类涉及数据库连接、格式转换、文件操作、发送邮件等等。提高开发效率，欢迎收藏与转载。   数据库连接工具类   数据库连接工具类——仅仅获得连接对象 ConnDB.java package com.util; import java.sql.Connection; import java.sql.Driver
Java常用的工具类
qq_40981804的博客
10-23 112
IOUtils LongAdder：LongAdder 是一个多线程高并发时使用的自增计数器，它的设计思想就是以空间换时间。相比较于 AtomicLong，它在高并发时更高效，因为 AtomicLong 自增时使用了 unsafe.getAndAddLong cells数组是LongAdder高性能实现的必杀器： AtomicInteger只有一个value，所有线程累加都要通过cas竞争value这一个变量，高并发下线程争用非常严重； 而LongAdder则有两个值用于累加，一个是base，它的作用类
Java基础----集合类汇总
03-28
Java集合框架还包含了一些工具类，如Collections和Arrays，它们提供了各种实用方法，如排序、复制、反转和查找集合中的特定元素。此外，Set和List接口都有一个叫做CopyOnWriteArrayList和CopyOnWriteArraySet的特殊...
1-Collections-Overview-Section-Java-Collections-S_overview
09-24
本项目“1-Collections-Overview-Section-Java-Collections-S_overview”着重于概述Java集合框架的基本概念和关键组件，旨在帮助开发者理解和掌握这个强大的工具。 在Java中，集合框架包括两种主要类型：集合...
Java常用ArrayUtile工具类
04-28
### Java常用ArrayUtil工具类知识点解析 #### 一、判断数组是否为空（null或长度为0） **功能：** 此方法用于检查一个对象数组是否为空。如果数组为`null`或者数组的长度为0，则认为该数组为空。 **代码实现：** ...
JAVA常用工具类
qq_41799291的博客
03-09 180
1.常用的16个工具类 1一、org.apache.commons.io.IOUtils 1、closeQuietly 关闭一个IO流、socket、或者selector且不抛出异常。通常放在finally块。 2、toString 转换IO流、Uri、byte[]为String。 3、copy IO流数据复制，从输入流写到输出流中，最大支持2GB。 4、toByteArray 从输入流、URI获...
Java 常用工具类
qq_41948178的博客
02-27 112
读取properties文件 public static void loadConfiguration() { Properties properties = new Properties(); BufferedReader bufferedReader = null; try { bufferedReader = new ...
Java常用工具类详解：Collections、Arrays等
"这篇文档介绍了Java中常用的工具类库，包括Collections、Arrays、Math、BigInteger、Random、Scanner以及System.out，特别关注了Collections类的一些关键方法，并强调了在使用这些工具类时，自定义数据类型需遵循的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值