椛丿未眠

安卓开发（四）收藏的轮子——图片相关

Tue, 22 Mar 2022 00:00:00 +0000

@[toc]

界面布局

沉浸式标题栏

一个可以使得屏幕铺满顶部状态栏的方法：

    /**
     * 通过设置全屏，设置状态栏透明
     *
     * @param activity
     */
    public static void fullScreen(Activity activity) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                //5.x开始需要把颜色设置透明，否则导航栏会呈现系统默认的浅灰色
                Window window = activity.getWindow();
                View decorView = window.getDecorView();
                //两个 flag 要结合使用，表示让应用的主体内容占用系统状态栏的空间
                int option = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
                decorView.setSystemUiVisibility(option);
                window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
                window.setStatusBarColor(Color.TRANSPARENT);
                //导航栏颜色也可以正常设置
//                window.setNavigationBarColor(Color.TRANSPARENT);
            } else {
                Window window = activity.getWindow();
                WindowManager.LayoutParams attributes = window.getAttributes();
                int flagTranslucentStatus = WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;
                int flagTranslucentNavigation = WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;
                attributes.flags |= flagTranslucentStatus;
//                attributes.flags |= flagTranslucentNavigation;
                window.setAttributes(attributes);
            }
        }
    }

在manifest中指定app的主题style：

style中的下边两个属性分别表示标题栏背景色和状态栏背景色，两者设为一致既可实现沉浸式效果，铺满全屏。

走马灯轮播图

引入依赖：implementation 'com.youth.banner:banner:1.4.10' xml：

                <com.youth.banner.Banner
                    android:layout_marginLeft="@dimen/dp_10"
                    android:layout_marginRight="@dimen/dp_10"
                    android:layout_marginTop="@dimen/dp_10" 
                    android:id="@+id/banner"
                    android:layout_width="match_parent"
                    android:layout_height="150dp" >

activity中，先获取到banner组件对象，然后初始化：主要是构建imgePath列表和标题列表，然后banner.setImages设置图片，banner.setTittles设置标题。加载具体的实现是通过加载器Myloader，通过glide加载图片到imageview中。然后可以重写OnBannerClick，设置轮播图点击反馈事件。

    private void initBanner() {
        List<User> friends = application.getFriendList();
        //放图片地址的集合
        list_path = new ArrayList<>();
        //放标题的集合
        list_title = new ArrayList<>();
        if (friends!=null) {
            for (int i = 0; i < friends.size(); i++) {
                list_path.add(friends.get(i).getAvatar());
                list_title.add(friends.get(i).getFullName());
            }
        }
        list_title.add("更多");
        list_path.add("https://img-blog.csdnimg.cn/9a6ae33e401543589b3f953a87166746.png");
        //设置内置样式，共有六种可以点入方法内逐一体验使用。
        banner.setBannerStyle(BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE);
        //设置图片加载器，图片加载器在下方
        banner.setImageLoader(new MyLoader());
        //设置图片网址或地址的集合
        banner.setImages(list_path);
        //设置轮播的动画效果，内含多种特效，可点入方法内查找后内逐一体验
        banner.setBannerAnimation(Transformer.Default);
        //设置轮播图的标题集合
        banner.setBannerTitles(list_title);
        //设置轮播间隔时间
        banner.setDelayTime(3000);
        //设置是否为自动轮播，默认是“是”。
        banner.isAutoPlay(true);
        //设置指示器的位置，小点点，左中右。
        banner.setIndicatorGravity(BannerConfig.CENTER)
                //以上内容都可写成链式布局，这是轮播图的监听。比较重要。方法在下面。
                .setOnBannerListener(this)
                //必须最后调用的方法，启动轮播图。
                .start();
    }

    //自定义的图片加载器
    private class MyLoader extends ImageLoader {
        @Override
        public void displayImage(Context context, Object path, ImageView imageView) {
            Glide.with(context).load((String) path).into(imageView);
        }
    }

    @Override
    public void OnBannerClick(int position) {
        Log.i("tag", "你点了第"+position+"张轮播图");
    }

图标、图片处理、头像相关

下载图标一些依赖：

    implementation 'com.github.bumptech.glide:glide:4.11.0' // 图片加载
    implementation 'com.github.chrisbanes:PhotoView:2.3.0'    // 大图图片显示，拖拉放大
    implementation 'top.zibin:Luban:1.1.8'  // 图片压缩类
    implementation 'com.github.Othershe:CombineBitmap:1.0.5' //bitmap合成，仿微信群头像
    implementation 'com.githang:clipimageview:0.1' // 头像剪裁
    implementation 'cjt.library.wheel:camera:1.1.9' // 调用相机拍照和录制视频

ImageUtils

包含在Bitmap中绘制文字水印；从网络上下载图片Bitmap保存；取出视频的第一帧转为Bitmap构建视频缩略图；旋转Bitmap指定angle；Glide加载头像的封装；view转bitmap显示自定义图标。

package com.beidouapp.model.utils;

import android.app.Activity;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Toast;

import androidx.annotation.NonNull;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.beidouapp.Config;
import com.beidouapp.R;
import com.beidouapp.ui.DemoApplication;
import com.beidouapp.ui.Setting.ActivityUser;
import com.beidouapp.ui.Setting.ClipAvatar;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutionException;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;
import okhttp3.Response;
import wseemann.media.FFmpegMediaMetadataRetriever;

public class ImageUtil {
    /**
     * 设置水印图片在左上角
     *
     * @param context     上下文
     * @param src
     * @param watermark
     * @param paddingLeft
     * @param paddingTop
     * @return
     */
    public static Bitmap createWaterMaskLeftTop(Context context, Bitmap src, Bitmap watermark, int paddingLeft, int paddingTop) {
        return createWaterMaskBitmap(src, watermark,
                dp2px(context, paddingLeft), dp2px(context, paddingTop));
    }

    private static Bitmap createWaterMaskBitmap(Bitmap src, Bitmap watermark, int paddingLeft, int paddingTop) {
        if (src == null) {
            return null;
        }
        int width = src.getWidth();
        int height = src.getHeight();
        //创建一个bitmap
        Bitmap newb = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);// 创建一个新的和SRC长度宽度一样的位图
        //将该图片作为画布
        Canvas canvas = new Canvas(newb);
        //在画布 0，0坐标上开始绘制原始图片
        canvas.drawBitmap(src, 0, 0, null);
        //在画布上绘制水印图片
        canvas.drawBitmap(watermark, paddingLeft, paddingTop, null);
        // 保存
        canvas.save();
        // 存储
        canvas.restore();
        return newb;
    }

    /**
     * 设置水印图片在右下角
     *
     * @param context       上下文
     * @param src
     * @param watermark
     * @param paddingRight
     * @param paddingBottom
     * @return
     */
    public static Bitmap createWaterMaskRightBottom(Context context, Bitmap src, Bitmap watermark, int paddingRight, int paddingBottom) {
        return createWaterMaskBitmap(src, watermark,
                src.getWidth() - watermark.getWidth() - dp2px(context, paddingRight),
                src.getHeight() - watermark.getHeight() - dp2px(context, paddingBottom));
    }

    /**
     * 设置水印图片到右上角
     *
     * @param context
     * @param src
     * @param watermark
     * @param paddingRight
     * @param paddingTop
     * @return
     */
    public static Bitmap createWaterMaskRightTop(Context context, Bitmap src, Bitmap watermark, int paddingRight, int paddingTop) {
        return createWaterMaskBitmap(src, watermark,
                src.getWidth() - watermark.getWidth() - dp2px(context, paddingRight),
                dp2px(context, paddingTop));
    }

    /**
     * 设置水印图片到左下角
     *
     * @param context
     * @param src
     * @param watermark
     * @param paddingLeft
     * @param paddingBottom
     * @return
     */
    public static Bitmap createWaterMaskLeftBottom(Context context, Bitmap src, Bitmap watermark, int paddingLeft, int paddingBottom) {
        return createWaterMaskBitmap(src, watermark, dp2px(context, paddingLeft),
                src.getHeight() - watermark.getHeight() - dp2px(context, paddingBottom));
    }

    /**
     * 设置水印图片到中间
     *
     * @param src
     * @param watermark
     * @return
     */
    public static Bitmap createWaterMaskCenter(Bitmap src, Bitmap watermark) {
        return createWaterMaskBitmap(src, watermark,
                (src.getWidth() - watermark.getWidth()) / 2,
                (src.getHeight() - watermark.getHeight()) / 2);
    }

    /**
     * 给图片添加文字到左上角
     *
     * @param context
     * @param bitmap
     * @param text
     * @return
     */
    public static Bitmap drawTextToLeftTop(Context context, Bitmap bitmap, String text, int size, int color, int paddingLeft, int paddingTop) {
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(color);
        paint.setTextSize(dp2px(context, size));
        Rect bounds = new Rect();
        paint.getTextBounds(text, 0, text.length(), bounds);
        return drawTextToBitmap(bitmap, text, paint, bounds,
                dp2px(context, paddingLeft),
                dp2px(context, paddingTop) + bounds.height());
    }

    /**
     * 绘制文字到右下角
     *
     * @param context
     * @param bitmap
     * @param text
     * @param size
     * @param color
     * @return
     */
    public static Bitmap drawTextToRightBottom(Context context, Bitmap bitmap, String text, int size, int color, int paddingRight, int paddingBottom) {
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(color);
        paint.setTextSize(dp2px(context, size));
        Rect bounds = new Rect();
        paint.getTextBounds(text, 0, text.length(), bounds);
        return drawTextToBitmap(bitmap, text, paint, bounds,
                bitmap.getWidth() - bounds.width() - dp2px(context, paddingRight),
                bitmap.getHeight() - dp2px(context, paddingBottom));
    }

    /**
     * 绘制文字到右上方
     *
     * @param context
     * @param bitmap
     * @param text
     * @param size
     * @param color
     * @param paddingRight
     * @param paddingTop
     * @return
     */
    public static Bitmap drawTextToRightTop(Context context, Bitmap bitmap, String text, int size, int color, int paddingRight, int paddingTop) {
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(color);
        paint.setTextSize(dp2px(context, size));
        Rect bounds = new Rect();
        paint.getTextBounds(text, 0, text.length(), bounds);
        return drawTextToBitmap(bitmap, text, paint, bounds,
                bitmap.getWidth() - bounds.width() - dp2px(context, paddingRight),
                dp2px(context, paddingTop) + bounds.height());
    }

    /**
     * 绘制文字到左下方
     *
     * @param context
     * @param bitmap
     * @param text
     * @param size
     * @param color
     * @param paddingLeft
     * @param paddingBottom
     * @return
     */
    public static Bitmap drawTextToLeftBottom(Context context, Bitmap bitmap, String text, int size, int color, int paddingLeft, int paddingBottom) {
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(color);
        paint.setTextSize(dp2px(context, size));
        Rect bounds = new Rect();
        paint.getTextBounds(text, 0, text.length(), bounds);
        return drawTextToBitmap(bitmap, text, paint, bounds,
                dp2px(context, paddingLeft),
                bitmap.getHeight() - dp2px(context, paddingBottom));
    }

    /**
     * 绘制文字到中间
     *
     * @param context
     * @param bitmap
     * @param text
     * @param size
     * @param color
     * @return
     */
    public static Bitmap drawTextToCenter(Context context, Bitmap bitmap, String text, int size, int color) {
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(color);
        paint.setTextSize(dp2px(context, size));
        Rect bounds = new Rect();
        paint.getTextBounds(text, 0, text.length(), bounds);
        return drawTextToBitmap(bitmap, text, paint, bounds,
                (bitmap.getWidth() - bounds.width()) / 2,
                (bitmap.getHeight() + bounds.height()) / 2);
    }

    //图片上绘制文字
    private static Bitmap drawTextToBitmap(Bitmap bitmap, String text, Paint paint, Rect bounds, int paddingLeft, int paddingTop) {
        android.graphics.Bitmap.Config bitmapConfig = bitmap.getConfig();

        paint.setDither(true); // 获取跟清晰的图像采样
        paint.setFilterBitmap(true);// 过滤一些
        if (bitmapConfig == null) {
            bitmapConfig = android.graphics.Bitmap.Config.ARGB_8888;
        }
        bitmap = bitmap.copy(bitmapConfig, true);
        Canvas canvas = new Canvas(bitmap);

        canvas.drawText(text, paddingLeft, paddingTop, paint);
        return bitmap;
    }

    /**
     * 缩放图片
     *
     * @param src
     * @param w
     * @param h
     * @return
     */
    public static Bitmap scaleWithWH(Bitmap src, double w, double h) {
        if (w == 0 || h == 0 || src == null) {
            return src;
        } else {
            // 记录src的宽高
            int width = src.getWidth();
            int height = src.getHeight();
            // 创建一个matrix容器
            Matrix matrix = new Matrix();
            // 计算缩放比例
            float scaleWidth = (float) (w / width);
            float scaleHeight = (float) (h / height);
            // 开始缩放
            matrix.postScale(scaleWidth, scaleHeight);
            // 创建缩放后的图片
            return Bitmap.createBitmap(src, 0, 0, width, height, matrix, true);
        }
    }

    /**
     * dip转pix
     *
     * @param context
     * @param dp
     * @return
     */
    public static int dp2px(Context context, float dp) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dp * scale + 0.5f);
    }

    public static Bitmap getDefaultBitmap(String nickname ,int size,Context context ){
        Bitmap base = BitmapFactory.decodeResource(context.getResources(),R.drawable.avatar_default);
        String text;
        if (nickname!=null && nickname.length() > 0){
            if (nickname.length() >1){
                // 如果昵称有一个字以上，取最后两位
                text = nickname.substring(nickname.length()-2);
            }else {
                // 一个字就是本身
                text = nickname;
            }
            Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
            paint.setColor(Color.WHITE);
            paint.setTextSize(dp2px(context, size));
            Rect bounds = new Rect();
            paint.getTextBounds(text, 0, text.length(), bounds);
            return drawTextToBitmap(base,text,paint,bounds,(base.getWidth() - bounds.width()) / 2,
                    (base.getHeight() + bounds.height()) / 2);
        }else {
            return base;
        }
    }



    /**
     * 保存位图到本地
     * @param bitmap
     * @param name 图片名
     * @return 图片文件
     */
    public static File  SavaImage(Bitmap bitmap,String name){
        String path = Config.PHOTO_SAVE_DIR;
        File file=new File(path);
        FileOutputStream fileOutputStream=null;
        //文件夹不存在，则创建它
        if(!file.exists()){
            file.mkdir();
        }
        String localAvatar = path+"/"+ name +".png";
        try {
            fileOutputStream=new FileOutputStream(localAvatar);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100,fileOutputStream);
            fileOutputStream.close();
            Log.d("下载头像", "SavaImage: 保存图片，地址为" + localAvatar);
            return new File(localAvatar);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 判断文件是否为图片文件(GIF,PNG,JPG),且可用
     * @param srcFilePath
     * @return
     */
    public static boolean isImage(File srcFilePath) {
        FileInputStream imgFile = null;
        byte[] b = new byte[10];
        int l = -1;
        try {
            imgFile = new FileInputStream(srcFilePath);
            l = imgFile.read(b);
            imgFile.close();
        } catch (Exception e) {
            return false;
        }
        Bitmap bitmap = BitmapFactory.decodeFile(srcFilePath.getAbsolutePath());
        try{
            bitmap.getWidth();
        }catch(Exception e) {
            return false;
        }

        if (l == 10) {
            byte b0 = b[0];
            byte b1 = b[1];
            byte b2 = b[2];
            byte b3 = b[3];
            byte b6 = b[6];
            byte b7 = b[7];
            byte b8 = b[8];
            byte b9 = b[9];

            if (b0 == (byte) 'G' && b1 == (byte) 'I' && b2 == (byte) 'F') {
                return true;
            } else if (b1 == (byte) 'P' && b2 == (byte) 'N' && b3 == (byte) 'G') {
                return true;
            } else if (b6 == (byte) 'J' && b7 == (byte) 'F' && b8 == (byte) 'I'&& b9 == (byte) 'F') {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    /**
     * 检查图片是否损坏
     *
     * @param filePath
     * @return
     */
    public static boolean checkImgDamage(String filePath) {
        BitmapFactory.Options options = null;
        if (options == null) {
            options = new BitmapFactory.Options();
        }
        options.inJustDecodeBounds = true;

        BitmapFactory.decodeFile(filePath, options);
        if (options.mCancel || options.outWidth == -1
                || options.outHeight == -1) {
            return true;
        }
        return false;
    }

    /**
     * 复制文件
     *
     * @param source 输入文件
     * @param target 输出文件
     */
    public static void copy(File source, File target) {
        Log.d("glide加载", "copy: 复制图片到指定路径");
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(source);
            fileOutputStream = new FileOutputStream(target);
            byte[] buffer = new byte[1024];
            while (fileInputStream.read(buffer) > 0) {
                fileOutputStream.write(buffer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 异步生成默认头像上传至服务器
     */


    public static void drawDefaultAvatar(DemoApplication application, Context context, String token, String username, String fullName){
        if (fullName!=null){
            Observable.just(fullName).map(new Function<String, Bitmap>() {
                @Override
                public Bitmap apply(@NonNull String s) throws Exception {
                    try {
                        return getDefaultBitmap(fullName,200,context);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return null;
                }
            }).subscribeOn(Schedulers.io())
                    .map(new Function<Bitmap, File>() {
                        @Override
                        public File apply(@NonNull Bitmap bitmap) throws Exception {
                            try {
                                return SavaImage(bitmap,username);
                            }catch (Exception e){
                                e.printStackTrace();
                            }

                            return null;
                        }
                    }).subscribeOn(Schedulers.io())
                    .subscribe(new Observer<File>() {
                        @Override
                        public void onSubscribe(@NonNull Disposable d) {

                        }

                        @Override
                        public void onNext(@NonNull File file) {
                            String url = Config.getUrl("/system/user/profile/avatar");
                            OkHttpUtils.getInstance(context).uploadAvatar(url,file, token, new OkHttpUtils.MyCallback() {
                                @Override
                                public void success(Response response) throws IOException {
                                    JSONObject object = JSON.parseObject(response.body().string());
                                    int code = object.getInteger("code");
                                    if(code == 200){
                                        String imgUrl = object.getString("imgUrl");
                                        Log.d("默认头像", "success: 默认头像上传成功");
                                        application.setAvatar(Config.getUrl(imgUrl));
                                    }
                                }
                                @Override
                                public void failed(IOException e) {
                                    e.printStackTrace();
                                }
                            });
                        }

                        @Override
                        public void onError(@NonNull Throwable e) {

                        }

                        @Override
                        public void onComplete() {
                            Log.d("默认头像", "onComplete: 生成默认头像成功");
                        }
                    });
        }
    }



    /**?
     * 异步补充下载本地缺失头像，execute传递两个参数，第一个为手机号username决定头像文件名，
     * 第二个为头像的服务器地址，avatar
     */
    public static class downloadAvatar extends AsyncTask<String,Integer,File>{
        @Override
        protected File doInBackground(String... strings) {
            String username = strings[0];
            String avatar = strings[1];
            Observable.just(avatar).map(new Function<String, Bitmap>() {
                @Override
                public Bitmap apply(@NonNull String s) throws Exception {
                    try {
                        URL url = new URL(avatar);
                        HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                        httpURLConnection.setConnectTimeout(5000);
                        int code = httpURLConnection.getResponseCode();
                        if (code == HttpURLConnection.HTTP_OK) {
                            InputStream inputStream = httpURLConnection.getInputStream();
                            Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                            return bitmap;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    return null;
                }
            }).subscribeOn(Schedulers.io())
                    .map(new Function<Bitmap, File>() {
                        @Override
                        public File apply(@NonNull Bitmap bitmap) throws Exception {
                            String path = Config.PHOTO_SAVE_DIR;
                            File file = new File(path);
                            FileOutputStream fileOutputStream = null;
                            //文件夹不存在，则创建它
                            if (!file.exists()) {
                                file.mkdir();
                            }
                            String localAvatar = path + "/" + username + ".png";
                            File oldFile = new File(localAvatar);
                            if (oldFile.isFile() && oldFile.exists()) {
                                oldFile.delete();
                            }
                            try {
                                fileOutputStream = new FileOutputStream(localAvatar);
                                bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
                                fileOutputStream.close();
                                Log.d("下载头像", "SavaImage: 保存图片，地址为" + localAvatar);
                                return new File(localAvatar);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            return null;
                        }
                    }).subscribeOn(Schedulers.io())
                    .subscribe(new Observer<File>() {
                        @Override
                        public void onSubscribe(@NonNull Disposable d) {

                        }

                        @Override
                        public void onNext(@NonNull File file) {
                            System.out.println("头像下载路径"+file.getAbsolutePath()+"----头像大小"+file.length());
                        }

                        @Override
                        public void onError(@NonNull Throwable e) {

                        }

                        @Override
                        public void onComplete() {

                        }
                    });
            return null;
        }
    }

    public static InputStream getInputStream(FileInputStream fileInput) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024*4];
        int n = -1;
        InputStream inputStream = null;
        try {
            while ((n=fileInput.read(buffer)) != -1) {
                baos.write(buffer, 0, n);

            }
            byte[] byteArray = baos.toByteArray();
            inputStream = new ByteArrayInputStream(byteArray);
            return inputStream;


        } catch (FileNotFoundException e) {

            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }
            }
        }
    }

    public static byte[] getBitmapByte(String filepath){
        Bitmap bitmap = BitmapFactory.decodeFile(filepath);
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream);
        return byteArrayOutputStream.toByteArray();
    }

    public static void loadAvatar(Context context, String id, ImageView view) {
        File localAvatar = new File(Config.getAvatarPath((id)));
        if (localAvatar.exists() && isImage(localAvatar)) {
            Log.d("聊天界面头像", "onResume: 如果本地有图片加载本地");
            Glide.with(context)
                    .load(localAvatar)
                    .diskCacheStrategy(DiskCacheStrategy.NONE)
                    .skipMemoryCache(true)
                    .centerCrop()
                    .placeholder(R.mipmap.default_header)
                    .into(view);
        } else {
            Log.d("聊天界面头像", "onResume: 如果本地没有图片加载服务器");
            Glide.with(context)
                    .load(view)
                    .centerCrop()
                    .thumbnail(0.1f)
                    .placeholder(R.mipmap.default_header)
                    .error(R.mipmap.default_header) // will be displayed if the image cannot be loaded
                    .into(view);
        }
    }


    /**
     * 加载头像
     * @param context 上下文
     * @param id 目标id
     * @param url 目标网络头像地址
     * @param view 目标ImageView
     */
    public static void loadAvatar(Context context, String id, String url,ImageView view) {
        File localAvatar = new File(Config.getAvatarPath((id)));
        if (localAvatar.exists() && isImage(localAvatar)) {
            Log.d("聊天界面头像", "onResume: 如果本地有图片加载本地");
            Glide.with(context)
                    .load(localAvatar)
                    .diskCacheStrategy(DiskCacheStrategy.NONE)
                    .skipMemoryCache(true)
                    .centerCrop()
                    .into(view);
        } else {
            Log.d("聊天界面头像", "onResume: 如果本地没有图片加载服务器");
            Glide.with(context)
                    .load(url)
                    .centerCrop()
                    .thumbnail(0.1f)
                    .error(R.mipmap.default_header) // will be displayed if the image cannot be loaded
                    .into(view);
            if(url!=null){
                downloadAvatar task = new downloadAvatar();
                task.execute(id, url);
            }
        }
    }

    public static Bitmap getAvatar(Context context, String id, String url) throws ExecutionException, InterruptedException {
        File localAvatar = new File(Config.getAvatarPath((id)));
        Bitmap bitmap;
        if (localAvatar.exists() && isImage(localAvatar)) {
            Log.d("聊天界面头像", "onResume: 如果本地有图片加载本地");
            bitmap = Glide.with(context)
                    .asBitmap()
                    .load(localAvatar)
                    .diskCacheStrategy(DiskCacheStrategy.NONE)
                    .skipMemoryCache(true)
                    .centerCrop()
                    .into(100,100)
                    .get();
        } else {
            Log.d("聊天界面头像", "onResume: 如果本地没有图片加载服务器");
            bitmap = Glide.with(context)
                    .asBitmap()
                    .load(url)
                    .centerCrop()
                    .thumbnail(0.1f)
                    .error(R.mipmap.default_header) // will be displayed if the image cannot be loaded
                    .into(100,100)
                    .get();
            if(url!=null){
                downloadAvatar task = new downloadAvatar();
                task.execute(id, url);
            }
        }
        return bitmap;
    }

    public static Bitmap getVideoImg(Context context, Bitmap baseBitmap) {
        Bitmap startBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.start_new);
        Bitmap bitmap = null;

        bitmap = Bitmap.createBitmap(baseBitmap);
        Canvas canvas = new Canvas(bitmap);
        Paint paint = new Paint();
        int w1 = baseBitmap.getWidth();
        int h1 = baseBitmap.getHeight();

        int w2 = startBitmap.getWidth();
        int h2 = startBitmap.getHeight();

        paint.setColor(Color.GRAY);
        paint.setAlpha(125);

        canvas.drawRect(0,0, w1, h1, paint);

        paint = new Paint();

        canvas.drawBitmap(startBitmap, Math.abs((w1 - w2)/2), Math.abs((h1 - h2)/2), paint);
        canvas.save();
        canvas.restore();

        return  bitmap;
    }

    public static Bitmap getVideoFrame(String path){
        FFmpegMediaMetadataRetriever retriever = new  FFmpegMediaMetadataRetriever();
        try {
//                        retriever.setDataSource("/storage/emulated/0/test.mp4"); //file's path
            retriever.setDataSource(path); //file's path
            Bitmap bitmap = retriever.getFrameAtTime(100000,FFmpegMediaMetadataRetriever.OPTION_CLOSEST_SYNC );  //这个时间就是第一秒的
            return bitmap;
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally{
            retriever.release();
        }
        return null;
    }

    public static Bitmap adjustPhotoRotation(Bitmap bm, final int orientationDegree) {
        Matrix m = new Matrix();
        m.setRotate(orientationDegree, (float) bm.getWidth() / 2, (float) bm.getHeight() / 2);
        try {
            Bitmap bm1 = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), m, true);
            return bm1;
        } catch (OutOfMemoryError ex) {
        }
        return null;
    }

    /**
     * 通过设置全屏，设置状态栏透明
     *
     * @param activity
     */
    public static void fullScreen(Activity activity) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                //5.x开始需要把颜色设置透明，否则导航栏会呈现系统默认的浅灰色
                Window window = activity.getWindow();
                View decorView = window.getDecorView();
                //两个 flag 要结合使用，表示让应用的主体内容占用系统状态栏的空间
                int option = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
                decorView.setSystemUiVisibility(option);
                window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
                window.setStatusBarColor(Color.TRANSPARENT);
                //导航栏颜色也可以正常设置
//                window.setNavigationBarColor(Color.TRANSPARENT);
            } else {
                Window window = activity.getWindow();
                WindowManager.LayoutParams attributes = window.getAttributes();
                int flagTranslucentStatus = WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;
                int flagTranslucentNavigation = WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;
                attributes.flags |= flagTranslucentStatus;
//                attributes.flags |= flagTranslucentNavigation;
                window.setAttributes(attributes);
            }
        }
    }

    /**
     * 将View转换成Bitmap
     * @param addViewContent
     * @return
     */

    public static Bitmap getViewBitmap(View addViewContent) {

        addViewContent.setDrawingCacheEnabled(true);

        addViewContent.measure(
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED));
        addViewContent.layout(0, 0,
                addViewContent.getMeasuredWidth(),
                addViewContent.getMeasuredHeight());

        addViewContent.buildDrawingCache();
        Bitmap cacheBitmap = addViewContent.getDrawingCache();
        Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);

        return bitmap;
    }
}

