android 4-3排列的流式布局（直接上代码，原创）

最新推荐文章于 2024-07-10 03:09:53 发布
最新推荐文章于 2024-07-10 03:09:53 发布
阅读量739 收藏
点赞数 4
分类专栏： http://lbs.amap.com/faq/top/ho
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_33331545/article/details/79165074
版权 
import android.content.Context;
import android.graphics.Color;
import android.support.annotation.DrawableRes;
import android.support.annotation.IntDef;
import android.support.annotation.NonNull;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.android.yazm.mylibrary.utils.UIUtils;
import com.android.yazm.yiaizhiming.bean.MyGroupCheckedBean;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by fanqibo on 2018/1/22.
 */

public class NoNameViewGroup extends ViewGroup implements View.OnClickListener {
    private ArrayList<MyGroupCheckedBean> arrayList = new ArrayList<>();
    private ArrayList<String> mList = new ArrayList<>();
    private ArrayList<MyGroupCheckedBean> addNewTagList = new ArrayList<>();

    //获取的默认间距;depadding是算出来的
    private int depadding = -1;
    private int depaddingHeight;
    //最好在dimens做下适配
    private int width = UIUtils.dp2px(getContext(), 64);
    private int height = UIUtils.dp2px(getContext(), 50) / 2;

    public NoNameViewGroup(Context context) {
        super(context);
    }

    public NoNameViewGroup(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    private void getdpding(int gwidth, int childWidth, int cl, int cr) {
        int allwidth = gwidth - cl - cr;
        if (childWidth * 4 < allwidth) {
            depadding = (allwidth - childWidth * 4) / 3;
        }
        depaddingHeight = depadding / 2;
    }

    @IntDef({AddLocation.LOCATION_UP, AddLocation.LOCATION_DOWN})
    @Retention(RetentionPolicy.SOURCE)
    public @interface AddLocation {
        int LOCATION_UP = 1;
        int LOCATION_DOWN = 2;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        measureChildren(widthMeasureSpec, heightMeasureSpec);
        int mViewGroupWidth = getMeasuredWidth();
        int allwidth = mViewGroupWidth - getPaddingLeft() - getPaddingRight();
        if (depadding == -1) {
            depadding = (allwidth - width * 4) / 3;
        }
        int h = Math.max((getChildCount() / 7 + 1) * 2 * (depadding / 2 + height) + topMargin + bottomMargin, heightMeasureSpec);
        Log.e("getChildCount():" + getChildCount() + "/", "h:" + h + "/" + "depadding:" + depadding + "/" + " + height:" + height);
        setMeasuredDimension(widthMeasureSpec, h);
    }

    private void initView(String string, int pos, boolean select) {
        TextView textView = new TextView(getContext());
        textView.setGravity(Gravity.CENTER);
        textView.setWidth(width);
        textView.setHeight(height);
        textView.setText(string);
        textView.setTextSize(12);
        textView.setBackgroundResource(select ? R.drawable.lable_select : R.drawable.lable_normal);
        textView.setTextColor(Color.BLACK);
        textView.setOnClickListener(this);
        if (pos == -1) {
            addView(textView);
        } else {
            addView(textView, pos);
        }
    }

    public void addViews(@NonNull ArrayList<MyGroupCheckedBean> list) {
        for (int i = 0; i < list.size(); i++) {
            MyGroupCheckedBean bean = new MyGroupCheckedBean();
//            bean.setB(list.get(i).isB());
            bean.setString(list.get(i).getString());
            this.arrayList.add(bean);
            initView(bean.getString(), i, false);
        }
    }
    public void addTagView(String text){
        addTagView(AddLocation.LOCATION_UP,text,true);
    }
    public void addTagView(String text, boolean select){
        addTagView(AddLocation.LOCATION_UP,text,select);
    }
    public void addTagView(@AddLocation int addLocation, String text, boolean select) {
        if (isHadTag(text)) {
            Log.e("hadText", "hahaha");
            if (listener != null) {
                listener.isHad(true);
            }
        } else {
            if (select && canChecked()) {
                if (addLocation == AddLocation.LOCATION_UP) {
                    addNewTagList.add(new MyGroupCheckedBean(true, text,false));
                    arrayList.add(0, new MyGroupCheckedBean(true, text,false));
                    initView(text, 0, true);
                } else {
                    addNewTagList.add(new MyGroupCheckedBean(true, text,false));
                    arrayList.add(new MyGroupCheckedBean(true, text,false));
                    initView(text, -1, true);
                }

            } else if (!select) {
                if (addLocation == AddLocation.LOCATION_UP) {
                    addNewTagList.add(new MyGroupCheckedBean(false, text,false));
                    arrayList.add(0, new MyGroupCheckedBean(false, text,false));
                    initView(text, 0, false);
                } else {
                    addNewTagList.add(new MyGroupCheckedBean(false, text,false));
                    arrayList.add(new MyGroupCheckedBean(false, text,false));
                    initView(text, -1, false);
                }
            } else if (!canChecked()) {
                if (listener != null) {
                    listener.isMax(true);
                }
                if (addLocation == AddLocation.LOCATION_UP) {
                    addNewTagList.add(new MyGroupCheckedBean(false, text,false));
                    arrayList.add(0, new MyGroupCheckedBean(false, text,false));
                    initView(text, 0, false);
                } else {
                    addNewTagList.add(new MyGroupCheckedBean(false, text,false));
                    arrayList.add(new MyGroupCheckedBean(false, text,false));
                    initView(text, -1, false);
                }
            }
        }
    }


    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        Log.e("onlayout", "布局重绘制");
        hang = 1;
        int mViewGroupWidth = getMeasuredWidth();  //当前ViewGroup的总宽度
        int paddingLeft = getPaddingLeft();
        int paddingRight = getPaddingRight();

        int childCount = getChildCount();
        Log.e("childCount", childCount + "");

        for (int i = 0; i < childCount; i++) {
            View childView = getChildAt(i);
            getdpding(mViewGroupWidth, width, paddingLeft, paddingRight);
            initChild(childView, mViewGroupWidth, i + 1, l, t, r, b);
        }
    }

