广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 移动开发 >android实现简单的矩形裁剪框
  • 312

0
分享到

android实现简单的矩形裁剪框

2024-04-02 19:04:59 312人浏览 薄情痞子
摘要

本文实例为大家分享了Android实现矩形裁剪框的具体代码，供大家参考，具体内容如下 前阵子做视频编辑功能，视频裁剪功能不太好用，就简单的修改了一下 正常模式是这样的 简单的添加了

本文实例为大家分享了Android实现矩形裁剪框的具体代码，供大家参考，具体内容如下

前阵子做视频编辑功能，视频裁剪功能不太好用，就简单的修改了一下

正常模式是这样的

简单的添加了等比例裁剪

贴代码

public class CutView extends View {
    float downX;
    float downY;
    boolean isLeft;
    boolean isRight;
    boolean isTop;
    boolean isBottom;
    boolean isMove;
    boolean isSlideLeft;
    boolean isSlideRight;
    boolean isSlideTop;
    boolean isSlideBottom;
 
    float rectLeft;
    float rectRight;
    float rectTop;
    float rectBottom;
    private int measuredWidth;
    private int measuredHeight;
    private Paint paint;
    private int dp3;
    private int cornerLength;
    private int dp1;
    private float aspect = -1;
 
    public CutView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }
    public CutView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }
    public CutView(Context context) {
        super(context);
        init();
    }
 
    private void init() {
 
        dp3 = (int) getResources().getDimension(R.dimen.dp3);
        dp1 = (int) getResources().getDimension(R.dimen.dp1);
 
        paint = new Paint();
        paint.setAntiAlias(true);
        paint.setColor(Color.WHITE);
        paint.setStyle(Paint.Style.STROKE);
    }
 
 
 
    @Override
    public boolean onTouchEvent(MotionEvent event) {
 
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
 
                downX = event.getX();
                downY = event.getY();
 
                if(downX >= rectLeft && downX <= rectRight && downY >= rectTop && downY <= rectBottom){
                    //判断手指的范围在左面还是右面
                    int w = (int) ((rectRight - rectLeft)/3);
                    if (downX >= rectLeft && downX <= rectLeft+w) {
                        isLeft = true;
                    } else if (downX <= rectRight && downX >= rectRight - w) {
                        isRight = true;
                    }
                    //判断手指的范围在上面还是下面
                    int h = (int) ((rectBottom - rectTop)/3);
                    if (downY >= rectTop && downY <= rectTop+h) {
                        isTop = true;
                    } else if (downY <= rectBottom && downY >= rectBottom - h) {
                        isBottom = true;
                    }
                    //如果手指范围没有在任何边界位置, 那么我们就认为用户是想拖拽框体
                    if (!isLeft && !isTop && !isRight && !isBottom) {
                        isMove = true;
                    }
                }
                break;
            case MotionEvent.ACTION_MOVE:
                float moveX = event.getX();
                float moveY = event.getY();
                //得到手指移动距离
                float slideX = moveX - downX ;
                float slideY = moveY - downY;
 
                if (isMove) {//判断是否是拖拽模式
                    rectLeft += slideX;
                    rectRight += slideX;
                    rectTop += slideY;
                    rectBottom += slideY;
                    //同时改变left和right值, 达到左右移动的效果
                    if (rectLeft < 0 || rectRight > measuredWidth) {//判断x轴的移动边界
                        rectLeft -= slideX;
                        rectRight -= slideX;
                    }
                    //同时改变top和bottom值, 达到上下移动的效果
                    if (rectTop < 0 || rectBottom > measuredHeight ) {//判断y轴的移动边界
                        rectTop -= slideY;
                        rectBottom -= slideY;
                    }
                    //实时触发onDraw()方法
                    invalidate();
                    downX = moveX;
                    downY = moveY;
                } else {
                    if(aspect != -1){
                        if(isLeft && (isTop || isBottom)){
                            if(!isSlideLeft && !isSlideTop && !isSlideBottom){
                                float x = Math.abs(slideX);
                                float y = Math.abs(slideY);
                                if(x > y && x > 10){
                                    isSlideLeft = true;
                                }else if(x < y && y >10){
                                    if(isTop){
                                        isSlideTop = true;
                                    }else{
                                        isSlideBottom = true;
                                    }
                                }
                            }
                        }else if (isRight && (isTop || isBottom)){
                            if(!isSlideRight && !isSlideTop && !isSlideBottom){
                                float x = Math.abs(slideX);
                                float y = Math.abs(slideY);
                                if(x > y && x > 10){
                                    isSlideRight = true;
                                }else if(x < y && y >10){
                                    if(isTop){
                                        isSlideTop = true;
                                    }else{
                                        isSlideBottom = true;
                                    }
                                }
                            }
                        }else if(isLeft && !isSlideLeft){
                            isSlideLeft = true;
                        }else if(isRight && !isSlideLeft){
                            isSlideRight = true;
                        }else if(isTop && !isSlideTop){
                            isSlideTop = true;
                        }else if(isBottom && !isSlideBottom){
                            isSlideBottom = true;
                        }
                        if (isSlideLeft) {
                            rectLeft += slideX;
                            if (rectLeft < 0) rectLeft = 0;
                            float w = rectRight - rectLeft;
                            if(w < cornerLength * 2){
                                w = cornerLength * 2;
                                rectLeft = rectRight - w;
                            }
                            float h = w/aspect;
                            if(h < cornerLength * 2){
                                h = cornerLength * 2;
                                w = h *aspect;
                                rectLeft = rectRight - w;
                            }
                            if(isTop){
                                rectBottom = rectTop + h;
                            }else if(isBottom){
                                rectTop = rectBottom - h;
                            }else{
                                float rh = rectBottom - rectTop;
                                float t = (rh - h)/2;
                                rectTop += t;
                                rectBottom -= t;
                            }
                            if(rectTop < 0){
                                rectTop = 0;
                                rectBottom = h;
                                if(rectBottom > measuredHeight){
                                    rectBottom =  measuredHeight;
                                }
                                w = rectBottom *aspect;
                                rectLeft = rectRight - w;
                            }else if(rectBottom > measuredHeight){
                                rectBottom = measuredHeight;
                                rectTop = measuredHeight - h;
                                if(rectTop < 0){
                                    rectTop = 0;
                                }
                                w = (rectBottom - rectTop) *aspect;
                                rectLeft = rectRight - w;
                            }
                            invalidate();
                            downX = moveX;
                            downY = moveY;
                        } else if (isSlideRight) {
                            rectRight += slideX;
                            if (rectRight > measuredWidth )
                                rectRight = measuredWidth;
                            float w = rectRight - rectLeft;
                            if(w < cornerLength * 2){
                                w = cornerLength * 2;
                                rectRight = rectLeft + w;
                            }
                            float h = w/aspect;
                            if(h < cornerLength * 2){
                                h = cornerLength * 2;
                                w = h *aspect;
                                rectRight = rectLeft + w;
                            }
 
                            if(isTop){
                                rectBottom = rectTop + h;
                            }else if(isBottom){
                                rectTop = rectBottom - h;
                            }else{
                                float rh = rectBottom - rectTop;
                                float t = (rh - h)/2;
                                rectTop += t;
                                rectBottom -= t;
                            }
                            if(rectTop < 0){
                                rectTop = 0;
                                rectBottom = h;
                                if(rectBottom > measuredHeight){
                                    rectBottom =  measuredHeight;
                                }
                                w = rectBottom *aspect;
                                rectRight = rectLeft + w;
                            }else if(rectBottom > measuredHeight){
                                rectBottom = measuredHeight;
                                rectTop = measuredHeight - h;
                                if(rectTop < 0){
                                    rectTop = 0;
                                }
                                w = (rectBottom - rectTop) *aspect;
                                rectRight = rectLeft + w;
                            }
                            invalidate();
                            downX = moveX;
                            downY = moveY;
                        }else if (isSlideTop) {
                            rectTop += slideY;
                            if (rectTop < 0) rectTop = 0;
                            float h = rectBottom - rectTop;
                            if(h < cornerLength * 2){
                                h = cornerLength * 2;
                                rectTop = rectBottom - h;
                            }
                            float w = h*aspect;
                            if(w < cornerLength * 2){
                                w = cornerLength * 2;
                                h = w /aspect;
                                rectTop = rectBottom - h;
                            }
 
                            if(isLeft){
                                rectRight = rectLeft + w;
                            }else if(isRight){
                                rectLeft = rectRight - w;
                            }else{
                                float rw = rectRight - rectLeft;
                                float t = (rw - w)/2;
                                rectLeft += t;
                                rectRight -= t;
                            }
                            if(rectLeft < 0){
                                rectLeft = 0;
                                rectRight = w;
                                if(rectRight > measuredWidth){
                                    rectRight = measuredWidth;
                                }
                                h = rectRight /aspect;
                                rectTop = rectBottom - h;
                            }else if(rectRight > measuredWidth){
                                rectRight = measuredWidth;
                                rectLeft = measuredWidth - w;
                                if(rectLeft < 0){
                                    rectLeft = 0;
                                    w = measuredWidth;
                                }
                                h = w /aspect;
                                rectTop = rectBottom - h;
                            }
                            invalidate();
                            downX = moveX;
                            downY = moveY;
                        } else if (isSlideBottom) {
                            rectBottom += slideY;
                            if (rectBottom > measuredHeight )
                                rectBottom = measuredHeight ;
                            float h = rectBottom - rectTop;
                            if(h < cornerLength * 2){
                                h = cornerLength * 2;
                                rectBottom = rectTop + h;
                            }
                            float w = h*aspect;
                            if(w < cornerLength * 2){
                                w = cornerLength * 2;
                                h = w /aspect;
                                rectBottom = rectTop + h;
                            }
 
                            if(isLeft){
                                rectRight = rectLeft + w;
                            }else if(isRight){
                                rectLeft = rectRight - w;
                            }else{
                                float rw = rectRight - rectLeft;
                                float t = (rw - w)/2;
                                rectLeft += t;
                                rectRight -= t;
                            }
                            if(rectLeft < 0){
                                rectLeft = 0;
                                rectRight = w;
                                if(rectRight > measuredWidth){
                                    rectRight = measuredWidth;
                                }
                                h = rectRight /aspect;
                                rectBottom = rectTop + h;
                            }else if(rectRight > measuredWidth){
                                rectRight = measuredWidth;
                                rectLeft = measuredWidth - w;
                                if(rectLeft < 0){
                                    rectLeft = 0;
                                    w = measuredWidth;
                                }
                                h = w /aspect;
                                rectBottom = rectTop + h;
                            }
                            invalidate();
                            downX = moveX;
                            downY = moveY;
                        }
                    }else{
                        if (isLeft) {
                            rectLeft += slideX;
                            if (rectLeft < 0) rectLeft = 0;
                            if (rectLeft > rectRight - cornerLength * 2)
                                rectLeft = rectRight - cornerLength * 2;
                        } else if (isRight) {
                            rectRight += slideX;
                            if (rectRight > measuredWidth )
                                rectRight = measuredWidth;
                            if (rectRight < rectLeft + cornerLength * 2)
                                rectRight = rectLeft + cornerLength * 2;
                        }
                        //改变边框的高度, 如果两个都满足(比如手指在边角位置),那么就呈现一种缩放状态
                        if (isTop) {
                            rectTop += slideY;
                            if (rectTop < 0) rectTop = 0;
                            if (rectTop > rectBottom - cornerLength * 2)
                                rectTop = rectBottom - cornerLength * 2;
                        } else if (isBottom) {
                            rectBottom += slideY;
                            if (rectBottom > measuredHeight )
                                rectBottom = measuredHeight ;
                            if (rectBottom < rectTop + cornerLength * 2)
                                rectBottom = rectTop + cornerLength * 2;
                        }
                        invalidate();
                        downX = moveX;
                        downY = moveY;
                    }
 
                }
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                isLeft = false;
                isRight = false;
                isTop = false;
                isBottom = false;
                isMove = false;
                isSlideLeft = false;
                isSlideRight = false;
                isSlideTop = false;
                isSlideBottom = false;
                break;
        }
        return true;
    }
 
    
    public float[] getCutArr() {
 
        float[] arr = new float[4];
        arr[0] = rectLeft ;
        arr[1] = rectTop ;
        arr[2] = rectRight ;
        arr[3] = rectBottom ;
        return arr;
    }
 
    public int getRectWidth() {
        return (int) (measuredWidth);
    }
 
    public int getRectHeight() {
        return (int) (measuredHeight);
    }
 
 
    public void setAspect(float aspect){
        this.aspect = aspect;
    }
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
 
        if (measuredWidth == 0) {
            initParams();
        }
    }
 
    private void initParams() {
 
        measuredWidth = getMeasuredWidth();
        measuredHeight = getMeasuredHeight();
 
        if(aspect == -1){
            cornerLength = measuredWidth / 6;
            rectRight = measuredWidth ;
            rectLeft = 0;
            rectTop = 0;
            rectBottom = measuredHeight ;
        }else{
            float vh = measuredWidth*1.0f/measuredHeight;
            if(aspect > 1){
                cornerLength = measuredWidth / 6;
            }else{
                cornerLength = measuredHeight / 6;
            }
            if(aspect > vh){
                rectLeft = 0;
                rectRight = measuredWidth;
                float h = measuredWidth/aspect;
                rectTop = (measuredHeight - h)/2;
                rectBottom = rectTop + h;
            }else{
                rectTop = 0;
                rectBottom = measuredHeight;
                float w = measuredHeight*aspect;
                rectLeft = (measuredWidth - w)/2;
                rectRight = rectLeft + w;
            }
        }
    }
 
    @Override
    protected void onDraw(canvas canvas) {
 
        paint.setStrokeWidth(dp1);
        //绘制裁剪区域的矩形, 传入margin值来确定大小
        canvas.drawRect(rectLeft, rectTop, rectRight, rectBottom, paint);
        //绘制四条分割线和四个角
        drawLine(canvas, rectLeft, rectTop, rectRight, rectBottom);
    }
 
    
    private void drawLine(Canvas canvas, float left, float top, float right, float bottom) {
 
        paint.setStrokeWidth(1);
        //绘制四条分割线
        float startX = (right - left) / 3 + left;
        float startY = top;
        float stopX = (right - left) / 3 + left;
        float stopY = bottom;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        startX = (right - left) / 3 * 2 + left;
        startY = top;
        stopX = (right - left) / 3 * 2 + left;
        stopY = bottom;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        startX = left;
        startY = (bottom - top) / 3 + top;
        stopX = right;
        stopY = (bottom - top) / 3 + top;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        startX = left;
        startY = (bottom - top) / 3 * 2 + top;
        stopX = right;
        stopY = (bottom - top) / 3 * 2 + top;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        paint.setStrokeWidth(dp3);
        //绘制四个角
        startX = left - dp3 / 2;
        startY = top;
        stopX = left + cornerLength;
        stopY = top;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
        startX = left;
        startY = top;
        stopX = left;
        stopY = top + cornerLength;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        startX = right + dp3 / 2;
        startY = top;
        stopX = right - cornerLength;
        stopY = top;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
        startX = right;
        startY = top;
        stopX = right;
        stopY = top + cornerLength;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        startX = left;
        startY = bottom;
        stopX = left;
        stopY = bottom - cornerLength;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
        startX = left - dp3 / 2;
        startY = bottom;
        stopX = left + cornerLength;
        stopY = bottom;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
 
        startX = right + dp3 / 2;
        startY = bottom;
        stopX = right - cornerLength;
        stopY = bottom;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
        startX = right;
        startY = bottom;
        stopX = right;
        stopY = bottom - cornerLength;
        canvas.drawLine(startX, startY, stopX, stopY, paint);
    }
}