图片压缩鲁班压缩

                Luban.with(ClipAvatar.this)
                        .load(file)                                   // 传人要压缩的图片列表
                        .ignoreBy(100)                                  // 忽略不压缩图片的大小
                        .setTargetDir(Config.PHOTO_SAVE_DIR)                        // 设置压缩后文件存储位置
                        .setCompressListener(new OnCompressListener() { //设置回调
                            @Override
                            public void onStart() {

                                Log.d(TAG, "onStart: 压缩前图片大小："+file.length());
                            }

                            @Override
                            public void onSuccess(File file) {

                                File compressAvatar = file;
                                Log.d(TAG, "onSuccess: 压缩成功后图片大小"+compressAvatar.length());
                                String url = Config.getUrl("/system/user/profile/avatar");
                                OkHttpUtils.getInstance(ClipAvatar.this).uploadAvatar(url,compressAvatar,
                                        application.getToken(), new OkHttpUtils.MyCallback() {
                                            @Override
                                            public void success(Response response) throws IOException {
                                                JSONObject object = JSON.parseObject(response.body().string());
                                                int code = object.getInteger("code");
                                                String msg = object.getString("msg");
                                                ClipAvatar.this.runOnUiThread(() -> Toast.makeText(ClipAvatar.this,msg,Toast.LENGTH_LONG).show());
                                                if(code == 200){
                                                    String imgUrl = object.getString("imgUrl");
                                                    //服务器返回地址类型： "imgUrl": "/profile/avatar/2022/03/08/3cd6f0f2-8a77-43e2-b105-401ef0e7f123.jpg",
                                                    //路径补全
                                                    String avatar = "http://" + Config.BeiDou_SERVER_HOST + ":" + Config.BeiDou_SERVER_PORT + imgUrl;
                                                    application.setAvatar(avatar);
                                                    File savaAvatar = new File(Config.getAvatarPath(application.getUserID()));
                                                    copy(compressAvatar,savaAvatar);
                                                }
                                            }
                                            @Override
                                            public void failed(IOException e) {
                                                e.printStackTrace();
                                            }
                                        });
                            }

                            @Override
                            public void onError(Throwable e) {

                                Log.d(TAG, "onError: 压缩失败");
                            }
                        }).launch();    //启动压缩

头像裁剪

    <com.githang.clipimage.ClipImageView
        android:id="@+id/clip_image_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginTop="?attr/actionBarSize"
        app:civHeight="3"
        app:civMaskColor="#CC000000"
        app:civClipPadding="30dp"
        app:civWidth="3" />

ClipImageLayout相当于一个图片裁剪的容器，在裁剪完毕后可以使用.clip()方法，即可获取到裁剪后的Bitmap图片。

        mClipImageLayout = (ClipImageView) findViewById(R.id.clip_image_view);
        Intent intent = getIntent();
        String imagePath = intent.getStringExtra("imagePath");
        bitmap = BitmapFactory.decodeFile(imagePath);
        mClipImageLayout.setImageBitmap(bitmap);

ClippedBitmap = mClipImageLayout.clip();

拍照录制视频

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.cjt2325.cameralibrary.JCameraView
        android:id="@+id/cameraView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:iconMargin="20dp"
        app:iconSize="30dp"
        app:iconSrc="@drawable/ic_camera_enhance_black_24dp" />

</RelativeLayout>

使用相机需要权限：

    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> <!-- 摄像头权限 -->
    <uses-permission android:name="android.permission.CAMERA" />

package com.beidouapp.ui.Setting;

import static com.beidouapp.model.utils.ImageUtil.SavaImage;

import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

import com.beidouapp.Config;
import com.beidouapp.R;
import com.cjt2325.cameralibrary.JCameraView;
import com.cjt2325.cameralibrary.listener.JCameraListener;

import java.io.File;

/**
 * 拍照、拍摄，作为其他activity的onActivityResult目标
 * 返回data有两个参数，一个是type：photo/video（区分拍照和摄影）,一个是path，返回本地文件名
 */