    private int hang = 1;
    private int doubleLeft;
    private int doubleRight;
    private int topMargin = 30;
    private int bottomMargin = 30;

    private void initChild(View cv, int dadw, int count, int l, int t, int r, int b) {
        t = 0;
        doubleRight = doubleLeft = (dadw - 3 * width - 2 * depadding) / 2;
        int zuo = 0;
        int shang = 0;
        int you = 0;
        int xia = 0;

        switch (count % 7) {
            case 1:
                zuo = l;
                you = zuo + width;
                if (count / 7 < 1) {
                    shang = topMargin + t;

                } else {
                    shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                }
                xia = shang + height;
                cv.layout(zuo + getPaddingLeft(), shang + getPaddingTop(), you + getPaddingLeft(), xia + getPaddingTop());
                break;
            case 2:
                zuo = l + depadding + width;
                you = l + depadding + 2 * width;
                if (count / 7 < 1) {
                    shang = topMargin + t;

                } else {
                    shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                }
                xia = shang + height;
                cv.layout(zuo + getPaddingLeft(), shang + getPaddingTop(), you + getPaddingLeft(), xia + getPaddingTop());
                break;
            case 3:
                zuo = l + 2 * depadding + 2 * width;
                you = l + 2 * depadding + 3 * width;
                if (count / 7 < 1) {
                    shang = topMargin + t;

                } else {
                    shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                }
                xia = shang + height;
                cv.layout(zuo + getPaddingLeft(), shang + getPaddingTop(), you + getPaddingLeft(), xia + getPaddingTop());
                break;

            case 4:
                zuo = l + 3 * depadding + 3 * width;
                you = l + 3 * depadding + 4 * width;
                if (count / 7 < 1) {
                    shang = topMargin + t;

                } else {
                    shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                }
                xia = shang + height;
                hang += 1;
                cv.layout(zuo + getPaddingLeft(), shang + getPaddingTop(), you + getPaddingLeft(), xia + getPaddingTop());
                break;
            case 5:
                zuo = l + doubleLeft;
                you = l + width + doubleLeft;
                shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                xia = shang + height;

                cv.layout(zuo, shang + getPaddingTop(), you, xia + getPaddingTop());
                break;
            case 6:
                zuo = l + width + doubleLeft + depadding;
                you = l + 2 * width + doubleLeft + depadding;
                shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                xia = shang + height;
                cv.layout(zuo, shang + getPaddingTop(), you, xia + getPaddingTop());
                break;
            case 0:
                zuo = l + 2 * width + doubleLeft + 2 * depadding;
                you = l + 3 * width + doubleLeft + 2 * depadding;
                shang = t + topMargin + (depaddingHeight + height) * (hang - 1);
                xia = shang + height;
                hang += 1;
                cv.layout(zuo, shang + getPaddingTop(), you, xia + getPaddingTop());
                break;
        }
    }

    int max = -1;