使用的时候，只要把这个CutView盖在图片的View上，CutView的宽高必须和图片View的显示宽高一样

我是这样计算的

int screenWidth = mWidthPixels;
int screenHeight = mHeightPixels;
 
int left,top,viewWidth,viewHeight;
float sh = screenWidth*1.0f/screenHeight;
float vh = videoWidth *1.0f/ videoHeight;
if(sh < vh){
    left = 0;
    viewWidth = screenWidth;
    viewHeight = (int)(videoHeight *1.0f/ videoWidth *viewWidth);
    top = (screenHeight - viewHeight)/2;
}else{
    top = 0;
    viewHeight = screenHeight;
    viewWidth = (int)(videoWidth *1.0f/ videoHeight *viewHeight);
    left = (screenWidth - viewWidth)/2;
}
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(viewWidth,viewHeight);
params.leftMargin = left;
params.topMargin = top;
params.bottomMargin = mHeightPixels - top - viewHeight;
videoView.setLayoutParams(params);

设置是否比例画框

cutView.setAspect(-1);

-1表示不用，需要比例显示的话就传入width*1.0f/heigh

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程网。

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: android实现简单的矩形裁剪框

本文链接: https://www.lsjlt.com/news/149084.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • android实现简单的矩形裁剪框
    本文实例为大家分享了android实现矩形裁剪框的具体代码，供大家参考，具体内容如下 前阵子做视频编辑功能，视频裁剪功能不太好用，就简单的修改了一下 正常模式是这样的 简单的添加了...
    99+
    2022-11-13
  • android怎么实现简单的矩形裁剪框
    这篇文章主要介绍“android怎么实现简单的矩形裁剪框”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“android怎么实现简单的矩形裁剪框”文章能帮助大家解决问题。正常模式是这样的简单的添加了等比...
    99+
    2023-06-30
  • Android自定义View实现照片裁剪框与照片裁剪功能
    本文所需要实现的就是这样一种有逼格的效果： 右上角加了个图片框，按下确定可以裁剪正方形区域里的图片并显示在右上角。 实现思路： 1：首先需要自定义一个ZoomImageVie...
    99+
    2022-06-06
    view Android
  • Vue实现简单基础的图片裁剪功能
    目录一、准备工作二、基本结构三、添加功能onMouseDownonMouseMoveonMouseUponMouseLeave四、总结近日，在写公司项目的时候接到一个需求：对已加载的...
    99+
    2022-11-13
  • Android裁剪图片为圆形图片的实现原理与代码
    以前在eoe论坛中找过裁剪图片为圆形图片的方法，但是效果都不是很理想，这几天因为公司业务的要求，需要对头像进行裁剪以圆形的方式显示，这个方法是根据传入的图片的高度（height...
    99+
    2022-06-06
    图片 Android
  • android实现图片裁剪的两种方法
    两种android图片裁剪方式，供大家参考，具体内容如下 一、相机拍完照之后利用系统自带裁剪工具进行截取 public static void cropImage(Activit...
    99+
    2022-11-12
  • android编程实现系统图片剪裁的方法
    本文实例讲述了android编程实现系统图片剪裁的方法。分享给大家供大家参考，具体如下： package cn.test; import java.io.File; impo...
    99+
    2022-06-06
    方法 图片 系统 Android
  • Android编程实现图片拍照剪裁的方法
    本文实例讲述了Android实现图片拍照剪裁的方法。分享给大家供大家参考，具体如下： 调用系统的裁剪工具对相册或者拍照的图片进行裁剪。 startActivityforResu...
    99+
    2022-06-06
    方法 图片 Android
  • CSS3实现缺角矩形、折角矩形以及缺角边框的案例
    这篇文章将为大家详细讲解有关CSS3实现缺角矩形、折角矩形以及缺角边框的案例，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。效果图：缺角  1. 伪元素实现<div class=&...
    99+
    2023-06-08
  • Android实现圆角矩形和圆形ImageView的方式
    Android中实现圆角矩形和圆形有很多种方式，其中最常见的方法有ImageLoader设置Option和自定义View。 1.ImageLoader加载图片 publi...
    99+
    2022-06-06
    Android
  • C++矩阵运算的实现简单
    利用C++实现矩阵的构造，通过运算符的重载实现矩阵的乘法、加法等。并且实现矩阵形状的打印，矩阵的打印。 #include<iostream> #include<...
    99+
    2022-11-12
  • Android自定义ViewGroup实现带箭头的圆角矩形菜单
    本文和大家一起做一个带箭头的圆角矩形菜单，大概长下面这个样子：  要求顶上的箭头要对准菜单锚点，菜单项按压反色，菜单背景色和按压色可配置。 最简单的做法就是让U...
    99+
    2022-06-06
    菜单 Android
  • android实现圆角矩形背景的方法
    本文实例讲述了android实现圆角矩形背景的方法。分享给大家供大家参考。具体如下： 1. java代码如下： import android.graphics.Canvas;...
    99+
    2022-06-06
    方法 Android
  • Android自定义对话框的简单实现
    本文实例为大家分享了Android自定义对话框的具体实现代码，供大家参考，具体内容如下 1、定义对话框的布局 <xml version="1.0" encoding="utf-...
    99+
    2022-11-13
  • thinkphp框架中的图片旋转裁剪功能怎么实现
    这篇文章主要讲解了“thinkphp框架中的图片旋转裁剪功能怎么实现”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“thinkphp框架中的图片旋转裁剪功能怎么实现”吧！第一步：安装think...
    99+
    2023-07-06
  • Numpy创建NumPy矩阵的简单实现
    目录创建NumPy矩阵1. 创建矩阵2. 创建分块矩阵3. 矩阵计算4. 矩阵属性创建NumPy矩阵 NumPy对于多维数组的运算，默认情况下并不进行矩阵运算。如果需要对数组进行矩阵...
    99+
    2023-02-10
    Numpy创建NumPy矩阵 Numpy创建矩阵
  • css3如何实现带边框的缺角矩形
    这篇文章主要为大家展示了“css3如何实现带边框的缺角矩形”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“css3如何实现带边框的缺角矩形”这篇文章吧。 ...
    99+
    2022-10-19
  • Android简单实现自定义弹框（PopupWindow）
    一：一般都是先上效果图 二：实现步骤： 1.xml布局实现 <?xml version="1.0" encoding="utf-8"?> &...
    99+
    2022-06-06
    自定义 popupwindow Android
  • Android自定义对话框Dialog的简单实现
    本文着重研究了自定义对话框，通过一下步骤即可清晰的理解原理，通过更改界面设置和style类型，可以应用在各种各样适合自己的App中。首先来看一下效果图：首先是activity的界面点击了上述图片的按钮后，弹出对话框：点击对话框的确定按钮：点...
    99+
    2023-05-30
    android 对话框 dialog
  • Android自定义View实现简单的圆形Progress效果
    先给大家展示下效果图，如果感觉不错，请参考实现思路： 我们要实现一个自定义的再一个圆形中绘制一个弧形的自定义View，思路是这样的： 　　先要创建一个类ProgressVie...
    99+
    2022-06-06
    view progress Android
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作