public class TakePhoto extends AppCompatActivity {
    private JCameraView mJCameraView;
    private static final String TAG = "拍照";

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_take_photo);
        initView();
    }

    private void initView() {
        mJCameraView = findViewById(R.id.cameraView);
        //(0.0.7+)设置视频保存路径（如果不设置默认为Environment.getExternalStorageDirectory().getPath()）
        mJCameraView.setSaveVideoPath(Environment.getExternalStorageDirectory().getPath());
        //(0.0.8+)设置手动/自动对焦，默认为自动对焦
        //设置小视频保存路径
        File file = new File(Config.VIDEO_SAVE_DIR);
        if (!file.exists()) {
            file.mkdirs();
        }
        Log.d(TAG, "initView: "+file.getAbsolutePath());
        mJCameraView.setSaveVideoPath(Config.VIDEO_SAVE_DIR);
        mJCameraView.setJCameraLisenter(new JCameraListener() {

            @Override
            public void captureSuccess(Bitmap bitmap) {
                //获取到拍照成功后返回的Bitmap
                File photoFile = SavaImage(bitmap, "takePhoto"+System.currentTimeMillis());
                Intent data = new Intent();
                data.putExtra("type", "photo");
                data.putExtra("path", photoFile.getAbsolutePath());
                Log.d(TAG, "captureSuccess: "+photoFile.getAbsolutePath());
                setResult(RESULT_OK, data);
                finish();
            }

            @Override
            public void recordSuccess(String url, Bitmap firstFrame) {
                //获取成功录像后的视频路径
                Intent data = new Intent();
                data.putExtra("type", "video");
                data.putExtra("path", url);
                setResult(RESULT_OK, data);
                finish();
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (mJCameraView != null) {
            mJCameraView.onResume();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (mJCameraView != null) {
            mJCameraView.onPause();
        }
    }
}

安卓开发（三）数据存储机制、文件IO、SQLite

Sat, 12 Mar 2022 00:00:00 +0000

@[TOC]

安卓数据存储方式

SharedPreferences共享偏好设置

先获取到SharedPreferences对象，获取到他的编辑器，写入数据，提交。 sp.getString()来获取键值，第一个参数为键名，第二个参数为如果没有发现键名对应的键值应该返回的内容。

Preferences偏好设置

1-添加preference库依赖 2-构建用户偏好设定页面的布局

ListPreference这样的列表选择，表中具体某一项在单独的xml中定义通过name建立关系，一个是列表显示的内容，一个是程序中真实对应的值。回List本身，指明实体和实体值，并赋予列表选项一个默认值1000。 3 - 编写用户偏好页面的fragment类注意该fragment继承自PreferenceFragmentCompat，重写onCreatePreference方法，装载刚刚编写的布局文件。

此外还可以对用户偏好修改设置监听回调，例如在fragment主类实现preference更改的监听重写onSharePreference（）

在应用程序恢复时注册监听，在挂起时取消监听。采用的是getPreferenceScreen（）

内部存储

采用文件输出流（FileOutputStream）来将数据保存到文件中，指定保存的文件名和模式 Context.MODE_PRIVATE是覆盖模式，下一个用户的数据会覆盖前一个 Context.MODE_APPEND是追加模式。将name和pwd以##隔开，使用getBytes转为字节流。（只要涉及到流的形式，就需要注意判断流是否为空，如不为空，关闭流）

采用文件输入流（FileInputStream）来获取文件的字节流。用字节数组input来接收文件输入流（FileInputStream）的字节流内容，使用.available()，指定大小。判断当前读取是否为“-1”（-1代表文件末尾）。将字节数组转为字符串，使用.split（“##”）方法将字符串以“##”为间隔，分为字符串数组。则数组第一项即为用户名，第二项即为密码。

外部存储（扩展存储）

manifest添加权限：检查外部存储的可读、可写状态：

外部存储器存文件：与内部存储的主要不同是，需检查是否可写入,文件保存除了filename参数，还需获取到外部存储的路径 getExternalFilesDir（Environment.DIRECTORY_DOWNLOADS,filename）读取数据只需要读取权限：方式类似

SQLite

SQLite简介

在安卓sdk的平台工具目录下有sqlite3

SQLite数据库表的创建与增删改查

新建databaseHelper类 onCreate方法中写sql语句，执行建表操作。

在activity中运用databasehelp类来创表，获取到可写入的数据库表对象db 编写插入数据的SQL语句，利用获取的数据库表对象执行语句。这里需要注意的是使用单引号包裹每个数据内容，使用双引号和加号包裹变量名实现变量名到变量值的转化。

对于查询操作，查询的结果用游标cursor来接收。 cursor中有各种方法来获取查询结果。先moveToFirst移动游标到第一条查询结果，判断当前游标cursor的位置不在最后一条之后，则利用cursor提供的方法，获取对应的表中数据。cursor本身是对查询结果每一条的遍历，因此最后执行cursor移动到下一行。带筛选条件的查询： sql语句中先用？代表参数args，args赋值具体的参数uname，注意这里是以字符串数组的形式。然后查询语句为 db.rawQuery(sql,args)。

更新：

安卓开发（二）中间层应用、后台应用与多任务处理机制

Wed, 16 Feb 2022 00:00:00 +0000

@[TOC]

广播-broadcast

静态注册

1- 新建广播接收类：

2-在manifest中静态注册例如这里注册了广播的启动指令为 com.example.BROADCAST

3-在activity中发送广播注意andriod8.0以上需要显式的intent；

4-在广播接收器类中处理广播事件：

动态注册和取消注册广播

与静态注册过程的主要不同是不需要在manifest注册，在程序中执行。发送广播与广播接收后处理与静态相同。

在程序中构建接收器对象。构建intent过滤器，给intent过滤器添加指令内容。然后使用注册接收器函数，第一个参数是接收器，第二个参数是过滤器。

相应的取消注册：

通知-notification

第一步构建通知管理器

建立通道，先判断安卓版本 1-创建通知通道对象mchannel 2-使用通知管理器来创建通知通道新建通知构建对象，设置通知的提示图标，标题，内容，显示时间，是否点击后自动取消，设置点击通知后的intent（用于跳转activity，使用PendingIntent（）绑定activity）最后.build（）；构建成功

还可以使用setStyle设置通知大图：

多任务和服务

handle实现异步

计数器例子

1-构建runnable线程对象，将需要执行的代码写在重写的run()方法中 2-使用handle执行这个runnable 3-在runnable中可以再次使用handle来执行runnable自身，达到循环调用的结果。 4-使用handle.removeCallbacks（）来终止runnable的运行。

进度条例子

使用handle.obtainMessage，来直接获取handle的消息队列。给message附一个参数arg1，handle发送该message 在handle中设置进度条参数为message传来的arg1

AsyncTask实现多任务

继承AsyncTask 使用.execute(1000)执行AsncTask，1000为传给onProgressUpdate的参数

在doInBackground（）方法中可以获取到传来的这个参数1000，直接用integers[]，获取。该方法执行耗时任务，不可执行界面显示等操作。使用publishProgress（）发布进度，即传参给onProgressUpdate（）

服务Service

服务的生命周期

通过intent传值，启动或者暂停服务。 intent中指明了程序的跳转，从this，到 Myservice.class

使用.startService（）跳转到MyService中先执行onCreate，再执行onStartCommand 注：.startService（）可以多次启动，但是onCreate方法只在第一个服务有效，其他服务直接进入onStartCommand方法。

使用.stopService（），则执行service中的onDestroy（）方法。

IntentService

使用startService（intent）启动intentService：跳转到intentService中，执行onHandleIntent（）的回调， 执行完毕后会自动执行onDestroy（）方法来销毁服务。 这就是intentService的特点。

绑定型服务BindService

绑定型服务实现了访问者获取服务类中的数据，具体的实现是通过服务类返回Ibinder对象，而访问者程序可以直接获取到Inbind对象。

1-定义ServiceConnection 类实现程序与service的连接：

使用intent指明程序要绑定的服务。使用bindService（）方法，将intent，ServiceConnection 类带入。这里第三个参数，指的是绑定后的一些选项操作，这里直接使用了Context.BIND_AUTO_CREATE常量，意思是绑定后自动执行创建服务。

终止服务绑定只需要使用unbinderService（）方法，传入连接对象参数。

在service中，定义继承Binder的MyBinder类，在MyBinder类构建getService方法，用于将MyBindService本身返回出去。 IBinder类在onBind（）方法中可以被返回给访问程序，因此需要MyBinder类赋予给iBinder。

在访问程序中的服务连接建立那里就是获取IBinder的接口。获取到的iBinder类因为是别处接口获得的，所以需要使用强制类型转换。使用iBinder的getService（）方法即可以拿到service本身，从而调佣service的一些方法

为安全起见，在取消绑定前，应该判断一下连接是否已经建立。

信使Messenger

Messager单向传输

在service中构建IncomingHandler 用于处理响应客户端发送来的消息。使用信使Messager，来装载这个IncomingHandler ，在onBind（）方法中，将信使携带的Binder传递给客户端。

在服务端当连接成功时，即可获取到服务端发送过来的Binder，构建信使。构建message对象，构建Bundle存放消息，将Bundle放入message中，使用信使发送该message。

服务端对应的handle可以接到的信使传递来的消息。整个流程，首先服务端与客户端绑定连接。服务端构建handler，用于消息的处理，使用信使messager携带handler，通过onBind（）的接口将该handler赋予给客户端，客户端就可以指定一个信使messager携带该handle，向服务端r发送信息，实现客户端发送信息，而服务端完成handler响应。服务端本身只是binder（binder、IBinder、handler可以视为类似的东西）与客户端是相通的接口，服务端的信使在接口处，只有Binder被传到客户端，在客户端由Binder重新构建出服务端的信使，从而实现向服务端发送消息并响应

Messager双向传输

双向传输的主要区别在于，在客服端向服务端发送message时，可以直接指派一个客户端自己的信使mMessager给服务端，服务端直接把消息封装传给信使mMessager，客户端接收到消息后进行handler处理。

安卓开发（一）环境搭建、基本程序与控件

Wed, 02 Feb 2022 00:00:00 +0000

@TOC

Intent：协助应用间的交互与通信

根据此Intent的描述，负责找到对应的组件，将 Intent传递给调用的组件，并完成组件的调用。 Intent不仅可用于应用程序之间，也可用于应用程序内部的Activity/Service之间的交互。因此，可以将Intent理解为不同组件之间通信的“媒介”专门提供组件互相调用的相关信息。

intent书写两个activity页面跳转：

也可以在manifest.xml中activity中的action来实现跳转：当xml配置文件中action名有重名时，会由用户选择执行哪一个。

intent带数据

使用Bundle 存储数据，再将bundle传到intent中（bundle.putExtras()）：

在要切换到的activity中通过getIntent.getExtras(),获取到传来的bundle，取出内容：

Activity带参数返回

这种的activity之间传参是双向的：具体实现在发送方主要是：

接收方接收到信息进行处理，反馈数据给发送方

发送方接收到反馈信息后，确认请求码和接收码，编写回调。整个过程类似http通信。

Activity的生命周期

当有两个activity时的执行顺序：

View视图

布局

相对布局

Fragment

fragment类似Vue的组件

静态fragment构建步骤

fragment类似vue中封装的小组件。 1-在activity中使用fragment占位，（需要注意填写fragment的name属性，指明fragment所在位置） 2-编写fragment具体的layout.xml文件 3-编写fragment对应的java类，在onCreatView中采用inflater填充器将fragment的layout文件填充到View

动态fragment构建步骤

直接编写好fragment的layout文件和java类文件，然后在activity中使用fragment管理器：在main_activity中：

fragment通信

Activity调用Fragment

Activity在onCreate()中对fragment进行了渲染加载，因此可以直接在onStart()中直接获取fragment中的元素来处理事件。

Fragment中获取所在Activity

一般在Fragment的onActivityCreate中获取到所在Activity 注意：findViewById方法只在activity中可以使用 在fragment中onCreateView先填充view：然后view有findViewById方法

谷歌官方fragment接口通信

一般来讲，最好的事件处理方法是fragment各自监听本身的控件，监听到事件后，把事件统一交给activity处理，因此需要在fragment与activity中设置接口，传递事件。

单纯考虑fragment自己的监听和回调，步骤即为设置监听，以及监听到事件后回调执行。而现在的做法是fragment中监听，监听到事件后在activity中执行，因此首先在fragment中定义一个接口interface来包裹fragment中对事件的监听，即抽象出fragment层的监听，该抽象也需要定义设定，而interface就是桥梁，interface在activity中实现，activity在onAttachFragment即装载fragment时，如遇到有监听的fragment，则将该fragment对事件的监听收归自己所有，具体而言就是通过设定interface将自身引入传用，执行监听到事件后的回调操作，至此完成activity对fragment中监听事件的通信。

这种做法的好处在于，在fragment中完成监听以后，可以交给不同的activity来复用，interface可以看做是对fragment的监听功能的一种封装打包，将其打包给activity使用。步骤详解：在fragment中定义监听事件接口和设置监听事件（“定义监听事件接口”，具体是指监听的执行，即监听谁，而设定监听事件，则是完成对监听事件的传出设置）设定接口方法，设定接口方法可将接口中传递的事件私有化到activity本身。在activity中实现该接口（即，监听到事件后对事件的处理）：

在fragment中进行设置监听（依旧是在onActivityCreate()方法下）

在onAttachFragment()中，即给activity装载fragment时，判断是否装载的是所需的fragment，如何是，将该fragment实例化，并实例化设置接口方法。这里要注意，前边在fragment中只是定义了接口的设置，这里才是真正调用了所定义的方法，完成了接口对事件的实例化。因为Activity中实现了fragment的接口方法，所有activity本身即是监听事件。

activity获取了fragment的对事件的监听，执行回调。

###

横屏竖屏判断

全局变量配置

项目开发的过程中，可能会大量的使用全局变量，在android开发中，大多数人更偏向于使用application来保存全局变量。Application类是用来维护应用程序全局状态。我们可以提供自己的实现，并在AndroidManifest.xml文件的标签中指出它的名字，这将导致在创建应用程序时去实例化我们自己的Application类。Android系统会为每个程序运行时创建一个Application类的对象且仅创建一个，所以Application可以说是单例模式的一个类。且Application对象的生命周期是整个程序中最长的，它的生命周期就等于这个程序的生命周期。因为它是全局唯一的，所以在不同的Activity,Service中获得的对象都是同一个对象。所以，通过Application来进行一些数据传递、数据共享、数据缓存等操作。

　　首先创建继承自Application的MyApplication类，定义变量score,并创建get和set方法。复制代码

package com.example.whs.myapplication;

import android.app.Application;

/**
 * Created by whs on 17/5/1.
 */

public class MyApplication extends Application {
    private int score = 100;

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

下面就是如何使用我们创建的全局变量了，在MainActivity中，首先要获得MyApplication的对象，因为MyApplication继承自Application，所以使用getApplication()方法即可，然后可以调用MyApplication的get或set方法进行访问全局变量。

        MyApplication application = (MyApplication)this.getApplication();
        application.setScore(200);
        int score = application.getScore()

真机测试

手机端：查看手机安卓版本，比如安卓11.0，开启开发者模式（一般是系统管理、关于手机、版本信息、软件版本），进入开发者选项（进入开发者模式后设置中出现），打开USB调试。电脑端：根据手机安卓版本，下载对应的SDK平台（设置中）一般还需要给手机下载谷歌的USB驱动，在SDKtools中：根据下载的位置：D:\Jetbrains\andriodSDK\extras\google\usb_driver，更新驱动程序。

所有都做完后，一般可以检测到安卓设备。

生成apk安装包的方法

生成apk

inflater（布局填充器）

布局渲染的过程：获取填充器，构建布局View，编辑View属性

LayoutInflater inflater = getLaoutInflater();
View layout = inflater.inflate(R.layout.custom,(ViewGroup)findViewById(R.id.llToast));
TextView title = layout.findViewById(R.id.tvTitleToast);
image.setImageResource(R.drawble.picture);

基本控件

按钮

按钮的快速绑定三部曲： 1- 在主类中实现监听方法 2- 设置按钮监听器 3- 重写onClick（）按钮点击的回调。

ImageView

ImageView具有setImageDrawable()和getDrawable()来设置图像内容或者获取图像内容。

进度条

设置水平进度条：

    <ProgressBar
        android:id="@+id/id_progress"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

                // 设置进度条
                mProgressBar.setProgress(mProgress); ## 按钮组

            <RadioGroup
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_gravity="center_vertical"
                android:layout_marginEnd="20dp"
                android:id="@+id/rd_mode_set"
                android:orientation="horizontal">

                <RadioButton
                    android:id="@+id/bt_set_mode_normal"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:text="@string/bt_set_mode_normal" />

                <RadioButton
                    android:id="@+id/bt_set_mode_sos"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:text="@string/bt_set_mode_sos" />
                <RadioButton
                    android:id="@+id/bt_set_mode_extreme"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:text="@string/bt_set_mode_extreme" />
            </RadioGroup>

        rg_mode_set = findViewById(R.id.rd_mode_set);
        rg_mode_set.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            // 第一个参数 按钮组，第二个被选中按钮的id
            public void onCheckedChanged(RadioGroup radioGroup, int i) {
                for (Map.Entry<String, Integer> entry : MODE_MAP.entrySet()) {
                    if (Objects.equals(entry.getValue(), i)) {
                        try {
                            String cmd = getCMDDownMode('1',Integer.parseInt(entry.getKey()));
                            writeCh.setValue(cmd.getBytes("GBK"));
                            gatt.writeCharacteristic(writeCh);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

对话框dialog

点击显示对话框

    /**
     * 修改头像选择
     */

    private void selectImg(){
        AlertDialog.Builder builder = new AlertDialog.Builder(this)
                .setTitle("提示")
                .setMessage("请选择操作类型")
                .setPositiveButton("拍照", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        try {
                            Intent intent = new Intent(ActivityUser.this,TakePhoto.class);
                            startActivityForResult(intent, 12);
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                })
                .setNegativeButton("图库", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        addPic();
                    }
                })
                .setNeutralButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {

                    }
                });
        builder.create().show();
    }

选项菜单

basic activity：布局构成：工具栏+content+浮动按钮 content使用的include引入的另一个layout资源文件：具体的菜单选项内容在menu文件夹下定义。 orderInCategory，是设定选项的顺序。可以添加icon图标 menu的每个item选项可以再嵌套menu：

在java类中，先在onCreateOptionsMenu（）中使用getMenuInflater（）对菜单进行填充在onOptionsItemSelected（）中设置菜单选项点击时的回调。

当然构建menu时也可以为每个setting设置onClick事件如果有设置，则系统优先执行的是你设置的onClick，而不是onOptionsItemSelected（）中的回调。

弹出菜单

在activity中实现视图点击监听和弹出菜单点击监听。创建PopupMenu对象，填充菜单内容，设置监听，在onMenuItemClick中写回调。

上下文菜单

浮动模式 菜单可以动态添加 menu.add（）

菜单选项监听：动作模式顶部动作选项

引入actionMode

创建actionMode对象：先判断actionMode是否已经执行，避免多次生成；然后设置 startActionMode 需要传递actionModeCallback参数，就是执行actionMode的回调 actionModeCallback需要另行构造在onCreateActionMode中填充菜单 onActionModeItemClicked中写点击回调

动作条actionView

以内置的searchView类型动作按钮为例：

ListView

ListView本身在layout中只是占位用，实际内容需另外构建item.xml文件。比较简单的使用，数据类型比较单一的时候，listview占位： item.xml，只有一个TextView

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:textSize="18sp"
    android:padding="5dp"
/>

activity中; 使用ArrayAdapter填充item.xml，给listview设置adapter，adapter添加数据。

        //初使化设备适配器存储数组
        mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);
        mUnPairedDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);

        //设置已配队设备列表
        ListView pairedListView = findViewById(R.id.pairedListView);
        pairedListView.setAdapter(mPairedDevicesArrayAdapter);
        pairedListView.setOnItemClickListener( mDeviceClickListener);

        // 设置新查找设备列表
        ListView newDevicesListView = findViewById(R.id.unPairedListView);
        newDevicesListView.setAdapter(mUnPairedDevicesArrayAdapter);
        newDevicesListView.setOnItemClickListener(mDeviceClickListener);

//         得到本地蓝牙句柄
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
//        //添加已配对设备到列表并显示
        if (pairedDevices.size() > 0) {
            findViewById(R.id.pairedListView).setVisibility(View.VISIBLE);
            for (BluetoothDevice device : pairedDevices) {
                mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
            }
        } else {
            String noDevices = "没有找到已配对的设备。" ;
            mPairedDevicesArrayAdapter.add(noDevices);
        }

较为复杂的实现，adapter需要自己定义。

例如聊天界面的消息列表 listview占位不赘述。 itme的xml形式：主要包括气泡框，发送时间，头像，发送内容这些数据。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout style="@style/jmui_chat_item_send_layout"
              xmlns:android="http://schemas.android.com/apk/res/android">


    <TextView
        android:id="@+id/tv_sendtime"
        style="@style/jmui_chat_text_date_style"/>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="5dp"
        android:gravity="right"
        android:orientation="horizontal">

        <ImageButton
            android:id="@+id/jmui_fail_resend_ib"
            android:layout_width="21dp"
            android:layout_height="21dp"
            android:layout_gravity="center_vertical"
            android:layout_marginRight="5dp"
            android:background="@drawable/send_message_failed"
            android:clickable="true"
            android:scaleType="fitCenter"
            android:visibility="gone"/>

        <LinearLayout
            style="@style/jmui_msg_content_style"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginRight="3dp"
            android:autoLink="web"
            android:background="@drawable/jmui_msg_send_bg"
            android:paddingLeft="10dp"
            android:paddingRight="18dp"
            android:textColor="#363333"
            android:textColorLink="#157BFB"
            android:orientation="vertical">

            <TextView
                style="@style/jmui_msg_text_style"
                android:id="@+id/tv_content"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:textColorLink="#157BFB"
                android:visibility="visible"/>

            <ImageView
                style="@style/jmui_msg_img_style"
                android:id="@+id/iv_content"
                android:adjustViewBounds="true"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:visibility="gone"/>

        </LinearLayout>


        <LinearLayout
            android:id="@+id/ll_push"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginRight="3dp"
            android:background="@drawable/business_card_bg"
            android:orientation="vertical"
            android:visibility="gone">

            <LinearLayout
                android:layout_width="wrap_content"
                android:layout_height="wrap_content">

                <ImageView
                    android:id="@+id/iv_push_img"
                    android:layout_width="40dp"
                    android:layout_height="40dp"
                    android:layout_marginBottom="12.33dp"
                    android:layout_marginLeft="11dp"
                    android:layout_marginTop="13.33dp"/>

                <LinearLayout
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_marginTop="14dp"
                    android:orientation="vertical">

                    <TextView
                        android:id="@+id/tv_menuName"
                        android:layout_width="120dp"
                        android:layout_height="wrap_content"
                        android:layout_marginLeft="11.33dp"
                        android:ellipsize="end"
                        android:maxLines="1"
                        android:textColor="#2C2C2C"
                        android:textSize="15sp"/>

                    <TextView
                        android:id="@+id/tv_pushContent"
                        android:layout_width="120dp"
                        android:layout_height="wrap_content"
                        android:layout_marginLeft="11.33dp"
                        android:layout_marginTop="4dp"
                        android:ellipsize="end"
                        android:maxLines="1"
                        android:textColor="#999999"
                        android:textSize="12sp"/>
                </LinearLayout>
            </LinearLayout>

            <View
                android:layout_width="183dp"
                android:layout_height="0.33dp"
                android:layout_marginLeft="10dp"
                android:layout_marginRight="16.67dp"
                android:background="#DCDCDC"/>

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginBottom="3dp"
                android:layout_marginLeft="10dp"
                android:layout_marginTop="3dp"
                android:text="@string/Message_push"
                android:textColor="#989898"
                android:textSize="10sp"/>

        </LinearLayout>

        <ImageView
            android:id="@+id/jmui_avatar_iv"
            style="@style/jmui_chat_item_sender_avatar_style"
            android:layout_width="@dimen/avatar_list_size"
            android:layout_height="@dimen/avatar_list_size"
            android:scaleType="fitCenter"
            android:gravity="center_vertical" />
<!--        <TextView-->
<!--            android:id="@+id/default_head"-->
<!--            android:layout_width="@dimen/default_head_list"-->
<!--            android:layout_height="@dimen/default_head_list"-->
<!--            android:layout_marginEnd="10dp"-->
<!--            android:textSize="@dimen/default_head_list_text"-->
<!--            android:textColor="@color/white"-->
<!--            android:gravity="center"-->
<!--            android:background="@drawable/border_head_list"/>-->

    </LinearLayout>

</LinearLayout>

package com.beidouapp.model.adapters;

import static androidx.core.content.ContextCompat.startActivity;
import static com.beidouapp.model.utils.ImageUtil.getDefaultBitmap;
import static com.beidouapp.model.utils.ImageUtil.isImage;

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.LayerDrawable;
import android.media.MediaMetadataRetriever;
import android.media.MediaPlayer;
import android.net.Uri;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.activity.result.contract.ActivityResultContracts;

import com.alibaba.fastjson.JSON;
import com.beidouapp.Config;
import com.beidouapp.R;
import com.beidouapp.model.messages.ChatMessage;
import com.beidouapp.model.messages.Position;
import com.beidouapp.model.utils.ImageUtil;
import com.beidouapp.ui.ZoomPhoto;
import com.beidouapp.ui.ZoomPosition;
import com.beidouapp.ui.ZoomVideo;
import com.bumptech.glide.Glide;
import com.bumptech.glide.request.RequestOptions;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

public class ChatAdapter extends BaseAdapter {
    List<ChatMessage> chatMessageList;
    LayoutInflater inflater;
    Context context;

    public ChatAdapter(Context context, List<ChatMessage> list) {
        this.chatMessageList = list;
        this.context = context;
        inflater = LayoutInflater.from(context);
    }

    @Override
    public int getViewTypeCount() {
        return 2;
    }

    @Override
    public int getItemViewType(int position) {
        if (chatMessageList.get(position).getIsMeSend() == 1)
            return 0;
        else
            return 1;
    }

    @Override
    public int getCount() {
        return chatMessageList.size();
    }

    @Override
    public Object getItem(int position) {
        return chatMessageList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        String fileName;
        ChatMessage chatMessage = chatMessageList.get(position);
        String content = chatMessage.getContent();
//        int start=content.lastIndexOf("/");
//        int end=content.lastIndexOf(".");
//        if(start!=-1 && end!=-1){
//            fileName = content.substring(start+1,end);
//        }else{
//            fileName = null;
//        }
//        Log.d("zw", "getView: " + content + " " + fileName + ".amr");
        String extraContent = "File//sdcard/BeidouAPP/Download/" + "2d46ee8c-69ab-445f-b960-7ec3b56672e3" + ".amr";
        Log.d("zw", "getView: " + extraContent);
        String time = formatTime(chatMessage.getTime());
        String type = chatMessage.getType();
        String nickname = chatMessage.getName();
        int isMeSend = chatMessage.getIsMeSend();
        String avatar = chatMessage.getAvatar();
        String id = chatMessage.getId();
        //int isRead = chatMessage.getIsRead();
        final ViewHolder holder;

        if (convertView == null) {
            holder = new ViewHolder();
            if (isMeSend == 0) {
                convertView = inflater.inflate(R.layout.item_chat_receive_text, parent, false);
                holder.tv_content = convertView.findViewById(R.id.tv_content);
                holder.tv_sendtime = convertView.findViewById(R.id.tv_sendtime);
                holder.iv_content = convertView.findViewById(R.id.iv_content);
                holder.tv_display_name = convertView.findViewById(R.id.tv_display_name);
                holder.avatar = convertView.findViewById(R.id.tv_display_avatar);

            } else {
                convertView = inflater.inflate(R.layout.item_chat_send_text, parent, false);
                holder.tv_content = convertView.findViewById(R.id.tv_content);
                holder.iv_content = convertView.findViewById(R.id.iv_content);
                holder.tv_sendtime = convertView.findViewById(R.id.tv_sendtime);
                holder.avatar = convertView.findViewById(R.id.jmui_avatar_iv);
            }
            convertView.setTag(holder);
        } else {
            holder = (ViewHolder) convertView.getTag();
        }
        if (avatar.equals(holder.avatar.getTag())){}
        else {
            ImageUtil.loadAvatar(context, id, avatar, holder.avatar);
            holder.avatar.setTag(avatar);
        }

        holder.tv_sendtime.setText(time);

        if (type.equals("text")) {
            holder.tv_content.setVisibility(View.VISIBLE);
            holder.tv_content.setText(content);
            holder.iv_content.setVisibility(View.GONE);
        }
        else if (type.equals("img")) {
            try {
                holder.tv_content.setVisibility(View.GONE);
                Bitmap bitmap = BitmapFactory.decodeFile(content);
                holder.iv_content.setImageBitmap(bitmap);
                holder.iv_content.setVisibility(View.VISIBLE);
                holder.iv_content.setOnClickListener(view -> {
                    Intent intent = new Intent(context, ZoomPhoto.class);
                    intent.putExtra("path",content);
                    context.startActivity(intent);
                });
            } catch (Exception e) {
                holder.tv_content.setVisibility(View.VISIBLE);
                holder.tv_content.setText("[图片已损坏]");
                holder.iv_content.setVisibility(View.GONE);
            }
        }
        else if (type.equals("audio")) {
            holder.tv_content.setVisibility(View.GONE);
            holder.iv_content.setImageResource(R.drawable.icon_voice_press);
            holder.iv_content.setVisibility(View.VISIBLE);
            holder.iv_content.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    try {
                        MediaPlayer mediaPlayer = MediaPlayer.create(context, Uri.parse(content));
                        mediaPlayer.start();
//                        MediaPlayer mediaPlayer = MediaPlayer.create(context, Uri.parse(extraContent));
//                        mediaPlayer.start();
                    }catch (Exception e){
                        Log.d("zw", "onClick: 此时使用第二个方法加载");
                        try {
                            MediaPlayer mediaPlayer = MediaPlayer.create(context, Uri.parse(extraContent));
                            mediaPlayer.start();
                        }catch (Exception exception){
                            Log.d("zw", "onClick: 第二个方法也错了");
                            exception.printStackTrace();
                        }
                    }
                }
            });
        }
        else if (type.equals("video")) {
            try {
                holder.tv_content.setVisibility(View.GONE);
                MediaMetadataRetriever media = new MediaMetadataRetriever();
                media.setDataSource(content);
                Bitmap baseBitmap = media.getFrameAtTime();
                holder.iv_content.setImageBitmap(ImageUtil.getVideoImg(context, baseBitmap));
                holder.iv_content.setVisibility(View.VISIBLE);
                holder.iv_content.setOnClickListener(view -> {
                    Intent intent = new Intent(context, ZoomVideo.class);
                    intent.putExtra("path",content);
                    Log.d("视频", "getView: "+content);
                    context.startActivity(intent);
                });
            } catch (Exception e) {
                holder.tv_content.setVisibility(View.VISIBLE);
                holder.tv_content.setText("[视频已损坏]");
                holder.iv_content.setVisibility(View.GONE);
            }
        }
        else if (type.equals("notice")) {
            holder.tv_content.setVisibility(View.VISIBLE);
            holder.tv_content.setText("群公告："+ content);
            holder.iv_content.setVisibility(View.GONE);
        }
        else if (type.equals("pos")) {
            holder.tv_content.setVisibility(View.VISIBLE);
            holder.iv_content.setVisibility(View.VISIBLE);

            Position pos = JSON.parseObject(content, Position.class);
            holder.tv_content.setText("位置：" + pos.getText());
            holder.iv_content.setImageResource(R.drawable.pos_img);
            holder.iv_content.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Intent intent = new Intent(context, ZoomPosition.class);
                    intent.putExtra("pos", pos);
                    context.startActivity(intent);
                }
            });
        }



        if (isMeSend == 1) {
        }else{
            holder.tv_display_name.setVisibility(View.VISIBLE);
            holder.tv_display_name.setText(nickname);
        }

        return convertView;
    }

    class ViewHolder {
        private TextView tv_content;
        private TextView tv_sendtime;
        private TextView tv_display_name;
        private ImageView avatar;
        private ImageView iv_content;
        //private TextView tv_isRead;
    }

    private String formatTime(String timeMillis) {
        long timeMills=Long.parseLong(timeMillis);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date(timeMills);
        return simpleDateFormat.format(date);
    }
}