    private boolean canChecked() {
        return max == -1 || !arrayList.isEmpty() && getListSize() <= max;
    }

    private int getListSize() {
        int a = 0;
        for (MyGroupCheckedBean bean : arrayList) {
            if (bean.isB()) {
                a += 1;
            }
        }
        return a;
    }

    //是否有重复的标签
    private boolean isHadTag(String s) {
        for (MyGroupCheckedBean bean:arrayList){
            if (bean.getString().equals(s)){
                return true;
            }
        }
        return false;
    }

    //获取选中标签集合
    public ArrayList<String> getTagList() {

        for (MyGroupCheckedBean bean : arrayList) {
            if (bean.isB()) {
                mList.add(bean.getString());

            }
        }
        return mList;
    }
    //获取选中标签集合
    public ArrayList<MyGroupCheckedBean> getAllTagList() {
        for (MyGroupCheckedBean bean : arrayList) {
            if (!bean.isB()&&!bean.isBelongToDefault()) {
                arrayList.remove(bean.getString());
            }
        }
        return arrayList;
    }
    //设置最大标签限制
    public void setMaxChoose(int max) {
        if (max < arrayList.size()) {
            this.max = max;
        }
    }
    private int getPosition(String s){
       for (int i=0;i<arrayList.size();i++){
            if (arrayList.get(i).getString().equals(s)){
                return i;
            }
       }
       return -1;
    }
    @Override
    public void onClick(View v) {

        TextView textView = (TextView) v;
        int tag = getPosition(textView.getText().toString());
        if (tag==-1){
            return;
        }
        boolean b = arrayList.get(tag).isB();
        if (b) {
            textView.setBackgroundResource(mBg_u);
            arrayList.get(tag).setB(false);
            if (listener != null) {
                listener.isMax(false);
                listener.itemSelect(textView.getText().toString());
            }
        } else {
            if (listener != null) {
                listener.itemSelect(textView.getText().toString());
            }
            if (canChecked()) {
                textView.setBackgroundResource(mBg_s);
                arrayList.get(tag).setB(true);
            } else {
                if (listener != null) {
                    listener.isMax(true);
                }
            }
        }
    }

    private int mBg_s = R.drawable.lable_select;//选中

    public void setBackGroundSelect(@DrawableRes int res) {
        mBg_s = res;
    }

    private int mBg_u = R.drawable.lable_normal;//未选中

    public void setBackGroundUnSelect(@DrawableRes int res) {
        mBg_u = res;
    }

    private OnGroupSelectListener listener;

    public void setListener(OnGroupSelectListener listener) {
        this.listener = listener;
    }

    public interface OnGroupSelectListener {
        //每次点击得到的
        public void itemSelect(String text);

        //是否达到了最大值
        public void isMax(boolean b);

        //是否有同名的标签
        public void isHad(boolean b);

    }
}
支持套scrollview ，不支持在xml里写布局，支持padding，不支持吗，margin，
套scrollview 注意一点，android:fillViewport="true"
动态添加的时候方法如下
for (int i=0;i<200;i++){
    arrayList.add(new MyGroupCheckedBean(false,i+"",true));
}
NoNameViewGroup n=findViewById(R.id.group);
n.addViews(arrayList);
n.setMaxChoose(20);
n.setListener(this);
public class MyGroupCheckedBean {
    private boolean b;
    private String string;
    private boolean belongToDefault;//这个是防止原有标签和动态添加标签的时候做区分

    public MyGroupCheckedBean() {
    }

    public MyGroupCheckedBean(boolean b, String string,boolean belongToDefault) {
        this.b = b;
        this.string = string;
        this.belongToDefault=belongToDefault;
    }

    public boolean isB() {
        return b;
    }

    public void setB(boolean b) {
        this.b = b;
    }

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }

    public boolean isBelongToDefault() {
        return belongToDefault;
    }

    public void setBelongToDefault(boolean belongToDefault) {
        this.belongToDefault = belongToDefault;
    }


如有问题请私信，或留言



                

        

        

    

  


    

      

        

            

              
                
                  hackbutter123
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    4
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
android四列均匀布局,Android的4种基本布局

				
			

			

				

					weixin_39628342的博客
				

				

					05-27
					
					500
					
				

			

		

		

			
				
1.什么是布局？布局是一种可用于放置很多控件的容器,它可以按照一定的规律调整内部控件的位置，从而编写出精美的界面。布局的内部可以放置控件，当然了也可以放置布局，我们可以灵活的使用布局的嵌套从而实现出复杂的界面。  这个就是布局与控件的关系2.四种基本的布局- LinearLayout(线性布局)：这种布局的显示特点是所有子控件按横向或者纵向有序的排列android:orientation=”ver...

			
		

	



                

              
                



	

		

			

				
					