这个adapter的编写思路:

1- public class ChatAdapter extends BaseAdapter 然后实现方法：四个方法分别是获取列表长度，根据位置索引获取到某个item，根据位置索引获取itme的id，获取视图

2-构建子类viewHolder用于声明item中的各个布局组件 3- alt+inser，选择‘construct’，构造方法，开放接口给activity，以便输出context和数据列表：这里还传输了inflater，是为了渲染item.xml

4-在getview中，使用inflater渲染item.xml，并实例化viewHolder中的各个布局组件，进行数据设置。

5-在activity中使用自定义adapter：

    /**
     * 更新消息列表
     */
    private void initChatMsgListView() {
        adapter = new ChatAdapter(context, chatMessageList);
        listView.setAdapter(adapter);
        listView.setSelection(chatMessageList.size());
        listView.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL);
    }

这里 listView.setSelection(chatMessageList.size());将列表选中最后一个item， listView.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL); 如果是 TRANSCRIPT_MODE_ALWAYS_SCROLL：则强制从 ListView 的底部开始刷新；如果是 TRANSCRIPT_MODE_NORMAL：如果当前的最后一个 Item 在 ListView 显示范围内，adapter 数据集内容变化时就从滚动底部；否则不滚动到底部！

gtecAPI-Client文档

Thu, 09 Dec 2021 00:00:00 +0000

THE CLIENT API

Client API是一个库，它提供使用服务器服务进行数据获取的所有必要方法。 Client API可应用于任何类型 DAQ（数据采集）单元的常用方法和用于特殊操作的附加设备特定方法组成。客户端 API 可由任何代表客户端的应用程序使用。 API 使用包装在 TCP/IP 消息中的 XML 字符串与服务器服务进行通信。字符串携带诸如命令、配置或采集数据之类的信息。唯一的连接句柄始终是用于标识客户端的 XML 字符串的一部分

术语与歧义消除

g.NEEDaccess 文档中引入了几个术语来区分服务器的几个组件和逻辑概念。本章列出了在所有 g.NEEDaccess 文档中一致使用的一些重复使用的术语。下图说明了服务器的工作原理。客户端可以通过有线或无线网络连接到服务器。如果客户端与服务器服务在同一台计算机上运行，则使用环回（IP 地址：127.0.0.1）来寻址机器自己的以太网适配器。

DEVICE(设备)（或 DAQ 设备）是一种物理设备，即生物信号放大器，可测量数据并将其发送到所连接的计算机。它可以是 g.USBamp、g.HIamp 或 g.Nautilus 类型。 - MASTER/SLAVE(主机/从机)当多个设备（通常是同一类型）进行硬件同步时（即这些设备之一通过硬件同步所有其他设备之间的数据采集），产生时钟的设备是主设备。与主时钟同步的其余设备称为从设备。 1.1 节图中 DAQ 单元内的主站标记为红色。
SERVER/CLIENT（服务器/客户端）服务器服务在连接到应从中获取数据的所有设备的计算机上运行。服务器从其连接的设备获取数据并将其分发/流式传输到客户端。客户端是应用程序，而不是通过网络接口（使用网络 API）与服务器通信以配置和检索连接到服务器的某些设备的数据的计算机。多个客户端可以在同一台机器上运行，甚至可以在运行服务器服务的同一台机器上运行。服务器在单独的缓冲区中为每个客户端提供获取的数据，可以将其想象为单独的邮箱。客户端必须定期从其专用缓冲区请求和检索数据。这些缓冲区中的每一个都设计用于存储大约 10 秒的原始数据。如果客户端没有足够快地请求足够的数据，则其专用缓冲区会填满，并且当缓冲区已满时可能会向客户端报告溢出。下图显示了内部数据采集管理和客户端到 DAQ 单元的“路由”
DATA ACQUISITION UNIT (DAQ UNIT数据采集单元)数据采集单元是一个虚拟单元，是服务器的一部分。它封装了一个（最简单的情况）或多个硬件同步设备并从中获取数据。属于同一 DAQ 单元的设备必须具有相同的设备类型（并且该类型必须便于硬件同步）。因此，DAQ 单元也可以看作是实际设备类型的（巨大的）单个设备。对于每个特定的独立硬件同步设备组，存在单独的数据采集单元。一个物理设备只能是单个 DAQ 单元的一部分。考虑一个示例，其中六个 g.USBamp 设备连接到服务器。前四个是硬件同步的，并集中在 DAQ 单元 1 中。其余两个设备以相同的方式组成 DAQ 单元 2。因此，有两组独立的设备，服务器将运行两个独立的数据采集单元（DAQ 1 + 2），每组一个
DATA ACQUISITION SESSION (DAQ SESSION数据采集会话)数据采集会话基本上是指一个特定的数据采集单元，但是以更概念化的方式。服务器本身不知道其连接的哪些设备是硬件同步的。当客户端与服务器建立连接时，它必须指定要从中获取数据的特定设备组。该组中指定的所有设备都必须是硬件同步的。如果这些设备都不是另一个数据采集会话/单元的一部分，则服务器为该组创建一个数据采集单元。访问该特定数据采集单元的每个客户端都参与相同的数据采集会话。一旦客户端连接到服务器，就会生成一个唯一的连接句柄，服务器使用该句柄来寻址客户端。
SESSION CREATOR/PARTICIPANT(会话创建者/参与者)每个客户端都可以从一个 DAQ 单元访问和获取数据。对于另一个客户端，它可以参与正在运行的 DAQ 会话并从其分配的设备获取数据（参见第 1.1.3 节中的图），或者它可以使用不属于某个设备的设备创建新的数据获取会话。现有的数据采集单元。打开特定设备组的第一个客户端是该特定 DAQ 会话的创建者。服务器创建相应的 DAQ 单元。会话创建者可以完全控制他们分配的设备，并可以配置和操作它们。想要打开同一组设备的任何其他客户端都将成为该现有 DAQ 会话的参与者。服务器将客户端与现有的 DAQ 单元相关联，而不是创建一个新的单元。参与者不得控制数据采集或配置设备。基本上，他们只能检索有关该单元的数据和其他信息。当创建者关闭连接并且该单元被服务器销毁时，DAQ 单元的生命周期就会到期。通知可能的现有参与者。单元内的硬件设备被释放，可用于后续的数据采集会话。另一方面，如果参与者关闭其与服务器的连接，则数据获取单元保持运行，至少对于该会话的创建者和所有剩余参与者而言。
CONNECTION HANDLE(连接句柄)连接句柄基本上是一个唯一编号，用于标识客户端及其关联的数据获取会话。它在创建或打开数据采集会话时分配给客户端。需要指出的是，同一会话的创建者和参与者被分配了不同的连接句柄。每当客户端向服务器发送命令时，其连接句柄都包含在消息中，因此服务器知道该命令属于哪个客户端（和 DAQ 会话）
GDS GDS 是服务器服务本身的名称，代表 g.tec 设备服务。该术语可能出现在整个客户端 API 参考中。

使用C程序API库

g.NEEDaccess 带有用于 C 编程语言和 .NET 框架的 API，以及用于从 Windows 以外的平台访问 g.NEEDaccess 服务器的底层网络 API 的文档。本文档重点介绍 g.NEEDaccess 的 C API 库。其余 API 存在单独的文档。 C API 可以使用两种不同的方式与服务器通信。客户端 C API 使用网络与服务器通信。服务器端 C API 将命令直接应用到同一台机器上的服务器上，而无需使用网络通信。两者共享相同的接口。有关如何选择要使用的 API，请参阅针对入口点信息 (lib) 的链接部分。如果应用程序使用具有严格时序约束的高性能数据采集，则服务器端 C API 可能更适合满足其要求。 包含的头文件: 对于每个设备，存在一个单独的头文件，其中包含特定于设备的功能和该设备的配置结构。它们都包含基本的头文件 GDSClientAPI.h。仅在项目中包含您正在使用的设备的头文件就足够了，但要确保基本头文件与包含的头文件位于同一目录中。如果您使用不同类型的设备，请包含每种类型的头文件。不要将头文件与您的应用程序一起部署。 针对入口点信息 (LIB) 的链接对于每个受支持的平台，C API 安装路径中的子文件夹包含入口点信息 lib 文件，以供链接器使用。目前，C API 仅支持 64 位 Windows 平台 (x64)。您可以通过链接以下 lib 文件之一来选择使用客户端 C API 或服务器端 C API： 使用动态链接库 (DLL) 执行包含入口点信息 lib 文件的平台子文件夹还包含执行所需的动态链接库 (DLL)。所有这些 DLL 必须与使用它们的应用程序位于同一目录中，或者位于全局系统搜索路径中。如果运行该应用程序的同一台机器也运行 g.NEEDaccess Server，则这些库已经驻留在系统的 PATH 环境变量指向的系统搜索路径上，不需要额外部署。

一般数据采集流程

要使用客户端 API 方法成功获取数据，请确保服务器首先启动并运行。然后，按顺序执行以下步骤：

在第一次使用之前使用 GDS_Initialize 初始化库一次。
确定本地和目标 IP地址以及端口号。服务器（称为目标端点）默认使用端口 50223进行传入连接。建议在同一台机器上运行客户端应用程序和服务器。在这种情况下，本地和目标端点都使用环回地址 (127.0.0.1)。
初始化 GDS_ENDPOINT 结构的两个实例：一个用于本地（客户端），另一个用于目标（服务器）端点。
连接到服务器并使用 GDS_Connect 创建连接句柄。将服务器的端点作为目标端点传递。
设置回调（这不是必需的，但强烈推荐）。
为每个设备创建一个适当的配置结构实例，如有必要，设置配置或执行其他设备特定任务。
使用 GDS_GetDataInfo 确定缓冲区大小并相应地分配内存。如果需要，创建并打开文件（输出流）以将数据保存到文件中。
使用 GDS_StartStreaming开始流式传输。
使用 GDS_GetData 在循环内收集数据。
使用 GDS_StopStreaming 停止流式传输。
使用GDS_StopAcquisition 停止采集。释放先前分配的资源。如果以前打开过，请关闭输出文件。
使用GDS_Disconnect 断开与服务器的连接。
如果不再使用，则使用 GDS_Uninitialize 取消初始化库。

说明GDSClientAPIDemo项目

` GDSClientAPIDemo 是一个控制台应用程序，用于说明 Microsoft Windows 操作系统下 C++ 编程语言中 g.NEEDaccess Client API 的基本用法。相关的源代码和项目文件位于 GDSClientAPIDemo 文件夹中，该文件夹作为 MS Windows 的示例安装。提供了将 g.NEEDaccess 与 g.USBamp、g.HIamp、g.Nautilus PRO 和 g.Nautilus 设备配合使用的单独示例。运行示例需要在运行 Microsoft Windows 操作系统的主机上运行 g.NEEDaccess 服务器实例。假设示例在运行服务器的同一台机器上执行。这些示例使用环回适配器地址与服务器通信`（有关详细信息，请参阅 g.NEEDaccess 服务器文档）。此外，需要 Microsoft Visual C++（Microsoft Visual Studio 的一部分）来打开预配置的项目文件并编译示例的源代码

编译 GDSClientAPIDemo项目

打开 GDSClientAPIDemo 文件夹中为每种设备类型提供的 MS Visual C++ 项目文件之一（例如 gUSBampDemo.vcxproj）。确保您使用配置管理器从 Build 菜单中选择了适当的平台设置（Win32 for 32-bit, x64 for 64-bit），并通过从 Build 菜单中选择 Build Solution 来编译它。目前，仅支持 64 位平台 (x64) 根据所选平台和配置命名的文件夹将在 GDSClientAPIDemo 文件夹中创建，生成的可执行文件将构建到其中。从 Visual Studio、双击它或从命令行运行可执行文件。启动时，应用程序会扫描连接到当前机器的受支持设备，并提示您从显示的列表中选择其中一个。选择设备后立即开始测量过程，并将数据记录到二进制文件 (data.bin) 中。当预配置的采集持续时间结束时，数据采集将自动停止。应用程序和设备的配置被打印到控制台窗口。它们对于读取记录的数据文件很重要。

读取记录的数据文件

记录的数据文件包含作为 32 位浮点值的采集样本。数据被组织为一系列扫描。每次扫描都包含每个采集通道的一个样本，从第一个采集通道开始。扫描的所有样本都在同一时间点进行采样。可以将其视为格式为channel x samples 的二维矩阵。下面这段代码说明了如何在MATLAB中读入记录的数据文件。必须事先将文件名变量设置为记录数据文件的名称。通道变量必须设置为文件预先包含的获取通道数，包括可能记录的触发通道（或其他可用的附加通道）。 data 变量从文件中接收记录的数据作为格式通道 x 样本的矩阵 ```filename = ‘data.bin’; channels = 16; fid = fopen(filename, ‘rb’); data = fread(fid, [channels, inf], ‘float32’); fclose(fid);

```

机器学习的特征筛选方法

Sun, 24 Oct 2021 00:00:00 +0000

背景题目

抗胰腺癌候选药物分子优化建模 Mole—文件提供了候选药物分子的784个属性值，包含training和test两个表，分别有1974个分子和50个分子。 ER—–文件提供了这些候选分子的IC50和pIC50值的大小，用于衡量分子活性，其中pIC50是IC50的负对数，取负对数的原因是为了使pIC50大小与分子活性呈正相关。同样包含training表和test表，training表中分子活性标志值pIC50已经给出，test表中的值未给，是问二需要自己预测的值问一：从分子的784个属性特征中筛选出20个与分子活性最相关的属性问二：根据筛选出的20个特征属性，训练回归模型，预测test表中pIC50值。

特征筛选

记录两篇写的比较详细的博客地址特征选择- Sklearn.feature_selection的理解机器学习之特征选择（Feature Selection）这部分主要是上述两篇文章的汇总，以及skilearn官方api中feature-select相关接口的说明 sklearn库feature selection特征选择算法及API使用

Filter过滤法

方差过滤

　Variance Threshold是通过特征本身方差来筛选特征的类。比如一个特征本身的方差很小，就表示样本在这个特征上基本没有差异，可能特征中的大多数值都一样，甚至整个特征的取值都相同，那这个特征对于样本区分没有什么作用。所以无论接下来的特征工程要做什么，都要优先消除方差为0的特征。VarianceThreshold有重要参数threshold，表示方差的阈值，表示舍弃所有方差小于threshold的特征，不填默认为0，即删除所有的记录都相同的特征。

#设置方差阈值筛选
from sklearn.feature_selection import VarianceThreshold
selector = VarianceThreshold(threshold = 1)#设置方差过滤阈值为1
aa = selector.fit_transform(feature_frame)
aa_name = selector.get_support()#get_support函数返回方差＞阈值的布尔值序列
aa_select = feature_frame.iloc[:,aa_name]#根据布尔值序列取出各个特征

这个过程其实也可以不用api函数自行实现：

var = feature_frame.var()#求每列方差
var_thresh = 1 #设置阈值
var_select = var[var>var_thresh]#根据条件返回序列值，取大于阈值
X = feature_frame[var_select.index]#取出特征

方差过滤的阈值threshold是一个超参，根据情况自行设置，设置为0可以剔除常量特征。

灰色关联度分析（GRA）

灰色关联度计算方法代码示例：

#计算特征与分子活性间的灰色关联度
数据归一化
normal_pic50 = (pic50 - min(pic50)) / (max(pic50) - min(pic50))  #pIC50结果归一化
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
scaler.fit(X)
normal_X = pd.DataFrame(scaler.transform(X))  
normal_X.index = X.index
normal_X.columns = X.columns
refer_seq = normal_pic50 #设置分子活性为参考序列，特征矩阵每列为比较序列
diff_matrix = pd.DataFrame()
for feature in list(normal_X.columns):
    #比较序列与参考序列相减
    diff_col = pd.Series(X[feature] - refer_seq)
    diff_col.name = feature
    diff_matrix = diff_matrix.append(diff_col) #这里append是按行添加的，因此后边需要转置一下
diff_matrix = diff_matrix.T
#求最大差和最小差
mmax = diff_matrix.abs().max().max()
mmin = diff_matrix.abs().min().min()
rho=0.5 #设置分辨系数为0.5
#求关联度
r=(mmin+rho*mmax)/((abs(diff_matrix)+rho*mmax))
grey_corr=r.sum(axis=0)/len(diff_matrix.index)
grey_sort=grey_corr.sort_values(ascending=False)

##可视化灰色关联度排名
grey_select = grey_sort.iloc[:len(pesrson_select)]

##两种关联度的交叉
common_test = [index for index in grey_select.index if index in pesrson_select.index]
print("公共变量为：" , len(common_test))

plt.figure(figsize=(16,6))
sns.barplot(grey_select.values, grey_select.index, orient='h')
plt.title("特征与分子活性之间的灰色关联度排序")

Wrapper包装法

包装法将特征包装进模型通过评估模型效果，判断特征的去留。在初始特征集上训练评估器，并且通过coef_属性或通过feature_importances_属性获得每个特征的重要性。然后，从当前的一组特征中修剪最不重要的特征。在修剪的集合上递归地重复该过程，直到最终到达所需数量的要选择的特征。包装法最典型的方法为递归特征消除法Recursive feature elimination (RFE) 主要思想是反复的构建模型（如SVM或者回归模型）然后选出最差的（或者最好的）的特征（可以根据系数来选），把选出来的特征放到一边，然后在剩余的特征上重复这个过程，直到所有特征都遍历了。这个过程中特征被消除的次序就是特征的排序。因此，这是一种寻找最优特征子集的贪心算法。

RFE的稳定性很大程度上取决于在迭代的时候底层用哪种模型。例如，假如RFE采用的普通的回归，没有经过正则化的回归是不稳定的，那么RFE就是不稳定的；假如采用的是Ridge，而用Ridge正则化的回归是稳定的，那么RFE就是稳定的。 sklearn.feature_selection.RFE RFE类中有两个比较重要的属性，.support_：返回所有的特征的是否最后被选中的布尔矩阵，以及.ranking_返回特征的按数次迭代中综合重要性的排名。

skileanr还有一个类feature_selection.RFECV会在交叉验证循环中执行RFE以找到最佳数量的特征，增加参数cv，其他用法都和RFE一模一样。

Embedded嵌入法

包装法将特征打包不断创建新模型测试特征的有效性，而嵌入法则是将特征都嵌入到算法流程中，类似随机森林和决策树模型在模型训练过程中根据信息增益对特征重要性赋予权重，特征选择与模型生成同步进行，而不必重复创建模型测试特征的重要性。

使用SelectFromModel 选取特征（Feature selection using SelectFromModel）

示例1 随机森林模型绘制学习曲线确定特征重要性阈值

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier as RFC<br>import numpy as np<br>import matplotlib.pyplot as plt<br>
RFC_ = RFC(n_estimators =10,random_state=0)
print(X_embedded.shape)
#模型的维度明显被降低了
#画学习曲线来找最佳阈值
 
RFC_.fit(X,y).feature_importances_
threshold = np.linspace(0,(RFC_.fit(X,y).feature_importances_).max(),20)
score = []
for i in threshold:
X_embedded = SelectFromModel(RFC_,threshold=i).fit_transform(X,y)
once = cross_val_score(RFC_,X_embedded,y,cv=5).mean()
score.append(once)
plt.plot(threshold,score)
plt.show()
X_embedded = SelectFromModel(RFC_,threshold=0.00067).fit_transform(X,y)
X_embedded.shape
print(cross_val_score(RFC_,X_embedded,y,cv=5).mean())

示例2：基于L1的特征选取

from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectFromModel
iris = load_iris()
X, y = iris.data, iris.target

lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X, y)
model = SelectFromModel(lsvc, prefit=True)
X_new = model.transform(X)
X_new.shape

基于树模型特征筛选

xgboost和lightgbm等集成学习树模型可以在训练中记录特征的重要性，这些重要性的计算方法主要有三种： ‘weight’ - 特征在所有树上被使用的次数 ‘gain’ - 所有使用该特征的树的平均信息增益 ‘cover’ - 在树上使用该特征时的平均覆盖率以lightgbm为例：

import lightgbm as lgbm
from lightgbm import plot_importance
lgbm_reg = lgbm.LGBMRegressor(objective='regression',max_depth=6,num_leaves=25,learning_rate=0.005,n_estimators=1000,min_child_samples=80, subsample=0.8,colsample_bytree=1,reg_alpha=0,reg_lambda=0)
lgbm_reg.fit(X_train, y_train)
#选择最重要的20个特征，绘制他们的重要性排序图
lgbm.plot_importance(lgbm_reg, max_num_features=20)

##也可以不使用自带的plot_importance函数，手动获取特征重要性和特征名，然后绘图
feature_weight = lgbm_reg.feature_importances_
feature_name = lgbm_reg.feature_name_
feature_sort = pd.Series(data = feature_weight ,index = feature_name)
feature_sort = feature_sort.sort_values(ascending = False)
plt.figure(figsize=(16,6))
sns.barplot(feature_sort.values,feature_sort.index, orient='h')

两个图是一致的。

题目应用

背景题目是预测回归类问题，结合上述特征筛选的基本方法，选择方差过滤结合相关性过滤然后使用包装法中的递归特征消除法RFE筛选出20个特征，使用lightGBM绘制特征重要性

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 23 14:40:01 2021