Android 组件 —— 流式布局

				
			

			

				

					萌动小彩笔的博客
				

				

					07-27
					
					2648
					
				

			

		

		

			
				
这是一个Android流式布局，根据鸿翔大神之前写的FlowLayout设计思路结合Material库中的ChipGroup设计架构衍生而来，全新的流式布局组件。

			
		

	



                


  
              

                


	

		

			

				
					
Android-RandomLayout随机布局控件

				
			

			

				

					08-13
				

			

		

		

			
				
RandomLayout 随机布局控件

			
		

	





	

		

			

				
					
android固定布局,Android固定布局3/4 + 1/4

				
			

			

				

					weixin_42719781的博客
				

				

					05-26
					
					252
					
				

			

		

		

			
				
我很努力与android布局设置。无论内容是什么，我都想保持相同的固定大小，并且想要在中心显示所有内容！Android固定布局3/4 + 1/4----------------------------------      -  --      -  --  3/4 (center)  - 1/4 --      - (ct) --      -  --      -  -------------...

			
		

	



		

			
		



	

		

			

				
					
Android 开发流式布局

					
最新发布

				
			

			

				

					weixin_42139042的博客
				

				

					07-10
					
					45
					
				

			

		

		

			
				
Android 开发流式布局
在进行 Android 开发过程中，我们经常需要处理各种不同大小和数量的视图，这时候使用流式布局是一个不错的选择。流式布局可以让我们更方便地处理各种视图的排列，适应不同屏幕尺寸的需求。
什么是流式布局？
流式布局是一种能够根据视图的大小和数量自动调整布局的方式。它允许视图在一行不够的时候自动换...

			
		

	





	

		

			

				
					
流式布局点击字幕 跳转页面

				
			

			

				

					江霞的博客
				

				

					08-24
					
					293
					
				

			

		

		

			
				
main.xml


&lt;?xml version="1.0" encoding="utf-8"?&gt;
&lt;LinearLayout
    android:orientation="vertical"
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schema

			
		

	





	

		

			

				
					
安卓常用的三行布局

				
			

			

				

					bestlbw的博客
				

				

					12-11
					
					1456
					
				

			

		

		

			
				
第一次写博客，记录自己在日常开发中用到的实用的技术和技巧，与各位共享；
最近在app开发当中涉及到资讯方面的布局，举个例子？




在上面这个新闻详情界面，布局就是标准的三行布局: 上面一个titlebar,中间是content，下面是交互；
类似这样的布局，快速而高效的就是利用RelativeLayout:
最上方是一个自定义的titlebar，当然换成你喜欢xxbar都可以


			
		

	





	

		

			

				
					
Android自定义View —流式布局FlowLayout

				
			

			

				

					01-03
				

			

		

		

			
				
现在大部分商城类app都要用到流式布局，就是对不规则的子view进行布局排列。 自定义流式布局不外乎两点，重写onMeasure方法和onLayout方法。大部分代码我都写了注释，但还是有一些比较细节的地方，我还会抽取出来...

			
		

	





	

		

			

				
					
Android自定义控件--流式布局(FlowLayout)--自动适配

				
			

			

				

					kafly的博客
				

				

					11-03
					
					6995
					
				

			

		

		

			
				
在android开发中，随着开发需求的不断提升，android原生的控件在很大程度上已不能满足开发者以及用户的需求，为了更好的增加用户体验，更有利的维护UI,在一个完整的程序中，自定义控件往往是不可或缺的知识，我根据自己的学习经验，现在对自定义控件的分类，以及自定义控件的流程，然后根据FlowLayout案例进行简单分析

			
		

	





	

		

			

				
					
Android中常见的流式布局的使用

				
			

			

				

					论一个程序员的自我修养
				

				

					11-17
					
					3089
					
				

			

		

		

			
				
Android中常见的自定义FlowLayout流式布局的使用
  在日常的app使用中，我们会在Android 的app中看见,比如淘宝购物页面尺寸的选取，脉脉和慕课技术职位的选取等等热门标签自动换行的流式布局，今天，我们就来看看如何自定义一个类似热门标签那样的流式布局吧，老规矩，直接上效果图
概述1.流式布局原理：在布局内，随意摆放任意个view,每行所摆放的view个数，根据实施计算出来的宽度

			
		

	





	

		

			

				
					
Android-Android支持拖拽排序的流式标签布局

				
			

			

				

					08-12
				

			

		

		

			
				