@author: Flower unbeaten
"""

import numpy as np #数据处理
import matplotlib.pyplot as plt
import pandas as pd #dataFrame,Series等数据结构
plt.rcParams['font.family'] = 'SimHei' #设置绘图的中文显
plt.rcParams['axes.unicode_minus'] = False#matplotlib绘图准备，中文显示等
import seaborn as sns   #导入seaborn绘图库
sns.set_style('darkgrid') #设置seaborn绘图风格为暗色网络
sns.set(font="simhei")#sns遇到标签需要汉字的可以在绘图前加上这句，与plt类似

##import data
feature_path = "../data/Molecular_Descriptor.xlsx"
c50_path = "../data/ERα_activity.xlsx"
admet_path = "../data/ADMET.xlsx"
feature_frame = pd.read_excel(feature_path,sheet_name = 'training', index_col = 'SMILES') #使用pd读取excel，index_col设置为SMILES
feature_test_frame = pd.read_excel(feature_path,sheet_name = 'test', index_col = 'SMILES')
c50_frame = pd.read_excel(c50_path,sheet_name = 'training', index_col = 'SMILES') 
c50_frame.drop(columns='IC50_nM',axis=1,inplace=True) #删掉IC50_nM所在列，inplace为true代表在原来dataframe集成上删除，如果为false则会创建新的dataframe对象并删掉所在列
pic50 = c50_frame['pIC50'] #选中某列，将dataframe转series

##方差筛选
from sklearn.feature_selection import VarianceThreshold
var_selector = VarianceThreshold(threshold = 1)#设置方差过滤阈值为1
var_selector.fit_transform(feature_frame)
is_select = var_selector.get_support()#get_support函数返回方差＞阈值的布尔值序列
var_feature = feature_frame.iloc[:,is_select]#根据布尔值序列取出各个特征所在列

##相关性筛选
from sklearn.feature_selection import mutual_info_regression
mutualInfo = mutual_info_regression(var_feature, pic50, discrete_features= False)
mutualInfo_select = pd.Series(data = mutualInfo , index = var_feature.columns).sort_values(ascending = False)
append_frame = var_feature#先复制dataFrame
append_frame.insert(len(var_feature.columns),pic50.name,pic50.values)#再添加一列
corr = append_frame.corr()
corr_series = pd.Series(data = corr.iloc[-1,:-1])
corr_sort = corr_series.abs().sort_values(ascending = False)
var_feature.drop('pIC50',axis = 1 , inplace = True)
plt.figure(figsize=(16,6))
sns.barplot(mutualInfo_select.values[:40], mutualInfo_select.index[:40], orient='h')
plt.title("基于互信息的相关性筛选")

plt.figure(figsize=(16,6))
sns.barplot(corr_sort.values[:40], corr_sort.index[:40], orient='h')
plt.title("基于相关系数的相关性筛选")

##递归特征消除法
from sklearn.feature_selection import RFE
#ightGBM模型获取特征重要性
import lightgbm as lgbm
from lightgbm import plot_importance
lgbm_reg = lgbm.LGBMRegressor(objective='regression',max_depth=6,num_leaves=25,learning_rate=0.005,n_estimators=1000,min_child_samples=80, subsample=0.8,colsample_bytree=1,reg_alpha=0,reg_lambda=0)
wapper = RFE(estimator=lgbm_reg, n_features_to_select=20)
wapper.fit(var_feature.iloc[:,:-1], var_feature.iloc[:,-1])
is_select = wapper.support_
wapper_feature = var_feature.iloc[:,is_select]#根据布尔值序列取出各个特征所在列

##训练集划分,三七分，随机数状态107
from sklearn.model_selection import train_test_split 
X_train,X_test, y_train, y_test = train_test_split(wapper_feature, pic50,test_size=0.3, random_state=107)

##回归模型评价
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, explained_variance_score
model_index_function = [explained_variance_score, mean_absolute_error, mean_squared_error, r2_score]
def reg_score(regressor,X_test , y_test):
    y_pre = regressor.predict(X_test)
    tmp_list = []
    for func in model_index_function:
        tmp_score = func(y_test, y_pre)
        tmp_list.append(tmp_score)
    model_score = pd.Series(tmp_list) 
    # 画出原始值的曲线
    plt.plot(np.arange(100), y_test.iloc[:100], color='k', label='real')
    # 画出各个模型的预测线
    plt.plot(np.arange(100), y_pre[:100], color='cyan', label='lightgbm')       
    return model_score

lgbm_reg.fit(X_train, y_train)
plt.figure(figsize=(16,6))
model_score = reg_score(lgbm_reg, X_test, y_test)

lgbm.plot_importance(lgbm_reg)
plt.title("lgbm模型特征贡献排序")

##也可以不使用自带的plot_importance函数
feature_weight = lgbm_reg.feature_importances_
feature_name = lgbm_reg.feature_name_
feature_sort = pd.Series(data = feature_weight ,index = feature_name)
feature_sort = feature_sort.sort_values(ascending = False)
plt.figure(figsize=(16,6))
sns.barplot(feature_sort.values,feature_sort.index, orient='h')
plt.title("lgbm模型特征贡献排序")

回归模型的评价指标

回归模型评价指标

RMSE（均方根误差）

MAE（平均绝对误差）

R2（决定系数）

越接近1，表明方程的变量对y的解释能力越强，这个模型对数据拟合的也较好

越接近0，表明模型拟合的越差

经验值：>0.4，拟合效果好

EV(解释方差)

可解释方差指标衡量的是所有预测值和样本之间的差的分散程度与样本本身的分散程度的相近程度。本身是分散程度的对比。最后用1-这个值，最终值越大表示预测和样本值的分散分布程度越相近。

机器学习的分类模型评价方法

Tue, 05 Oct 2021 00:00:00 +0000

分类模型评价方法

评估分类器（分类模型）相对于评估回归器通常要复杂，本篇以MNIST数据集的手写数字识别分类为例，记录常用的分类器评估方法。

交叉验证：Cross-Validation

留一交叉验证：（Leave-One-Out Cross Validation记为LOO-CV）在数据缺乏的情况下使用，如果设原始数据有N个样本，那么LOO-CV就是N-CV，即每个样本单独作为验证集，其余的N-1个样本作为训练集，故LOO-CV会得到N个模型，用这N个模型最终的验证集的分类准确率的平均数作为此下LOO-CV分类器的性能指标。
k折交叉验证：将原始数据分成K组（一般是均分），将每个子集数据分别做一次验证集，其余的K-1组子集数据作为训练集，这样会得到K个模型，用这K个模型最终的验证集的分类准确率的平均数作为此K-CV下分类器的性能指标。K一般大于等于2，实际操作时一般从3开始取，只有在原始数据集合数据量小的时候才会尝试取2。

#K折交叉验证
from sklearn.model_selection import cross_val_score
scores=cross_val_score(log_reg, X_pca_3, y, cv=5, scoring='accuracy')
print(scores)  
print("5折交叉验证平均准确率：",np.mean(scores))

交叉验证的局限在于面对样本分布极不均匀的情况下，例如分类正例反例时，样本中正例数目极多，那么分类正例的成功概率自然会很高，如此得到交叉验证的高准确性可信度较低。

混淆矩阵：Confusion Matrix

考虑最简单的二分类情况，分类出错的可能有FP（假正例，原本是反例，误分类为正例），FN（假反例，原本是正例，误分类为反例）。

from sklearn.metrics import confusion_matrix
def plot_confusion_matrix(clf,name):
    y_pre=clf.predict(X_test)
    confusion=confusion_matrix(y_test,y_pre)
    plt.figure()
    plt.imshow(confusion, cmap=plt.cm.Blues)
    classes = list(set(y_test))
    classes.sort()
    indices = range(len(confusion))
    iters = np.reshape([[[i,j] for j in indices] for i in indices],(confusion.size,2))
    for i, j in iters:
        plt.text(j, i, confusion[i, j])   #显示对应的数字
    plt.title("Confusion matrix of %s "%name,fontsize=12)
    plt.xticks(indices, classes)
    plt.yticks(indices, classes)
    # plt.ylim(len(confusion)-0.5,-0.5)
    plt.xlabel('prediction',fontsize=18)
    plt.ylabel('reality',fontsize=18)
    
plot_confusion_matrix(log_reg,'LogistRegression')`

混淆矩阵沿着主对角线的分布集中度越高，代表模型的分类精度越高。

精确率&召回率（查准率&查全率）：Precision and Recall

\[P = TP/(TP+FP)\]

精确率针对预测结果而言，又称查准率，即预测结果中预测正确的正样本所占总预测次数的比率，该值越大证明预测结果的准确率越高 $R = TP/(TP+FN)$ 召回率针对原有样本而言，又成查全率，即预测模型预测正确的正样本占总的真实样本的比率，该值越大证明预测结果中预测到的正例数相对于样本中实际的正例数越全。所谓召回，可理解为真实的正例数在预测中再次预测出，即被召回。

精确率/召回率权衡：Precision/Recall Tradeoff 精确率与召回率通常无法同时取得比较理想的结果，考虑实际中模型5分类器预测的过程，模型通过训练最终得到一个判断的阈值threshold，高于threshold判断为5，反之为非5，显而易见的时，当高阈值的情况下精确性更高，而低阈值的情况下召回率更高，即分类模型可囊括的真实正实例5的数目越多。

高精确率和高召回率的取舍通常取决于我们需要解决的实际问题，例如我们要训练一个视频分类器，以避免将不好的内容推送给用户时，假如这里的5代表健康的视频，那么我们倾向于模型具有更高的准确性，以保证推送给用户的视频尽可能的健康，尽管这样可能会导致召回率的下降，即将一些原本健康的视频分到问题视频的类别中；在另一种情况下，考虑机场视频监控中可疑扒手识别模型中，假如这里的5代表偷窃行为，那么我们更倾向于模型能够具有更高的召回率，以尽可能地不放过任何一个扒手，尽管这样做可能会导致模型准确性下降，以至于错误警报增多。准确率与召回率的权衡也可能通过绘制以准确率和召回率为坐标轴的图像曲线来看，通常称为PR曲线：通过该图，结合自己的实际情况，可以在确保精确率或者召回率一方达到要求的同时，仅可能选择另一参数更高的阈值，来得到符合期望的模型效果。

此外，当模型的准确率和召回率相近时，可以使用准确率和召回率的调和平均数，通常称为F1得分，来评价模型分数

\[F_{1}=\frac{2}{\frac{1}{\text { precision }}+\frac{1}{\text { recall }}}=2 \times \frac{\text { precision } \times \text { recall }}{\text { precision }+\text { recall }}=\frac{T P}{T P+\frac{F N+F P}{2}}\]

受试者工作特征曲线：receiver operating characteristic (ROC) curve

得此名的原因在于曲线上各点反映着相同的感受性，它们都是对同一信号刺激的反应，只不过是在几种不同的判定标准下所得的结果而已。它与精确率/召回率曲线非常相似，但 ROC 曲线不是绘制精确率与召回率的关系图，而是绘制真阳性率（召回的另一个名称）与假阳性率的关系图。所谓真阳性率即为召回率，而假阳性率(false positive rate)，即真实为阴性的被误认为是阳性的样本占原有样本的比率，它等价于1-真阴性率，真阴性率即真实为阴性且预测为阴性所在预测样本中的比率，真阴性率可以称为以阴性为主的准确率。

\[TPR = TP/(TP+FN)\] \[FPR = FP/(FP+TN) = 1-TNR\] \[TNR = TN/(TN+FP)\]

FPR和TPR曲线同样具有类似准确率和召回率那样的权衡，上图虚线代表随机分类器的结果，一个好的分类器会尽可能的远离该虚线。一种比较分类器好坏的方法是比较ROC曲线下方的面积（Area Under the Curve），面积接近为1的分类器是最为理想的。 ROC曲线和PR曲线是十分类似的，经验法则告诉我们，当样本中阳性例数目较少，或者我们更加关心假阳性（假阳性为小概率）时，选择PR曲线，反之选择ROC曲线。

最后贴一个MNIST数据集使用sgd分类手写数字是否为5的二分类器的训练及评价全流程代码

# -*- coding: utf-8 -*-
"""
Created on Tue Oct  5 19:17:58 2021

@author: Flower unbeaten
"""
import sys
assert sys.version_info >= (3, 5)

#Scikit-Learn ≥0.20 is required
import sklearn
assert sklearn.__version__ >= "0.20"
import numpy as np
import os
np.random.seed(42)

#plot pretty figures
#引入画图库，提前设置好绘图坐标标签大小等参数
import matplotlib as mpl
import matplotlib.pyplot as plt
plt.rcParams['font.family'] = 'SimHei'
plt.rcParams['axes.unicode_minus'] = False#绘图准备
mpl.rc('axes',labelsize=14)
mpl.rc('xtick',labelsize=12)
mpl.rc('ytick',labelsize=12)

#figures save path
#静态变量统一使用大写字母+下划线分割，"."代表当前目录，os.makedirs(“保存路径”,exist_ok)
#exist_ok为true时当文件夹已经存在时不会提示异常，为false时则会
PROJECT_ROOT_DIR = "."
CHAPTER_ID = "classification"
IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR,"images",CHAPTER_ID)
os.makedirs(IMAGES_PATH,exist_ok = True)

#save figure function
def save_fig(fig_id, tight_layout=True, fig_extension="png",resolution=300):
    path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)
    print("Saving figure", fig_id)
    if tight_layout:
        plt.tight_layout()
        plt.savefig(path, format=fig_extension, dpi=resolution)

#import MNIST dataset
from sklearn.datasets import fetch_openml
mnist = fetch_openml('mnist_784',version=1)
mnist.keys()

#overview the data
X, y = mnist["data"] , mnist["target"]
print("X大小为", X.shape)
print("y大小为", y.shape)

#类型转化
#数据类型原本为DataFrame，表头索引对数据进行说明，这里我们仅关注数据本身，
#使用DataFrame、Series的values属性转为array类型
X = X.values
y = y.values

#取一个图片看看
some_digit = X[0]
some_digit_image = some_digit.reshape(28,28)
#cmap指代colormap，指定为二值图
plt.imshow(some_digit_image, cmap=mpl.cm.binary)
plt.axis("off")

#显示第一个数字图片，查看对应的target标签
save_fig("some_digit_plot")
print("对应的标签为", y[0])

y = y.astype(np.uint8)

def plot_digit(data):
    image = data.reshape(28,28)
    plt.imshow(image,cmap = mpl.cm.binary,interpolation="nearest")
    plt.axis("off")
    
#绘制一片数字
def plot_digits(instances,images_per_row=10,**options):
    size = 28
    images_per_row = min(len(instances),images_per_row)
    images = [np.array(instance).reshape(size,size) for instance in instances]
    n_rows = (len(instances)) // images_per_row + 1
    row_images = []
    n_empty = n_rows*images_per_row - len(instances)
    images.append(np.zeros((size,size*n_empty)))
    for row in range(n_rows):
        rimages = images[row*images_per_row : (row+1)*images_per_row]
        row_images.append(np.concatenate(rimages,axis = 1))
    image = np.concatenate(row_images,axis=0)
    plt.imshow(image , cmap = mpl.cm.binary,**options)
    plt.axis("off")
    
plt.figure(figsize=(9,9))
example_images = X[:100]
plot_digits(example_images,images_per_row=10)
save_fig("more_digits_plot")
plt.show()

#数据集划分
#MNIST数据集的训练集已经被随机打乱并划分好，前60000个为训练集，其余为测试集
X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]

#训练一个判断数字是否为5的二分类器
#这里的标签为布尔型，5为true，非5为false
y_train_5 =( y_train == 5)
y_test_5 = (y_test == 5)
y_5 = (y == 5)
#引入SGD分类器模型
from sklearn.linear_model import SGDClassifier
#tol为停止标准，即精度小于tol时停止，max_iter,最大迭代次数，iteration，迭代
sgd_clf = SGDClassifier(max_iter=1000, tol=1e-3, random_state=42)
#使用训练集训练模型
#通常我们想要记录训练花费时间，引入time包，使用time.time()方法记录
import time
tic = time.time()
sgd_clf.fit(X_train, y_train_5)
toc = time.time()
print("SGDClassifier cost",(toc-tic),"s" )

#调用我们训练好的模型来识别之前的some_digit，使用sgd_clf.predict
print("训练完成的模型判断some_digit是否为5的结论是",sgd_clf.predict([some_digit]))

## 分类模型评价
#K折交叉验证
from sklearn.model_selection import cross_val_score
scores=cross_val_score(sgd_clf, X, y_5, cv=3, scoring='accuracy')
print("每折准确率为：", scores)
print("3折交叉验证平均准确率：",np.mean(scores))

#也可以不用模型自带的cross_val_score，自己实现交叉验证的过程
#引入克隆器，用于克隆已经使用某折数据训练过的模型
from sklearn.model_selection import StratifiedKFold
from sklearn.base import clone
#划分3折,创建一个三折数据划分器
skfolds = StratifiedKFold(n_splits =3)
#每一折单独划分训练集与测试集，每次训练得到的模型被克隆得到保存，后边的数据折在前边训练得到的模型基础上继续训练
for train_index , test_index in skfolds.split(X_train, y_train_5):
    #k折划分留一折作为测试集，其余为训练集
    clone_clf = clone(sgd_clf)
    X_train_folds = X_train[train_index]
    y_train_folds = y_train_5[train_index]
    X_test_fold = X_train[test_index]
    y_test_fold = y_train_5[test_index]
    
    #使用训练集折训练模型，对测试集进行预测，将结果与实际测试集targe比对，得到正确数目
    clone_clf.fit(X_train_folds, y_train_folds)
    y_pred = clone_clf.predict(X_test_fold)
    n_correct = sum(y_pred == y_test_fold)
    #计算准确率
    print(n_correct / len(y_pred))
    
#混淆矩阵
from sklearn.metrics import confusion_matrix
#confusion matrix function
def plot_confusion_matrix(clf,name,X_test,y_test):
    y_pre=clf.predict(X_test)
    confusion=confusion_matrix(y_test,y_pre)
    plt.figure()
    plt.imshow(confusion, cmap=plt.cm.Oranges)
    classes = list(set(y_test))
    classes.sort()
    indices = range(len(confusion))
    iters = np.reshape([[[i,j] for j in indices] for i in indices],(confusion.size,2))
    for i, j in iters:
        plt.text(j, i, confusion[i, j])   #显示对应的数字
    plt.title("Confusion matrix of %s "%name,fontsize=12)
    plt.xticks(indices, classes)
    plt.yticks(indices, classes)
    # plt.ylim(len(confusion)-0.5,-0.5)
    plt.xlabel('prediction',fontsize=18)
    plt.ylabel('reality',fontsize=18)
    
plot_confusion_matrix(sgd_clf,'SGDClassifier',X_test,y_test_5)
save_fig("SGDClassifier confusion matrix plot")

# PR(准确率/召回率曲线)
#导入PR计算函数，PR曲线函数
from sklearn.metrics import precision_recall_curve
from sklearn.metrics import precision_score, recall_score
from sklearn.metrics import f1_score
#计算训练集的PR，F1score，这里也可以自己根据公式来计算
y_train_pred = sgd_clf.predict(X_train)
sgd_precision = precision_score(y_train_5, y_train_pred)
sgd_recall = recall_score(y_train_5, y_train_pred)
sgd_f1score = f1_score(y_train_5, y_train_pred)
print("P:",sgd_precision)
print("R:",sgd_recall)
print("F1:",sgd_f1score)

#使用cross_val_predict决策函数返回实例的预测分数，而非预测类别
#该函数也可在生成混淆矩阵时使用，那个时候是预测类别
from sklearn.model_selection import cross_val_predict
y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,
                             method="decision_function")
precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)
#定义PR曲线绘制函数
def plot_precision_vs_recall(precisions, recalls):
    plt.plot(recalls, precisions, "b-", linewidth=2)
    plt.xlabel("Recall", fontsize=16)
    plt.ylabel("Precision", fontsize=16)
    plt.axis([0, 1, 0, 1])
    plt.grid(True)
plt.figure(figsize=(8, 6))
plot_precision_vs_recall(precisions, recalls)
save_fig("precision_vs_recall_plot")
plt.show()

#ROC curves 受试者工作曲线
from sklearn.metrics import roc_curve

fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)

def plot_roc_curve(fpr, tpr, label=None):
    plt.plot(fpr, tpr, linewidth=2, label=label)
    plt.plot([0, 1], [0, 1], 'k--') # dashed diagonal
    plt.axis([0, 1, 0, 1])
    plt.xlabel('False Positive Rate (Fall-Out)', fontsize=16)
    plt.ylabel('True Positive Rate (Recall)', fontsize=16)
    plt.grid(True)                

plt.figure(figsize=(8, 6))
plot_roc_curve(fpr, tpr)
save_fig("roc_curve_plot")
plt.show()

#使用auc（roc曲线下方面积）打分模型
from sklearn.metrics import roc_auc_score

print("auc得分：", roc_auc_score(y_train_5, y_scores))

Numpy

Mon, 04 Oct 2021 00:00:00 +0000

numpy&pandas基础

ndim、shape、dtype、astype的用法

ndim：返回数组维度

shape：返回各个维度大小的元组，类似matlab的size

dtype：（data type）返回数据类型（例如：int32，float32）

astype：类型转化

eg：array.astype(“i”)

小转大，例如int32–>float64，没问题

大转小，例如float–>int32，会将小数部分截断

string_ –>float64 若字符串数组表示的为数字，将把字符串转为数值类型

数组拼接

np.concatenate( ) np.append( )

concatenate：n 连环，v 系、串联

append：附上，附加，增补

两个方法主要区别在于concatenate( )可以连接多个数组，而且多维数组的shape不需要完全相同；append( )只能连接2个，而且多维数组的shape必须相同

两方法同时有可选参数axis

axis=0 按照行拼接。 axis=1 按照列拼接。不写则默认axis=0

a = np.array([1, 2])
b = np.array([5, 6])
c = np.array([3, 4]) 
np.concatenate((a,b,c))
结果：[1 2 5 6 3 4]

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])            #b是一个二维array
np.concatenate((a, b), axis=0)    #按照行拼接
array([[1, 2],
       [3, 4],
       [5, 6]])

np.concatenate((a, b.T), axis=1)  #按照列拼接
array([[1, 2, 5],
       [3, 4, 6]])

注：b.T的意思为b数组的转置

append的意思为附加、增补x行或者x列，仅用于两个矩阵之间

pandas数据结构series和dataFrame

pandas中主要有两种数据结构，分别是：Series和DataFrame。

Series：一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。注意：Series中的索引值是可以重复的。

eg：series创建

可以通过一维数组创建：

arr = np.array([1,3,5,np.NaN,10])
series01 = pd.Series(arr)
#利用arr转化，注意Series大写，一般数据结构封装类首字母都是大写的

也可通过字典的方式创建

dict1 = pd.Series({
'a':10,
'b':20,
'c':30
})
#通过字典的方式创建，key变成了Series的索引，value变成了值

eg：series索引

#索引可以创建series后再手动设置
series02 = pd.Series([1,2,3,4])
series02.index = ['a','b','c','d']
#也可在创建时同步设置
series03 = pd.Series(np.array([1,2,3,4]),dtype = np.float64,index = ['*','**','***','****'])

eg：series值获取

通过[] + 索引的方式读取对应索引的数据，有可能返回多条数据（series的索引可以重复）

通过[] + 下标值的方式读取对应下标值的数据，下标值的取值范围为[0,len(Series.values)]，此外下标值也可以是负数，表示从右往左读取数据

Series的下标值和数组的“索引”才是对应的，而Series的索引更像是给数据value赋予的一个label（标签）

Series获取多个值的方式类似数组，通过[]+下标值/索引值+：的形式来截取对象中一部分数据，通过索引和下标值截取区间是不同的
```
#以series03为例
#通过索引读取：
series03['*':'***']
#通过下标值读取：
series03[0:2]
```

eg：series的运算

#series运算与numpy的array类似
series03[series03>2]
series03[series03/10]
series03[np.exp(series03)]
series03[np.fabs(seres03)]
#fabs是float类型的abs，取绝对值
     
#series运算不会改变索引与value之间的对应关系

series缺失值检测

#所谓缺失值，例如pandas中的NaN，通常由于series创建时，未给索引赋值导致
series04 = pd.Series([10，20，30])
series04.index = ['a','b','c','d']
#这里赋值时有三个，而索引有四个，就会导致NaN的出现
     
#pandas提供了isnull和notnull函数可以用于series中检测缺失值，这两个函数返回一个布尔类型的Series，即索引与原Series一致，value值为布尔值类型
pd.isnull(series04)
pd.notnull(series04)

series自动对齐

#
series05 = pd.Series({
    'num1':10,
    'num2':20,
    'num3':30
})
series06 = pd.Series({
    'num4':10,
    'num2':20,
    'num3':30
})
series05+series06
#相同索引下标会对齐，非公共索引计算会得出NaN
     

series及其索引的name属性

Series对象本身及其索引具有一个name属性，默认为空，根据需要可以赋值

series07 = pd.Series([1,2,3,4],index=['a','b','c','d'])
series07.name = 'Series_name'
series07.index.name = 'Series_indexName'

DataFrame：一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引(index)也有列索引(colum)，可以被看做是由Series组成的字典。

DataFrame的行列表头均为索引

默认索引表头为下标值
```
df01 = pd.DataFrame[['joe','suan','andy'],[70,80,90]]
```
- DataFrame创建
- DataFrame索引
  
  DataFrame分为行索引和列索引，默认情况下是从0开始，也可以自定义索引，添加行索引使用 index ，添加列索引使用 columns ，此操作称“重置行列索引值”
- pandas中的loc-iloc-ix的使用
  
  iloc是基于“位置”的dataFrame操作，i为下标值的意思，loc为location的缩写
```
    # 使用DataFrame 和 iloc 进行单行/列的选择
    # 行选择：
    data.iloc[0] # 数据中的第一行
    data.iloc[1] # 数据中的第二行
    data.iloc[-1] # 数据中的最后一行
         
    # 列选择：
    data.iloc[:, 0] # 数据中的第一列
    data.iloc[:, 1] # 数据中的第二列
    data.iloc[:, -1] # 数据中的最后一列 
```
  使用iloc注意：
  1. iloc只选择单独一行会返回series类型，选择多行会返回DataFrame类型
  2. 使用[1:5]这种语法进行数据切片时，满足左闭右开原则，仅包含下标1，2，3，4
  loc则针对索引，DataFrame的表头来取值，同时可以使用布尔值/带条件查找
  
  ix是早期pandas版本，现已经抛弃（2021）
- DataFrame获取数据及其CRUD
可以直接通过列索引来获取指定列，但是获取指定行需要iloc或者loc

DataFrame详解

np.c_和np.r_

np.r_是按行连接两个矩阵，就是把两矩阵上下合并，要求列数相等。

np.c_是按列连接两个矩阵，就是把两矩阵左右合并，要求行数相等。

类似有vstack，hstack方法，对两个数组“拼接”

a=np.floor(10*np.random.random((2,2)))
b=np.floor(10*np.random.random((2,2)))
print(a),print(b)
print(np.vstack((a,b))) #vstack将数组a,b竖直拼接vertical
print(np.hstack((a,b))) #hstack将数组a,b水平拼接horizontal

vsplit，hsplit方法，对数组“切分”

a=np.floor(10*np.random.random((2,12)))
print(a)
print(np.hsplit(a,3))  #hsplit将数组a在水平方向切分成3等分

a1=np.floor(10*np.random.random((2,12)))
print(a1)
print(np.hsplit(a1,(3,4)))  #hsplit将数组a在水平方向切分,从列索引3前切，到列索引4前停止

b=np.floor(10*np.random.random((12,2)))
print(b)
print(np.vsplit(b,3))  #vsplit将数组b在竖直方向切分成3等分

数组矩阵运算

矩阵A、B

A*B#对应元素乘积

A.dot(B)#使用dot矩阵乘积

数组整体函数操作

np.exp(B)#对数组B取e指数

np.sqrt(B)#取平方根

rabel方法，将数组维度拉成一维数组

a=np.floor(10*np.random.random((3,4)));print(a) [[1. 7. 8. 5.] [2. 4. 8. 4.] [7. 9. 1. 3.]]

print(a.ravel()) #ravel矩阵按行拉成一维数组 [1. 7. 8. 5. 2. 4. 8. 4. 7. 9. 1. 3.]

数组赋值后指向：直接赋值，浅复制，深复制

Python中复制、深拷贝和浅拷贝的区别

a=np.arange(12)
b=a
print(b is a)   #赋值后，b和a指向同一个内存地址
b.shape=3,4
print('b维度变成(3,4)后a的维度：',a.shape)
print('a的id:',id(a));print('b的id:',id(b))  #取a,b在内存里的id
print('_________________________________')

c=a.view()   #c是对a的浅复制，两个数组不同，但数据共享
print(c is a)
c.shape=2,6
print(a.shape); #c的形态变量，a的形态没变
print('对c赋值前的a:\n',a);
c[0,4]=1234;print('c:\n',c);print('对c赋值后的a:\n',a)  #c的[0,4]位置数据改变，a也改变
print('_________________________________')

d=a.copy()   #d是对a的深复制，两个数组不同，数据也不共享
print(d is a)
d[0,0]=9999
print('d:\n',d);print('a:\n',a)
print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')


##在数组中找最大值的位置
import numpy as np
data=np.sin(np.arange(20)).reshape(5,4)
print('初始数据：\n',data)
index=data.argmax(axis=0)  #argmax找每列的最大值位置
print('每一列最大值的索引:',index)
data_max=data[index,range(data.shape[1])] #根据索引index找出data数组里的元素!!!
print('根据索引找出最大值：',data_max)
print('直接办法取最大值：',data.max(axis=0)) #array.max(axis=0)
print('检测两种办法取到的max是否一致：',all(data_max==data.max(axis=0)))
print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')

##对数组中元素“排序”
print('(1.)sort方法作用类np上<对象参数a不变，生成数组新开辟空间给b>:')
a=np.array([[4,3,5],[1,2,1]])
print('np.sort对a进行行排序前的a:\n',a)
b=np.sort(a,axis=1)  #sort对数组a里的元素按行排序
print('对a进行行排序后的b:\n',b)
print('np.sort对a进行行排序后的a:\n',a)
print('a的id:',id(a));print('b的id:',id(b))

print('(2.)sort方法作用对象a上,a被改变：')
a.sort(axis=1)
print(a)
print('a的id:',id(a))
print('_________________________________')
#返回最大值的索引
aa=np.array([0.4,0.3,0.1,0.2])
print('初始aa数组：',aa)
j=np.argsort(aa)
print('对aa元素排序后的索引位置：',j)
print('根据索引的排序对aa重排：',aa[j])
print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')

##对数组进行复制
a=np.arange(0,40,10)
print(a)
b=np.tile(a,(4,1)) #tile对a进行4行1列的复制
print(b)

Windows环境下Jekyll开发环境及部署建站指南

Wed, 01 Sep 2021 00:00:00 +0000

@[TOC]

Jekyll环境配置

Jekyll基于Ruby语言编写，需配置Ruby环境，参考：

在Windows上安装Jekyll

Jekyll模板移植

参考B站这个Up

模板站链接

进入项目路径下启动jekyll服务器：

jekyll server

jekyll 4以上启动命令修改为：

bundle exec jekyll serve --trace

遇到的坑

cannot load such file – webrick (LoadError) 原因是从 Ruby 3.0 开始 webrick 已经不在绑定到 Ruby 中了手动添加进：

bundle add webrick

依赖问题上边提到的bundle类似是依赖管理下载所有依赖;

bundle install

会自动生成Gemfile依赖：

Vue（二）生命周期、侦听器、动态组件、Prop参数承接

Fri, 13 Aug 2021 00:00:00 +0000

@[toc]

v-on绑定事件调用方法

<div id="app-5">
  <p></p>
  <button v-on:click="reverseMessage">反转消息</button>//绑定方法reverseMessage
</div>

reverseMessage方法在Vue实例中定义：

var app5 = new Vue({
  el: '#app-5',
  data: {
    message: 'Hello Vue.js!'
  },
  methods: {
    reverseMessage: function () {
      this.message = this.message.split('').reverse().join('')//方法实体，先单个分开成单字符（split）再翻转（reverse），再合并（join）
    }
  }
})

组件化应用构建

在 Vue 里，一个组件本质上是一个拥有预定义选项的一个 Vue 实例。在 Vue 中注册组件很简单：

// 定义名为 todo-item 的新组件
Vue.component('todo-item', {
  template: '<li>这是个待办项</li>'//模板是列表形式
})

var app = new Vue({
    el: '#app'
})

用它构建另一个组件模板，让他成为无序列表中的一项

<ol>
  <!-- 创建一个 todo-item 组件的实例 -->
  <todo-item id= "app"></todo-item>
</ol>

但是这样会为每个待办项渲染同样的文本，这看起来并不炫酷。我们应该能从父作用域将数据传到子组件才对。让我们来修改一下组件的定义，使之能够接受一个 prop：

Vue.component('todo-item', {
  // todo-item 组件现在接受一个
  // "prop"，类似于一个自定义 attribute。
  // 这个 prop 名为 todo。
  props: ['todo'],
  template: '<li></li>'//这里的todo.text表明了todo是一个对象，具体见下边的Vue实例
})

使用 v-bind 指令将待办项传到循环输出的每个组件中：

<div id="app-7">
  <ol>
    <!--
      现在我们为每个 todo-item 提供 todo 对象
      todo 对象是变量，即其内容可以是动态的。
      我们也需要为每个组件提供一个“key”，稍后再
      作详细解释。
    -->
    <todo-item
      v-for="item in groceryList"    
      v-bind:todo="item"
      v-bind:key="item.id"
    ></todo-item> <!--遍历groceryList，绑定列表的每一项（item）和列表的索引（id）-->
  </ol>
</div>

Vue.component('todo-item', {
  props: ['todo'],
  template: '<li></li>'
})

var app7 = new Vue({
  el: '#app-7',
  data: {
    groceryList: [
      { id: 0, text: '蔬菜' },
      { id: 1, text: '奶酪' },
      { id: 2, text: '随便其它什么人吃的东西' }
    ]
  }
})

前端显示数据非响应式

vue的数据property都是响应式的，即修改后前端显示会同步相应修改，使用 Object.freeze()，这会阻止修改现有的 property，也意味着响应系统无法再追踪变化。

实例生命周期

下图展示了实例的生命周期：生命周期钩子的 this 上下文指向调用它的 Vue 实例，这里先介绍几个常用的钩子：

created ：组件被创建后
mounted：组件被渲染后
updated ：组件更新后
destroye：组件销毁后

计算属性和侦听器

模板内的表达式非常便利，但是设计它们的初衷是用于简单运算的。在模板中放入太多的逻辑会让模板过重且难以维护。例如：

<div id="example">
  
</div>

在这个地方，模板不再是简单的声明式逻辑。你必须看一段时间才能意识到，这里是想要显示变量 message 的翻转字符串。当你想要在模板中的多处包含此翻转字符串时，就会更加难以处理。所以，对于任何复杂逻辑，你都应当使用计算属性。

<div id="example">
  <p>Original message: ""</p>
  <p>Computed reversed message: ""</p>
</div>

var vm = new Vue({
  el: '#example',
  data: {
    message: 'Hello'
  },
  computed: {
    // 计算属性的 getter
    reversedMessage: function () {
      // `this` 指向 vm 实例
      return this.message.split('').reverse().join('')
    }
  }
})

计算属性缓存 vs 方法：

我们可以通过在表达式中调用方法来达到同样的效果不同的是计算属性是基于它们的响应式依赖进行缓存的。只在相关响应式依赖发生改变时它们才会重新求值。这就意味着只要 message 还没有发生改变，多次访问 reversedMessage 计算属性会立即返回之前的计算结果，而不必再次执行函数。这一点可以用时间戳来说明，加入计算属性中使用事件戳，第一次用和第二次用，时间戳是相同的，因为计算结果已经在缓存中，仅当缓存更新时，计算属性值才会更新。而假如表达式中两次使用时间戳，则结果是不同的。

计算属性 vs 侦听属性：

Vue 提供了一种更通用的方式来观察和响应 Vue 实例上的数据变动：侦听属性。当你有一些数据需要随着其它数据变动而变动时，你很容易滥用 watch——特别是如果你之前使用过 AngularJS。然而，通常更好的做法是使用计算属性而不是命令式的 watch 回调。

<div id="demo"></div>

var vm = new Vue({
  el: '#demo',
  data: {
    firstName: 'Foo',
    lastName: 'Bar',
    fullName: 'Foo Bar'
  },
  watch: {
    firstName: function (val) {
      this.fullName = val + ' ' + this.lastName
    },
    lastName: function (val) {
      this.fullName = this.firstName + ' ' + val
    }
  }
})

var vm = new Vue({
  el: '#demo',
  data: {
    firstName: 'Foo',
    lastName: 'Bar'
  },
  computed: {
    fullName: function () {
      return this.firstName + ' ' + this.lastName
    }
  }
})

侦听器（*）

<div id="watch-example">
  <p>
    Ask a yes/no question:
    <input v-model="question">
  </p>
  <p></p>
</div>

<!-- 因为 AJAX 库和通用工具的生态已经相当丰富，Vue 核心代码没有重复 -->
<!-- 提供这些功能以保持精简。这也可以让你自由选择自己更熟悉的工具。 -->
<script src="https://cdn.jsdelivr.net/npm/axios@0.12.0/dist/axios.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/lodash@4.13.1/lodash.min.js"></script>
<script>
var watchExampleVM = new Vue({
  el: '#watch-example',
  data: {
    question: '',
    answer: 'I cannot give you an answer until you ask a question!'
  },
  watch: {
    // 如果 `question` 发生改变，这个函数就会运行
    question: function (newQuestion, oldQuestion) {
      this.answer = 'Waiting for you to stop typing...'
      this.debouncedGetAnswer()
    }
  },
  created: function () {
    // `_.debounce` 是一个通过 Lodash 限制操作频率的函数。
    // 在这个例子中，我们希望限制访问 yesno.wtf/api 的频率
    // AJAX 请求直到用户输入完毕才会发出。想要了解更多关于
    // `_.debounce` 函数 (及其近亲 `_.throttle`) 的知识，
    // 请参考：https://lodash.com/docs#debounce
    this.debouncedGetAnswer = _.debounce(this.getAnswer, 500)
  },
  methods: {
    getAnswer: function () {
      if (this.question.indexOf('?') === -1) {
        this.answer = 'Questions usually contain a question mark. ;-)'
        return
      }
      this.answer = 'Thinking...'
      var vm = this
      axios.get('https://yesno.wtf/api')
        .then(function (response) {
          vm.answer = _.capitalize(response.data.answer)
        })
        .catch(function (error) {
          vm.answer = 'Error! Could not reach the API. ' + error
        })
    }
  }
})
</script>

事件处理方法

除了直接绑定到一个方法，还可以在内联 JavaScript 语句中调用方法：

<div id="example-3">
  <button v-on:click="say('hi')">Say hi</button>
  <button v-on:click="say('what')">Say what</button>
</div>
<!--注意这里click直接是调用的方法-->

new Vue({
  el: '#example-3',
  methods: {
    say: function (message) {
      alert(message)
    }
  }
})

有时也需要在内联语句处理器中访问原始的 DOM 事件。可以用特殊变量 $event 把它传入方法：

<button v-on:click="warn('Form cannot be submitted yet.', $event)">
  Submit
</button>

// ...
methods: {
  warn: function functionName (message, event) {
    // 现在我们可以访问原生事件对象
    if (event) {
      event.preventDefault()
    }
    alert(message)
  }
}

事件修饰符

在事件处理程序中调用 event.preventDefault() 或 event.stopPropagation() 是非常常见的需求。尽管我们可以在方法中轻松实现这点，但更好的方式是：方法只有纯粹的数据逻辑，而不是去处理 DOM 事件细节。

为了解决这个问题，Vue.js 为 v-on 提供了事件修饰符。之前提过，修饰符是由点开头的指令后缀来表示的。

.stop
.prevent
.capture
.self
.once
.passive ```html <!-- 阻止单击事件继续传播 --> <a v-on:click.stop="doThis"></a>

...

使用修饰符时，顺序很重要；相应的代码会以同样的顺序产生。因此，用 v-on:click.prevent.self 会阻止所有的点击，而 v-on:click.self.prevent 只会阻止对元素自身的点击。

# 通过 Prop 向子组件传递数据
当组件变得越来越复杂的时候，.比如一篇博客，我们的博文不只需要标题和内容，还需要发布日期、评论等等。为每个相关的信息定义一个 prop 会变得很麻烦：

```html
<blog-post
  v-for="post in posts"
  v-bind:key="post.id"
  v-bind:title="post.title"
  v-bind:content="post.content"
  v-bind:publishedAt="post.publishedAt"
  v-bind:comments="post.comments"
></blog-post>

所以是时候重构一下这个组件了，让它变成接受一个单独的 post prop：

<blog-post
  v-for="post in posts"
  v-bind:key="post.id"
  v-bind:post="post"
></blog-post>

Vue.component('blog-post', {
  props: ['post'],
  template: `
    <div class="blog-post">
      <h3></h3>
      <div v-html="post.content"></div>
    </div>
  `
})

现在，不论何时为 post 对象添加一个新的 property，它都会自动地在内可用。值得注意的一点是v-html指令，它表示以html语句解析post.content的内容，相应的有v-text指令，同一个字符串`“<h1>这是一个h1元素内容</h1>”`

使用v-html会解析出一号标题，显示内容“这是一个h1元素内容”
使用v-text则直接会显示字符串本身“<h1>这是一个h1元素内容</h1>”

监听子组件事件

在我们开发组件时，它的一些功能可能要求我们和父级组件进行沟通。例如我们可能会引入一个辅助功能来放大博文的字号，同时让页面的其它部分保持默认的字号。在其父组件中，我们可以通过添加一个 postFontSize 数据 property 来支持这个功能：

<div id="blog-posts-events-demo">
  <div :style="{ fontSize: postFontSize + 'em' }">
    <blog-post
            v-for="post in posts"
            v-bind:key="post.id"
            v-bind:post="post"
            v-on:enlarge-text="postFontSize += 0.1"
    ></blog-post>
  </div>
</div>
<!--父级元素blog-posts-events-demo，使用了自定义组件blog-post，组件blog-post内定义有子组件button，有了这个 v-on:enlarge-text="postFontSize += 0.1" 监听器，父级组件就会接收该事件并更新 postFontSize 的值。子组件中通过调用内建的 $emit 方法并传入事件名称来触发-->

Vue.component('blog-post', {
    props: ['post'],
    template: `
    <div class="blog-post">
      <h3></h3>
      <button v-on:click="$emit('enlarge-text')">//子组件可以通过调用内建的 $emit 方法并传入事件名称来触发一个事件
        Enlarge text
      </button>
      <div v-html="post.content"></div>
    </div>
  `
  })
    new Vue({
    el: '#blog-posts-events-demo',
    data: {
      posts:  [
        { id: 1, title: 'My journey with Vue' },
        { id: 2, title: 'Blogging with Vue' },
        { id: 3, title: 'Why Vue is so fun' }
      ],
      postFontSize: 1//字体大小赋初值
    }
  })

总结：自定义父组件中使用v-on绑定事件v-on:enlarge-text=”postFontSize += 0.1”，事件定义中监听数据postFontSize，子组件button的click触发$emit（”enlarge-text）

使用事件抛出一个值

有的时候用一个事件来抛出一个特定的值是非常有用的。例如我们可能想让组件决定它的文本要放大多少。这时可以使用 $emit 的第二个参数来提供这个值：

<button v-on:click="$emit('enlarge-text', 0.1)">
  Enlarge text
</button>

然后当在父级组件监听这个事件的时候，我们可以通过 $event 访问到被抛出的这个值：

<blog-post
  ...
  v-on:enlarge-text="postFontSize += $event"
></blog-post>

总结：自定义父组件中使用v-on绑定事件v-on:enlarge-text=”postFontSize += $ event”，事件定义中监听数据postFontSize，子组件button的click触发$ emit（”enlarge-text，0.1），指定事件，以及参数，父组件中$ event接收参数。或者，如果这个事件处理函数是一个方法：

<blog-post
  ...
  v-on:enlarge-text="onEnlargeText"
></blog-post>

那么这个值将会作为第一个参数传入这个方法：

methods: {
  onEnlargeText: function (enlargeAmount) {
    this.postFontSize += enlargeAmount
  }
}

在组件上使用v-model（*）

自定义事件也可以用于创建支持 v-model 的自定义输入组件。

<input v-model="searchText">

等价于：

<input
  v-bind:value="searchText"
  v-on:input="searchText = $event.target.value"
>

动态组件

有的时候，在不同组件之间进行动态切换是非常有用的，比如在一个多标签的界面里：上述内容可以通过 Vue 的元素加一个特殊的 is attribute 来实现：

<!-- 组件会在 `currentTabComponent` 改变时改变 -->
<component v-bind:is="currentTabComponent"></component>

在上述示例中，currentTabComponent 可以包括：已注册组件的名字，或一个组件的选项对象动态组件深层应用以后再说，下边是实现tab切换页面的源码，有注释！

<!DOCTYPE html>
<html>
<head>
  <title>Dynamic Components Example</title>
  <script src="https://unpkg.com/vue"></script>
  <style>
    .tab-button {
      padding: 6px 10px;
      border-top-left-radius: 3px;
      border-top-right-radius: 3px;
      border: 1px solid #ccc;
      cursor: pointer;
      /*cursor：pointer 当鼠标悬空在该元素时会显示一个点击的小手*/
      background: #f0f0f0;
      margin-bottom: -1px;
      margin-right: -1px;
    }
    .tab-button:hover {
      background: #e0e0e0;
    }
    .tab-button.active {
      background: red;
    /*  当选中时，按钮的背景色*/
    }
    .tab {
      border: 1px solid #268fd5;
      /*边框的颜色*/
      padding: 10px;
    }
  </style>
</head>
<body>
<div id="dynamic-component-demo" class="demo">
  <button
          v-for="tab in tabs"
          v-bind:key="tab"
          v-bind:class="['tab-button', { active: currentTab === tab }]"
          v-on:click="currentTab = tab"
  >
<!--对tabs遍历，仅当遍历到currentTab时，active为1，active是激活属性，
激活后的渲染为.tab-button.active，在原来基础上.activev-on绑定currentTab为当前点击的元素的tab-->
    
<!--这里取出元素的tab，显示在按钮上-->
  </button>
<!--至此完成上方的按钮切换-->
  <component v-bind:is="currentTabComponent" class="tab"></component>
<!--用is动态绑定currentTabComponent方法-->
</div>

<script>
  Vue.component("tab-home", {
    template: "<div>Home component</div>"
  });
  Vue.component("tab-posts", {
    template: "<div>Posts component</div>"
  });
  Vue.component("tab-archive", {
    template: "<div>Archive component</div>"
  });
  Vue.component("tab-add", {
    template: "<div>add</div>"
  });
  //定义选项子组件
  new Vue({
    el: "#dynamic-component-demo",
    data: {
      currentTab: "Home",
      tabs: ["Home", "Posts", "Archive","add"]
    },
    computed: {
      currentTabComponent: function() {
        return "tab-" + this.currentTab.toLowerCase();
      }
    }
  });
//  定义父组件，值得注意的是计算属性中，定义了currentTabComponent方法，用于切换动态组件，实际是
//  返回了要切换的组件名，tab-+currentTab,.toLowerCase()是转化为小写的意思
</script>
</body>
</html>

组件注册

W3C 规范中的自定义组件名 (字母全小写且必须包含一个连字符)。这会帮助你避免和当前以及未来的 HTML 元素相冲突。例如：

Vue.component('my-component-name', { /* ... */ })

全局注册与局部注册

用 Vue.component 来创建组件都是全局注册的，也就是说它们在注册之后可以用在任何新创建的 Vue 根实例 (new Vue) 的模板中。局部注册的方法：通过一个普通的 JavaScript 对象来定义组件：

var ComponentA = { /* ... */ }
var ComponentB = { /* ... */ }
var ComponentC = { /* ... */ }

然后在 components 选项中定义你想要使用的组件：

new Vue({
  el: '#app',
  components: {
    'component-a': ComponentA,
    'component-b': ComponentB
  }
})

对于 components 对象中的每个 property 来说，其 property 名就是自定义元素的名字，其 property 值就是这个组件的选项对象。 局部注册的组件在其子组件中不可用。 在模块系统中局部注册：

import ComponentA from './ComponentA'
import ComponentC from './ComponentC'

export default {
  components: {
    ComponentA,
    ComponentC
  },
  // ...
}

这样 ComponentA 和 ComponentC 都可以在 ComponentB 的模板中使用。总结：1、import组件 2、export的components中声明组件

prop

## prop的大小写（*） HTML 中的 attribute 名是大小写不敏感的，所以浏览器会把所有大写字符解释为小写字符。这意味着当你使用 DOM 中的模板时，camelCase (驼峰命名法) 的 prop 名需要使用其等价的 kebab-case (短横线分隔命名) 命名：

Vue.component('blog-post', {
  // 在 JavaScript 中是 camelCase 的
  props: ['postTitle'],
  template: '<h3></h3>'
})

<!-- 在 HTML 中是 kebab-case 的 -->
<blog-post post-title="hello!"></blog-post>

prop的类型

通常你希望每个 prop 都有指定的值类型。这时，你可以以对象形式列出 prop，这些 property 的名称和值分别是 prop 各自的名称和类型：

props: {
  title: String,
  likes: Number,
  isPublished: Boolean,
  commentIds: Array,
  author: Object,
  callback: Function,
  contactsPromise: Promise // or any other constructor
}

这不仅为你的组件提供了文档，还会在它们遇到错误的类型时从浏览器的 JavaScript 控制台提示用户。

传递静态或动态 Prop

<blog-post title="My journey with Vue"></blog-post>

<!-- 动态赋予一个变量的值 -->
<blog-post v-bind:title="post.title"></blog-post>

<!-- 动态赋予一个复杂表达式的值 -->
<blog-post
  v-bind:title="post.title + ' by ' + post.author.name"
></blog-post>

element-ui+vue快速创建组件

以创建跑马灯图片横幅为例：新建pmd.Vue文件，在网上找到组件设置的代码粘贴进去：

<template>
  <el-carousel :interval="4000" type="card" height="100px">
    <el-carousel-item v-for="item in imagebox" :key="item.id">
      <img :src="item.idView" class="image">
    </el-carousel-item>
  </el-carousel>
</template>

<script>
export default{
  name: 'pmd',
  data () {
    return {
      imagebox: [{id: 0, idView: require('../../assets/img/band1.png')},
      {id: 1, idView: require('../../assets/img/band2.png')},
      {id: 2, idView: require('../../assets/img/band3.png')},
      {id: 3, idView: require('../../assets/img/band4.png')},
      {id: 4, idView: require('../../assets/img/band5.png')},
      {id: 5, idView: require('../../assets/img/band6.png')}
        // imagebox是assets下一个放图片的文件夹
      ]
    }
  }
}
</script>

<style>
.el-carousel__item h3 {
  color: #475669;
  font-size: 14px;
  opacity: 0.75;
  line-height: 200px;
  margin: 20px 1px 1px 1px;
}

.el-carousel__item:nth-child(2n) {
  background-color: #99a9bf;
  margin: 5px 1px 1px 1px;
}

.el-carousel__item:nth-child(2n+1) {
  background-color: #d3dce6;
  margin: 5px 1px 1px 1px;
}

.image{
/*设置图片宽度和浏览器宽度一致*/
  width:100%;
  height:inherit;
}
</style>

我想要把这个跑马灯组件用到我的登录界面login.Vue，因此在login. vue的JS中导入这个pmd.vue：然后就可以在login的视图层html中直接用这个组件：效果;