Android 支持拖拽排序的流式标签布局 

			
		

	





	

		

			

				
					
Android 设置控件按宽:高=4:3显示

				
			

			

				

					qing_小诺的博客
				

				

					10-17
					
					5802
					
				

			

		

		

			
				
先来见效果图：


如果想向上图展示的那样，实现图片或是控件按照宽高比例进行显示，当然最先想到的是用weight，但是又一想weight只适用于屏幕宽度按比例分配，但是高度要怎么设置呢，所以weight方法不行。
那应该用什么方法呢，能做到宽：高=4:3的比例显示？所以想到了自定义控件：
step1：首先自定义一个名叫LoweImageView的类：
public class Lowe

			
		

	





	

		

			

				
					
android 4行代码解析短信内容（全手动）

				
			

			

				

					maxcion的博客
				

				

					06-22
					
					583
					
				

			

		

		

			
				
android 4行代码解析短信内容（全手动）主要内容如下注册接收短信的广播接收者
获得短信内容
解析短信内容
关于第一点注册广播接收者我想大家应该都了解，我就不多说了，如果没接触过广播接收者话还是建议以后再看这篇文章；第二点 获得短信内容，先贴上官方介绍 
public void onReceive( Context context, Intent intent)官方介绍就是，当设备接受到短信时，

			
		

	





	

		

			

				
					
Android 流式布局

				
			

			

				

					qq_41789379的博客
				

				

					06-18
					
					290
					
				

			

		

		

			
				
       今天我们来看Android的流式布局。 所谓流式布局指的是ViewGroup中同一行的宽度不足以容纳下一个子view时，进行换行处理，而不需要考虑子view的大小，每一行的高度以其中最高者为准。自定义ViewGroup的三种方式：1.通过继承现有的ViewGroup(比如LinearLayout)重写 onMeasure() 来修改已有的 ViewGroup的尺寸,比如你需要一个正方...

			
		

	





	

		

			

				
					
Android流式布局

				
			

			

				

					细心程度决定你的成败
				

				

					06-21
					
					2208
					
				

			

		

		

			
				
概述

大家都知道，java 图形编程有一个布局叫FlowLayout，即流式布局。但Android没有，所以今天教大家写一个Android版的流式布局。

代码

核心代码（FlowLayout.java）如下：




[java] view
 plain copy






package com.example.flowlayout;  
  


			
		

	





	

		

			

				
					
Android流式布局的实现原理

				
			

			

				

					细心程度决定你的成败
				

				

					07-13
					
					4101
					
				

			

		

		

			
				
1.流式布局的特点以及应用场景 
    特点：当上面一行的空间不够容纳新的TextView时候， 
    才开辟下一行的空间　　原理图：　　场景：主要用于关键词搜索或者热门标签等场景
2.自定义ViewGroup,重点重写下面两个方法1、onMeasure:测量子view的宽高，设置自己的宽和高2、onLayout:设置子view的位置onMeasure:根据子view的布局文件中属性，来为子v

			
		

	





	

		

			

				
					
2024年安卓最新Android自定义ViewGroup实战-----流式布局，2024年最新字节跳动面试是什么意思

				
			

			

				

					2401_84544914的博客
				

				

					05-07
					
					320
					
				

			

		

		

			
				
如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。[外链图片转存中…(img-YvDzeKnH-1715016052230)]欢迎大家一起交流讨论啊~网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！

			
		

	





	

		

			

				
					
Android中常见的热门标签的流式布局的实现

					
热门推荐

				
			

			

				

					我生苍茫
				

				

					04-14
					
					1万+
					
				

			

		

		

			
				
一、概述：
在日常的app使用中，我们会在android 的app中看见 热门标签等自动换行的流式布局，今天，我们就来看看如何

自定义一个类似热门标签那样的流式布局吧（源码下载在下面最后给出）

类似的自定义布局。下面我们就来详细介绍流式布局的应用特点以及用的的技术点：

1.流式布局的特点以及应用场景
    特点：当上面一行的空间不够容纳新的TextView时候，
    才开辟下一行的空间

　　原理图：

			
		

	





	

		

			

				
					
自定义Android ViewGroup实现FlowLayout流式布局教程

				
			

			

				

					
				

			

		

		

			
				
本文将深入探讨Android自定义ViewGroup如何实现FlowLayout流式布局，这是一种特殊的布局方式，控件会根据ViewGroup的宽度自动向右排列，当一行空间不足以容纳时，会自动移向下一行，形成类似"流"的效果。尽管Android...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值