Android的布局XML中app：srcCompat和android：src之间的区别

这里用tools:srcCompat不能显示矢量图。

遇到的问题

2020-01-31 13:59:14.564 13074-13074/com.example.note E/SpiderMan: java.lang.NullPointerException: Attempt to invoke virtual method ‘android.os.IBinder android.view.View.getWindowToken()’ on a null object reference at com.example.note.NoteNewActivity.closeSoftKeyInput(NoteNewActivity.java:224)

2020-01-31 14:25:00.270 14531-14538/? E/om.example.not: Failed to send jdwp-handshake response.: Broken pipe
2020-01-31 14:25:00.694 14531-14531/? E/SpiderMan: java.lang.NullPointerException: Attempt to invoke interface method ‘int java.lang.CharSequence.length()’ on a null object reference
at java.util.regex.Matcher.reset(Matcher.java:1059)

sqlite无法查看表内容

缺少“；”
select * from word；

在CoordinatorLayout的时候，上面的布局挡住下面的布局

在CoordinatorLayout的时候，上面的布局挡住下面的布局，只需要在下面的布局当中加入这个属性即可：

app:layout_behavior=”@string/appbar_scrolling_view_behavior”

Android EditText输入光标居于开头最开始位置

如果欲使EditText加载后的输入光标自动处于最开始处，可以通过设置EditText的android:gravity实现，设置android:gravity为left或者start即可，可以设置：

android:gravity=”start”

或者：

android:gravity=”left”

Android-获取屏幕宽高

Android-删除部分ImageSpan时删除整个ImageSpan？

Android Editable与String的区别

转载一颗西瓜 最后发布于2017-12-29 13:11:51 阅读数 232 收藏
展开
Editable 是一个接口类型，对它的实例化对象作出任何改变都是对原有的实例化对象操作的，内存地址还是原来的那个。
而对 String 的任何改变都是相当于重新实例化了一个 String 类出来，相当于重新分配了内存地址。
所以说 Editable 是可变的，String 是不可变的了；因为 Editable 变了之后还是原来的 Editable 对象，String 变了之后就已经不是原来的 String 对象了。

getText()和getEditableText()使用比较

（1）getText()和getEditableText()这两个方法是定义在android.widget.TextView控件中的，在默认情况下TextView是不可编辑的，getText().toString()能获得控件中的内容，而getEditableText()返回的值为null。

（2）android.widget.EditText继承自TextView，它只稍微重写了TextView中的getText()方法，。在EditText中使用getText().toString() 和getEditableText().toString()效果是一样的

详解android:scaleType属性

转载encienqi 最后发布于2012-08-27 18:03:11 阅读数 95723 收藏

android:scaleType是控制图片如何resized/moved来匹对ImageView的size。
ImageView.ScaleType / android:scaleType值的意义区别：
CENTER /center 按图片的原来size居中显示，当图片长/宽超过View的长/宽，则截取图片的居中部分显示
CENTER_CROP / centerCrop 按比例扩大图片的size居中显示，使得图片长(宽)等于或大于View的长(宽)
CENTER_INSIDE / centerInside 将图片的内容完整居中显示，通过按比例缩小或原来的size使得图片长/宽等于或小于View的长/宽
FIT_CENTER / fitCenter 把图片按比例扩大/缩小到View的宽度，居中显示
FIT_END / fitEnd 把图片按比例扩大/缩小到View的宽度，显示在View的下部分位置
FIT_START / fitStart 把图片按比例扩大/缩小到View的宽度，显示在View的上部分位置
FIT_XY / fitXY 把图片不按比例扩大/缩小到View的大小显示
MATRIX / matrix 用矩阵来绘制，动态缩小放大图片来显示。
** 要注意一点，Drawable文件夹里面的图片命名是不能大写的

android:scaleType=”centerCrop”

以填满整个ImageView为目的，将原图的中心对准ImageView的中心，等比例放大原图，直到填满ImageView为止（指的是ImageView的宽和高都要填满），原图超过ImageView的部分作裁剪处理。

android:scaleType=”fitXY”

把原图按照指定的大小在View中显示，拉伸显示图片，不保持原比例，填满ImageView.

编译’com.zhihu.android:matisse:$latest_version’

$latest_version要替换成具体版本号

Android获取不到Dialog自定义布局中的控件

想要获取自定义布局中的控件必须调用你所定义的View的findViewById方法，而不能像获得其他控件一样直接调用findViewById方法。。。。”

final View layout = inflater.inflate(R.layout.send_email_dialog,
                (ViewGroup) findViewById(R.id.send_email_dialog_ll));
final EditText sendEmailCon_ET = (EditText) layout.findViewById(R.id.send_email_dialog_et);

getExternalFilesDir(Environment.DIRECTORY_RINGTONES)

返回的字段后面不包括斜杆，如果要拼接路径，需要手动加上。

mIat.setParameter(SpeechConstant.ASR_AUDIO_PATH,context.getExternalFilesDir(Environment.DIRECTORY_RINGTONES) + "/" + fileName);

TextView和clickablespan和scrollview

setMovementMethod(LinkMovementMethod.getInstance())，让超链接起作用。顺便提下，TextView的setMovementMethod()和setIsSelectable()方法都可以让TextView支持内容滚动。

Android TextView设置ClickableSpan 点击结尾空白位置也响应点击的问题

解决方法有两个：1：给textview的宽设置warp_content

2:如果需要使用0dp加weight的形式，可以给textview设置text 的时候在末尾加一个空格\u3000字符

1 TextView设置了ClickableSpan，TextView宽度为match_parent时，会产生如下问题：
第一个问题如果设置的Span文本没有填满match_parent，此时点击空白处也会执行clickableSpan的click函数；
第二个问题是如果添加的文本超过了match_parent,此时点击TextView中没有添加ClickableSpan的文本，click事件会被拦截。

第一个问题如何解决：在SpannableString的结尾添加 spannable.append(“\u200b”);

另外一种办法: 我管理通过延伸LinkMovementMethod来解决它，并检查是否触摸事件 fset等于或大于文本长度：

public class MovementMethod extends LinkMovementMethod { 
    @Override 
    public boolean onTouchEvent(TextView widget, Spannable buffer, MotionEvent event) { 
     int action = event.getAction(); 
     if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_DOWN) { 
      int x = (int) event.getX(); 
      int y = (int) event.getY(); 
      x -= widget.getTotalPaddingLeft(); 
      y -= widget.getTotalPaddingTop(); 
      x += widget.getScrollX(); 
      y += widget.getScrollY(); 
      Layout layout = widget.getLayout(); 
      int line = layout.getLineForVertical(y); 
      int off = layout.getOffsetForHorizontal(line, x); 
      if (off >= widget.getText().length()) { 
       // Return true so click won't be triggered in the leftover empty space 
       return true; 
      } 
     } 
     return super.onTouchEvent(widget, buffer, event); 
    } 
}

有一点需要注意，因为我需要重写静态getInstance（）函数，否则您仍然会返回基础LinkMovementMethod的实例.

第二个问题解决办法：
设置了ClickableSpan需要添加setMovementMethod(LinkMovementMethod.getInstance());才能失败click事件，重写setMovementMethod用到的对象。
TextView富文本学习三-设置了ClickableSpan后与TextView click事件冲突

Android 设置TextView滑动滚动条和滑动效果

1、单独的TextView控件设置滚动条（滑动不流畅）

实际上这个自带点击的滑动效果贼垃圾，一碰就触发点击了，根本不滑。容易与clickablespan点击事件冲突。

<TextView
               android:id="@+id/content"
               android:layout_width="fill_parent"
               android:layout_height="wrap_content"
               android:text="file content is empty!"
               android:scrollbars="vertical"
               android:fadeScrollbars="false"/>

在activity中为这个TextView设置：

mFileContentView = (TextView) findViewById(R.id.content);
 mFileContentView.setMovementMethod(ScrollingMovementMethod.getInstance());

经过上面两个步骤，TextView就可以上下滚动了，如果想自定义滚动条，接着在xml里面加入属性：

android:scrollbarThumbVertical=”@drawable/ic_launcher” //滑块的图片
android:scrollbarTrackVertical=”@drawable/ic_launcher” //滑道的图片

ScrollBar由两部分组成，一个是Track（滑道），一个是Thumb(滑块)

2、也可以用ScrollView（滑动流畅）

<ScrollView
           android:layout_width="fill_parent"
           android:layout_height="wrap_content"
           android:scrollbars="vertical"
           android:fadingEdge="vertical">
       <TextView
               android:id="@+id/content"
               android:layout_width="fill_parent"
               android:layout_height="wrap_content"
               android:text="file content is empty!"/>
   </ScrollView>

解决ListView里TextView设置LinkMovementMethod后导致其ItemClick失效的问题

上述源码为LinkMovementMethod类的第188行。发现了Item点击失效的原因是因为onTouch方法总是返回true而并没有根据不同的情况来作处理，此时大家可能会想直接对这个方法重写就能解决问题了。我和大家想的也一样，对该方法重写，并根据情况返回true或false

把要处理的代码放在了TextView的onTouch方法里，然后根据不同的情况返回true或false.在getView()方法里对相应的TextView进行设置吧
参考TextView添加ClickableSpan和LinkMovementMethod之间的关系

        tv.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                int action = event.getAction();
                TextView tv = (TextView) v;
                CharSequence text = tv.getText();
                //这里的SpannableString根据实际情况可以更换
                if (text instanceof SpannableString) {
                    if (action == MotionEvent.ACTION_UP) {
                        int x = (int) event.getX();
                        int y = (int) event.getY();
                        x -= tv.getTotalPaddingLeft();
                        y -= tv.getTotalPaddingTop();
                        x += tv.getScrollX();
                        y += tv.getScrollY();
                        Layout layout = tv.getLayout();
                        int line = layout.getLineForVertical(y);
                        int off = layout.getOffsetForHorizontal(line, x);
                       //这里的SpannableString根据实际情况可以更换
                        ClickableSpan[] link = ((SpannableString)text).getSpans(off, off, ClickableSpan.class);
                        if (link.length != 0) {
                            link[0].onClick(tv);
                        } else {
                            //do textview click event
                        }
                    }
                }
                return false;
            }
        });

Android部分文字点击SpannableString实现及滑动冲突处理

滑动冲突处理——自定义MovementMethod
这里就是复制修改下LinkMovementMethod的源码，把滑动部分去掉就可以了。

public class CustomMovementMethod extends BaseMovementMethod {
    private static CustomMovementMethod customMovementMethod;
    public static CustomMovementMethod getInstance() {
        if (customMovementMethod == null) {
            synchronized (CustomMovementMethod .class) {
                if (customMovementMethod == null) {
                    customMovementMethod = new CustomMovementMethod ();
                }
            }
        }
        return customMovementMethod;
    }
    @Override
    public boolean onTouchEvent(TextView widget, Spannable buffer, MotionEvent event) {
        int action = event.getAction();
        if (action == MotionEvent.ACTION_UP ||
                action == MotionEvent.ACTION_DOWN) {
            int x = (int) event.getX();
            int y = (int) event.getY();
            x -= widget.getTotalPaddingLeft();
            y -= widget.getTotalPaddingTop();
            x += widget.getScrollX();
            y += widget.getScrollY();
            Layout layout = widget.getLayout();
            int line = layout.getLineForVertical(y);
            int off = layout.getOffsetForHorizontal(line, x);
            ClickableSpan[] link = buffer.getSpans(off, off, ClickableSpan.class);
            if (link.length != 0) {
                if (action == MotionEvent.ACTION_UP) {
                    // 只处理点击事件
                    link[0].onClick(widget);
                }
                return true;
            }
        }
        return super.onTouchEvent(widget, buffer, event);
    }
    private CustomMovementMethod () {
    }
}

tv.setMovementMethod(CustomMovementMethod.getInstance());是重点，漏了这句点击没有效果。

自定义可点击的ImageSpan并在TextView中内置“View“

解决TextView中ClickableSpan点击事件

点击clickableSpan之外的其他地方是可以触发普通的点击事件，问题是点击clickableSpan区域时，不仅会触发ClickableSpan.onClick(view)，还会触发TextView.onClick(view)。

解决Android TextView富文本拦截点击事件

添加了长按事件
解决TextView 设置ClickableSpan之后，点击和滑动冲突以及空白区域处理
1：ClickableSpan的点击和TextView的长文本滑动冲突
2：点击TextView空白区域，总选中最后一个文本

安卓 TextView 七宗罪

安卓自带文本控件 TextView 有七个比较恶心人的地方：

1. 默认情况下，点击 ClickableSpan 的文本时会同时触发绑定在 TextView 的监听事件；
2. 默认情况下，点击 ClickableSpan 的文本之外的文本时，TextView 会消费该事件，而不会传递给父 View；
3. 固定 TextView 行数的时候，点击 ClickableSpan 文本会出现滚动现象；
4. 在 8.0 系统上 Html.from() + ClickableSpan + TextUtils.concat() 点击事件表现异常；
5. Spannable 与 Ellispsize 同时使用时，Ellipsize 失效；
6. TextView 性能较低；
7. 折行策略不尽人意，在小米 2s 上尤其明显；
8. 诡异的 ClickableSpan 表现，在 TextView 上绑定点击事件，又在某段子串上绑定 ClickableSpan，根据 ClickableSpan#onClick() 内部的代码不同，会只触发 ClickableSpan 或既触发 ClickableSpan 又触发 TextView 绑定的事件；
9. 明明设置2行，当前3行都是 ImageSpan 实现的 emoji 时，第3行的顶部会被绘制出来；

scrollview

传进监听器的是一个event对象，就是用户的touch动作。得到这个event对象之后，我们调用event的getAction方法对这个动作进行判断。
getAction()有 Action_UP Action_DOWN Action_MOVE等结果，这里只用到了Action_MOVE;
再提几个方法：
1.ScrollView的getScrollY() : 滑动条垂直滑动的距离（就是当前视图相对于屏幕原点在Y轴上的偏移量，首先明确Android坐标概念，（0,0）处于左上角，向右是X轴正方向，向下是Y轴正方向，假如向上滚动显示下文，Y值必须为正数，因为当你向上移动后，原先的屏幕原点已经被甩到上面去了，超出屏幕之外，当前视图中的屏幕左上角相对于屏幕原点（是固定不变的的）已经在下方了，所以是正数）
2.View的getHeight(): 该View在屏幕上显示的的高度（和手机屏幕的高度是有区别的）。在本例中，在屏幕上显示的最外层的View是一个ScrollView，所以就用ScrollView调用这个方法得到屏幕的高度。tips：屏幕的高度是这样计算的 width = activity.getWindowManager().getDefaultDisplay().getWidth();
3.View的 getMeasuredHeight(): View的总高度。 当屏幕可以包裹整个View的时候，它和getHeight相等。比方说这个TextView有1000行，那高度就是1000行的高度。本例中我们测量的是Text的高度，所以就用TextView调用这个方法得到。因为TextView是ScrollView中的第一层子View，所以也可以用ScrollView.getChildAt(0)得到TextView对象，
到达底部后，我们用TextView的append()方法追加一条string, 这里是无限追加的，就是说每次到底部都会追加一条，无穷无尽，呵呵！

作者：陈利健
链接：https://www.jianshu.com/p/6a37c3256c6b
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

ScrollView常见问题（不能填满屏幕、内部layout_weight无效、进入自动下滑问题等）

不能填满屏幕、内部layout_weight无效—> android:fillViewport=”true”

Android 将本地资源图片转换成Drawable，进行设置大小

• 将本地图片（R.drawable.image）变成Drawable对象
• 将Drawable对象转换成Bitmap对象
• 将Bitmap对象根据指定大小创建一个新的Bitmap对象
• 将Bitmap对象转换成Drawable对象

Context.getResources().getDrawable(int res)方法过时

Context.getDrawable(int id, Resources.Theme theme), 第二个参数@theme可以为空值.或Context.getDrawable(int)。
但是这个方法的兼容性不是很好，只有在API Level 21及以上才能使用(也就是Android5.0以上)。最后找到了以下解决方案：
ContextCompat.getDrawable(context,R.drawable.icon_test);
这个方法看着容易理解，同时谷歌也推荐使用这种方法。

BitmapFactory.decodeStream 内存溢出java.lang.OutOfMemoryError

图片过大（5.78M左右）就可能导致内存溢出java.lang.OutOfMemoryError,通常大家的第一反应是在使用图片之前进行压缩（第一：质量压缩，第二：图片按比例大小压缩，第三：图片按比例大小压缩）但是这个思路是错误的。对质量压缩的理解（仅供参考）：不像网上所说的质量压缩既不失真有能压缩，亲测会失真，我觉得任何压缩方法都会付出代价，只是方法合适代价会小，或者牺牲次要方面，来维持我们的目的。下面是bitmap的compress方法官方介绍：
网上会对该方法的参数quality曲解 先看官方介绍：
@param quality Hint to the compressor, 0-100. 0 meaning compress for
small size, 100 meaning compress for max quality. Some
formats, like PNG which is lossless, will ignore the
* quality setting
认为100 就是不压缩 ，大小不变，其实是错误的理解 quality只表示compress程度，也就是只要使用compress 就会压缩 ，设置为100 文件也会 变小，当然0表示压缩到最小。经过测试，网上对质量压缩的优化 ：

Bitmap bitmap = null;  
       while (true) {  
           // 这一步是根据要设置的大小，使宽和高都能满足   
           if ((options.outWidth >> i <= size)  
                   && (options.outHeight >> i <= size)) {  
               // 重新取得流，注意：这里一定要再次加载，不能二次使用之前的流！   
               temp = this.getAssets().open(path);  
               // 这个参数表示 新生成的图片为原始图片的几分之一。   
               options.inSampleSize = (int) Math.pow(2.0D, i);  
               // 这里之前设置为了true，所以要改为false，否则就创建不出图片   
               options.inJustDecodeBounds = false;  
               bitmap = BitmapFactory.decodeStream(temp, null, options);  
               break;  
           }  
           i += 1;  
       }  
       return bitmap;

没有必要，我试了试不起作用，传到服务器会图片变成全黑的情况 。
重点：正确解决方案 设置inSampleSize
先说原因吧，BitmapFactory.decodeStream 内存溢出java.lang.OutOfMemoryError 是因为
使用Content Provider android.content.ContentResolver.openInputStream 去取数据时，因为图片过大就会报错，而不是bitmap显示时报错。
所以在使用前压缩的思路是错误了。

BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 4;
       Bitmap bitmap = BitmapFactory.decodeStream(cr.openInputStream(uri), null, options);
    image1.setImageBitmap(bitmap);

cr：是 android.content.ContentResolver 对象
image1： 是 ImageView对象
网上很多说设Options.inJustDecodeBounds = true; 可 能会出错 ，bitmap 会为null 图片全白 的现象 ，如果你是这种现象，去掉试试。
关于options.inSampleSize 大小设置 网上有优化这里只做简单处理 ，有大牛做动态计算合适大小。自己没尝试过就不做叙述了。
说的不一定对但都是自己亲测的一点感悟，网上很多理解都是错误的，希望可以帮到遇到同样问题的你。

安卓BitmapFactory.decodeStream报java.lang.OutOfMemoryError内存溢出
有效解决Android加载大图片内存溢出的问题
android 通过uri获取bitmap图片并压缩
ImageSpan使用时的坑(绘制出来图片大小不对的问题)
android 关于图片压缩库Luban.load(Uri)的问题

Android库对于加载图片来说不是很聪明，所以你必须为此创建解决方法。
在我的测试中，Drawable.createFromStream比使用更多的内存BitmapFactory.decodeStream。
你可以更改颜色方案以减少内存（RGB_565），但图像也会失去质量：

BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Config.RGB_565;
Bitmap bitmap = BitmapFactory.decodeStream(stream, null, options);

参考：http：//developer.android.com/reference/android/graphics/Bitmap.Config.html
你还可以加载缩放的图像，这会减少很多内存使用量，但您必须知道图像的质量不会过高：

BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
Bitmap bitmap = BitmapFactory.decodeStream(stream, null, options);

参考：http : //developer.android.com/reference/android/graphics/BitmapFactory.Options.html
要动态定义inSampleSize，你可能想知道图像大小以作出决定：

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
bitmap = BitmapFactory.decodeStream(stream, null, options);
int imageHeight = options.outHeight;
int imageWidth = options.outWidth;
options.inJustDecodeBounds = false;
// recreate the stream
// make some calculation to define inSampleSize
options.inSampleSize = ?;
Bitmap bitmap = BitmapFactory.decodeStream(stream, null, options);

您可以根据设备的屏幕大小自定义inSampleSize。要获得屏幕大小，您可以执行以下操作：

DisplayMetrics metrics = new DisplayMetrics();
((Activity) activity).getWindowManager().getDefaultDisplay().getMetrics(metrics);
int screenWidth = metrics.widthPixels;
int screenHeight =metrics.heightPixels;

官方参考高效加载大型位图

处理输入法可见度

当输入法出现在屏幕上时，它会减少应用界面的可用空间。系统会决定应如何调整界面的可见部分，但可能操作不正确。为了确保应用具有最佳行为，您应该指定希望系统如何在剩余空间中显示界面。
要在 Activity 中声明您的首选处理方式，请使用清单的 <activity> 元素中的 [android:windowSoftInputMode](https://developer.android.com/guide/topics/manifest/activity-element.html#wsoft) 属性，该属性包含其中一个“adjust”值。
例如，要确保系统将布局大小调整为可用空间，以确保所有布局内容均可访问（尽管可能需要滚动），请使用 "adjustResize"：

对Android 软键盘向下的监听

对 Edittext.onKeyPreIme() 方法重写
为什么 重写 Activity.onKeyDown() 方法为什么没有用？

Android监听键盘弹出与隐藏事件

其实系统提供的是InputMethodManager，让我们控制键盘的弹出和隐藏，而不是键盘弹出和隐藏触发事件。

参考Android 监听键盘弹出收起

搜到的一些监听键盘的方法必须要windowSoftInputMode属性为adjustResize时才可以用。这个方法不适用与app全屏显示(全屏时布局大小并不会改变)。有一个类可以实现监听键盘弹出收起，不用考虑windowSoftInputMode属性与Activity是否全屏。

package com.example.note.util;
import android.app.Activity;
import android.graphics.Rect;
import android.view.View;
import android.view.ViewTreeObserver;
/**
 * Created by liujinhua on 15/10/25.
 */
public class SoftKeyBoardListener {
    private View rootView;     // activity的根视图
    int rootViewVisibleHeight;  // 纪录根视图的显示高度
    private OnSoftKeyBoardChangeListener onSoftKeyBoardChangeListener;
    public SoftKeyBoardListener(Activity activity) {
        //获取activity的根视图
        rootView = activity.getWindow().getDecorView();
        //监听视图树中全局布局发生改变或者视图树中的某个视图的可视状态发生改变
        rootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                //获取当前根视图在屏幕上显示的大小
                Rect r = new Rect();
                rootView.getWindowVisibleDisplayFrame(r);
                int visibleHeight = r.height();
                System.out.println(""+visibleHeight);
                if (rootViewVisibleHeight == 0) {
                    rootViewVisibleHeight = visibleHeight;
                    return;
                }
                //根视图显示高度没有变化，可以看作软键盘显示／隐藏状态没有改变
                if (rootViewVisibleHeight == visibleHeight) {
                    return;
                }
                //根视图显示高度变小超过200，可以看作软键盘显示了
                if (rootViewVisibleHeight - visibleHeight > 200) {
                    if (onSoftKeyBoardChangeListener != null) {
                        onSoftKeyBoardChangeListener.keyBoardShow(rootViewVisibleHeight - visibleHeight);
                    }
                    rootViewVisibleHeight = visibleHeight;
                    return;
                }
                //根视图显示高度变大超过200，可以看作软键盘隐藏了
                if (visibleHeight - rootViewVisibleHeight > 200) {
                    if (onSoftKeyBoardChangeListener != null) {
                        onSoftKeyBoardChangeListener.keyBoardHide(visibleHeight - rootViewVisibleHeight);
                    }
                    rootViewVisibleHeight = visibleHeight;
                    return;
                }
            }
        });
    }
    private void setOnSoftKeyBoardChangeListener(OnSoftKeyBoardChangeListener onSoftKeyBoardChangeListener) {
        this.onSoftKeyBoardChangeListener = onSoftKeyBoardChangeListener;
    }
    public interface OnSoftKeyBoardChangeListener {
        void keyBoardShow(int height);
        void keyBoardHide(int height);
    }
    public static void setListener(Activity activity, OnSoftKeyBoardChangeListener onSoftKeyBoardChangeListener) {
        SoftKeyBoardListener softKeyBoardListener = new SoftKeyBoardListener(activity);
        softKeyBoardListener.setOnSoftKeyBoardChangeListener(onSoftKeyBoardChangeListener);
    }
}

Activity中调用：

SoftKeyBoardListener.setListener(getActivity(), new SoftKeyBoardListener.OnSoftKeyBoardChangeListener() {
@Override
public void keyBoardShow(int height) {
                //Toast.makeText(getActivity(), "键盘显示 高度" + height, Toast.LENGTH_SHORT).show();
     }
@Override
public void keyBoardHide(int height) {
              //Toast.makeText(getActivity(), "键盘隐藏 高度" + height, Toast.LENGTH_SHORT).show();
    }
});

Android软键盘弹出和收回监听

软键盘弹出和收回的三种方式：
第一种方案：
自定义Edittext

第二种方案：
软键盘弹出监听（通过高度计算，但是这种方式有问题，不推荐用）：

第三种方案：
自定义RelativeLayout

Android中visibility属性VISIBLE、INVISIBLE、GONE的区别

而INVISIBLE和GONE的主要区别是：当控件visibility属性为INVISIBLE时，界面保留了view控件所占有的空间；而控件属性为GONE时，界面则不保留view控件所占有的空间。

androidx.appcompat.view.menu.ActionMenuItemView无法转换为android.view.MenuItem

toolbar2.getMenu().findItem(R.id.action_refresh).setVisible(false);

也可以定义全局变量Menu menu,在onCreateOptionsMenu初始化。

public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        final MenuItem item = menu.findItem(R.id.ab_search);
        searchView = (SearchView) MenuItemCompat.getActionView(item);
}

动态改变actionbar上menu的图标

你不能在onCreate（）的菜单项上使用findViewById（），因为菜单布局尚未充满。你可以创建一个全局的Menu变量并在onCreateOptionsMenu（）中初始化它，然后在你的onClick（）中使用它。代码：
private Menu menu;
在你的onCreateOptionsMenu（）：
this.menu = menu;
在你的按钮的onClick（）方法中：
menu.getItem(0).setIcon(ContextCompat.getDrawable(this, R.drawable.ic_launcher));
改变最右边的menu图标

MenuItem moreItem;
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        moreItem = menu.add(Menu.NONE, Menu.FIRST, Menu.FIRST, null);
        moreItem.setIcon(R.drawable.action_bar_icon_more);
        moreItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
        return super.onCreateOptionsMenu(menu);
    }

Android应用中Back键的监听及处理

package cn.testnbackpressed;
import android.os.Bundle;
import android.view.KeyEvent;
import android.app.Activity;
/**
 * Demo描述:
 * 处理Back键按下事件
 * 
 * 注意事项:
 * 以下两种方法勿一起使用
 */
public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
    /**
     * 监听Back键按下事件,方法1:
     * 注意:
     * super.onBackPressed()会自动调用finish()方法,关闭
     * 当前Activity.
     * 若要屏蔽Back键盘,注释该行代码即可
     */
    @Override
    public void onBackPressed() {
        super.onBackPressed();
        System.out.println("按下了back键   onBackPressed()");        
    }
   /**
    * 监听Back键按下事件,方法2:
    * 注意:
    * 返回值表示:是否能完全处理该事件
    * 在此处返回false,所以会继续传播该事件.
    * 在具体项目中此处的返回值视情况而定.
    */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if ((keyCode == KeyEvent.KEYCODE_BACK)) {
             System.out.println("按下了back键   onKeyDown()"); 
             return false;
        }else {
            return super.onKeyDown(keyCode, event);
        }
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        System.out.println("执行 onDestroy()");
    }    
}

Android 回退键监听

方法1：回调方法onBackPressed

这个方法可以阻止用户点击后退键来退出程序。
一般的像升级程序或者重要数据传输页面都是要阻止用户轻易退出的。
这个方法也是我们最简单、常用的一个方法。

方法2：回调方法onKeyDown

这个方法是监听按键事件，但是阻止用户的行为，并且这种方法监听不到Home键的事件。

方法3：回调方法dispatchKeyEvent

这是个事件分发的方法，无论手指按下屏幕或滑动屏幕、离开屏幕都是会触发这个方法

    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {
        Log.i(LOG_TAG, "dispatchKeyEvent: keyCode -- " + event.getKeyCode());
        if (event.getKeyCode()==4){//回退键的KeyCode是4.
            return false;//表示不分发
        }else{
            return super.dispatchKeyEvent(event);
        }
    }

如果事件没有分发（返回false），onBackPressed方法和onKeyDown方法都是没有得到回调的

正常情况肯定是用第一种方法咯。

后面两种方法涉及到事件的分发。
事件分发要彻底理解是一个相当麻烦的过程：包括事件分发、事件拦截、事件处理，并且手指按下、移动、松开都要分析三个事件情况。

上面三个方法中，如果dispatchKeyEvent返回false，后面两个方法是无法得到回调的。
如果onKeyDown返回false，onBackPressed方法是没有得到回调的。

android LinearLayout布局嵌套覆盖问题

要设置layout_weight属性

在CoordinatorLayout的时候，上面的布局挡住下面的布局

在CoordinatorLayout的时候，上面的布局挡住下面的布局，只需要在下面的布局当中加入这个属性即可：
app:layout_behavior=”@string/appbar_scrolling_view_behavior”

序列化保存样式

Serializable

ObjectOutputStream既可以写入基本类型，如int，boolean，也可以写入String（以UTF-8编码），还可以写入实现了Serializable接口的Object。
因为写入**Object**时需要大量的类型信息，所以写入的内容很大。

**反序列化时，由JVM直接构造出Java对象，不调用构造方法，构造方法内部的代码，在反序列化时根本不可能执行。

import java.io.*;
import java.util.Arrays;
/** 
 * @authur    zhangqizky
 * @apiNote   序列化与反序列化，将java对象变成二进制内容，即byte[]数组.
 * 可序列化的Java对象必须实现java.io.Serializable接口，类似Serializable这样的空接口被称为“标记接口”（Marker Interface）；
反序列化时不调用构造方法，可设置serialVersionUID作为版本号（非必需）；
Java的序列化机制仅适用于Java，如果需要与其它语言交换数据，必须使用通用的序列化方法，例如JSON。
*/
public class MySeralize
{
    public static void main(String[]args)throws IOException,ClassNotFoundException
    {
        //序列化
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        try(ObjectOutputStream os = new ObjectOutputStream(buffer))
        {
            os.writeInt(12345);
            os.writeUTF("Hello");
            os.writeObject(Double.valueOf(123.456));
        }
        System.out.println(Arrays.toString(buffer.toByteArray()));
        ByteArrayInputStream bufferin = new ByteArrayInputStream(buffer.toByteArray());
        //反序列化,反序列化时，由JVM直接构造出Java对象，不调用构造方法，构造方法内部的代码，在反序列化时根本不可能执行
        try(ObjectInputStream in = new ObjectInputStream(bufferin))
        {
            int n = in.readInt();
            String s = in.readUTF();
            Double d = (Double)(in.readObject());
            System.out.println(n);
            System.out.println(s);
            System.out.println(d);
        }
    }
}

Parcel与Parcelable

TextAppearanceSpan实现了writeToParcel，但是没有创建Creator常量。所以我们可以先将TextAppearanceSpan对象通过writeToParcel保存为Parcel对象。然后将其转变为byte[]保存。TextAppearanceSpan提供了Parcel参数的构造函数。

SpannableStringBuilder实现不了Serializable，里面有一个字段没有实现序列化。
**Android中实现序列化有两个选择：一是实现Serializable接口（是JavaSE本身就支持的），一是实现Parcelable接口（是Android特有功能，效率比实现Serializable接口高效，可用于Intent数据传递，也可以用于进程间通信（IPC））。实现Serializable接口非常简单，声明一下就可以了，而实现Parcelable接口稍微复杂一些，但效率更高，推荐用这种方法提高性能。
注：Android中Intent传递对象有两种方法：一是Bundle.putSerializable(Key，Object)，另一种是Bundle.putParcelable(Key，Object)。当然这些Object是有一定的条件的，前者是实现了Serializable接口，而后者是实现了Parcelable接口。

实现parcelable接口中list处理方法
适用于非自定义对象
dest.writeList(sub_type);

source.readList(parcelableHelperPo.sub_type, getClass().getClassLoader());

自定义集合 Book

//自定义集合 Book实现了Parcelable接口 private ArrayList books;

out.writeTypedList(books);

// 用这种方法会报错。
// books=p.readArrayList(Thread.currentThread().getContextClassLoader());

   // 传递自定义List 只能用以下方法，p为Parcel<br />       books= p.createTypedArrayList(Book.CREATOR);

官方例子

public class MyParcelable implements Parcelable {
     private int mData;
     public int describeContents() {
         return 0;
     }
     public void writeToParcel(Parcel out, int flags) {
         out.writeInt(mData);
     }
     public static final Parcelable.Creator<MyParcelable> CREATOR
             = new Parcelable.Creator<MyParcelable>() {
         public MyParcelable createFromParcel(Parcel in) {
             return new MyParcelable(in);
         }
         public MyParcelable[] newArray(int size) {
             return new MyParcelable[size];
         }
     };
     private MyParcelable(Parcel in) {
         mData = in.readInt();
     }
 }

Parcel类

Parcel主要用于在进程间通讯，传递数据。
Parcel通过obtain()静态方法获取，数据的存储和读取主要通过writeXXX()和readXXX()实现，marshall()和unmarshall()将数据序列化和反序列化，最后recycle()回收资源。

读取时记得设置setDataPosition（0）

作者：Wellijohn
链接：https://juejin.im/post/5a3b24ab6fb9a04515440bd7
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

选择序列化方法的原则
1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable 。

ANDROID:SERIALIZABLE和PARCELABLE的持久化保存

前言:
Serializable和Parcelable能够将对象序列化，使之能够在一些特殊场景中进行传输，再进行数据的恢复(Serializable是Java实现的接口，而Parcelable是Android实现的)。
两者作用类似但是实现等其他方面有较大区别，比较多的说法认为Parcelable不适合用于数据的持久化保存，但合适与否和是否可行完全是两码事(GSON是另外一种保存对象的方式)。
出于好奇想从性能方面比较两者持久化的异同。

一.Serializable

需要实现的类如下

class SerialData implements Serializable {
    private static final long serialVersionUID = -7060210544622464481L;
    public ArrayList<String> array;
    public SerialData() {
        array = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            array.add(new String("123"));
        }
    }
}

写方法

private void saveAsSerializable(SerialData data) {
        FileOutputStream fos;
        ObjectOutputStream oos;
        try {
            fos = getApplicationContext().openFileOutput(TAG,
                    Context.MODE_PRIVATE);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(data);
            oos.close();
            fos.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

读方法

private SerialData readData() {
        SerialData obj = null;
        FileInputStream fis;
        ObjectInputStream ois;
        try {
            fis = getApplicationContext().openFileInput(TAG);
            ois = new ObjectInputStream(fis);
            obj = (SerialData) ois.readObject();
            ois.close();
            fis.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        if (obj != null)
            return obj;
        else
            return null;
    }

二.Parcelable

实现类

class ParceData implements Parcelable {
    public ArrayList<String> array;
    public ParceData() {
        array = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            array.add(new String("123"));
        }
    }
    @Override
    public int describeContents() {
        return 0;
    }
    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeStringList(array);
    }
    public static final Parcelable.Creator<ParceData> CREATOR = new Creator<ParceData>() {
        @Override
        public ParceData[] newArray(int size) {
            return new ParceData[size];
        }
        @Override
        public ParceData createFromParcel(Parcel in) {
            return new ParceData(in);
        }
    };
    public ParceData(Parcel in) {
        array = new ArrayList<String>();
        in.readStringList(array);
    }
}

写方法

protected void saveParce() {
        FileOutputStream fos;
        try {
            fos = getApplicationContext().openFileOutput(TAG,
                    Context.MODE_PRIVATE);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            Parcel parcel = Parcel.obtain();
            parcel.writeParcelable(new ParceData(), 0);
            bos.write(parcel.marshall());
            bos.flush();
            bos.close();
            fos.flush();
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

读方法

protected void loadParce() {
        FileInputStream fis;
        try {
            fis = getApplicationContext().openFileInput(TAG);
            byte[] bytes = new byte[fis.available()];
            fis.read(bytes);
            Parcel parcel = Parcel.obtain();
            parcel.unmarshall(bytes, 0, bytes.length);
            parcel.setDataPosition(0);
            ParceData data = parcel.readParcelable(ParceData.class.getClassLoader());
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

三.速度比较

1.Serializable
执行如下操作:
SerialData data = new SerialData();
Log.e(“time”, “befor = “ + System.currentTimeMillis());
saveAsSerializable(data);
Log.e(“time”, “after = “ + System.currentTimeMillis());

10次平均:2889ms

2.Parcelable
操作如下:
Log.e(“time”, “befor = “ + System.currentTimeMillis());
saveParce();
Log.e(“time”, “after = “ + System.currentTimeMillis());


10次平均:360ms

四.内存比较

初始状态:



执行一次Serializable的写入


执行一次Parcelable的写入




Pacelable在速度上，内存的使用上都比Serializable有优势。虽然如此，实际上面的数据并没有太大的参考意义，两个类都创建了10万个对象，项目中这种情况很少遇到。
实现起来Serializable更简单，实现接口即可，而Pacelable作二进制的转化，对写入和读取的顺序都要保持一致，对象越多实现越复杂。

Gson

添加serializedName注解，这是gson的注解，意思是序列化时的名字，json映射的是这个名字，而不是字段名，不加这个注解就是映射字段名。

使用gson生成json数组

一般toJson(Object src)方法就够用了。

String[] names = {"jadyli", "Juliet"};
String[] genders = {"male", "female"};
int[] ages = {18, 20};
List<Student> students = new ArrayList<>();
for (int i = 0; i < names.length; i++) {
    Student student = new Student();
    student.setName(names[i]);
    student.setGender(genders[i]);
    student.setAge(ages[i]);
    students.add(student);
}
String jsonStr = new Gson().toJson(students);
System.out.println(jsonStr);

new Gson().toJson(Object src)输出的是没有格式化的json字符串，要是想输出格式化了的，可以使用

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonStr = gson.toJson(students);

默认忽略空的字段，如果不想忽略，可以使用

Gson gson = new GsonBuilder().serializeNulls().create();
String jsonStr = gson.toJson(students);

Android控件属性 - gravity、layout_gravity、textAlignment的区别

gravity设置的是控件内部的子控件或文本的停靠位置，layout_gravity设置的是控件在其容器中的停靠位置。

textAlignment专门是指定文本的停靠（对齐）位置，可选值有”inherit”、”gravity”、”textStart”、”textEnd”、”center”、”viewStart”、”viewEnd”。对于TextView等控件，textAlignment的优先级高于gravity，而textAlignment为空或为”gravity”时，文本的对齐方式就由gravity属性确定。**

Nested weights are bad for performance警告

原因分析：在布局进行嵌套使用时，父布局与子布局都使用了android:layout_weight。

布局权重要求对小部件进行两次测量。当具有非零权重的LinearLayout嵌套在具有非零权重的另一个LinearLayout中时，度量的数量将呈指数增长。

最好使用RelativeLayout并根据其他视图的位置调整视图，而不使用特定的dpi值。

两分钟理解Android中PX、DP、SP的区别

px ： 其实就是像素单位，比如我们通常说的手机分辨列表800*400都是px的单位
sp ： 同dp相似，还会根据用户的字体大小偏好来缩放
dp ： 虚拟像素，在不同的像素密度的设备上会自动适配
dip： 同dp

APP设计尺寸解读：px、pt、ppi、dpi、dp、sp之间的关系
**px：pixel———————————— 【 像素】 电子屏幕上组成一幅图画或照片的最基本单元
pt: point—————————————【 点】印刷行业常用单位，等于1/72英寸
ppi: pixel per inch————————【每英寸像素数】 该值越高，则屏幕越细腻
dpi: dot per inch—————————【每英寸多少点】，该值越高，则图片越细腻
dp: dip，Density-independent pixel, 【安卓开发用的长度单位】
1dp表示在屏幕像素点密度为160ppi时1px长度
sp: scale-independent pixel————————————【安卓开发用的字体大小单位】。

公式四： 1dp=（屏幕ppi/ 160）px

RecyclerView设置两个不同布局的注意事项

You should extends RecyclerView.Adapter<RecyclerView.ViewHolder> as onCreateViewHolder is returning RecyclerView.ViewHolder

public class ItemCatgorySubListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder>

定义类的时候要用RecyclerView.Adapter
onCreateViewHolder 的返回值也要使用**RecyclerView.ViewHolder**
在绑定数据时根据对应的ViewHolder实行强制数据类型转换。

如果是想在同一个页面显示不同item，需要Override
参考[RecyclerView的使用（2）之多Item布局的加载**](https://blog.csdn.net/leejizhou/article/details/50708349)

TabLayout+ViewPager+Fragment

TabLayout+ViewPager+Fragment实现切页展示

TabLayout+ViewPager+Fragment方法的使用流程：

1. 创建存储多个Fragment实例的列表
2. 创建PagerAdapter实例并关联到Viewpager中
3. 将ViewPager关联到Tablayout中
4. 根据需求改写Tablayout属性*

   懒加载策略

   Android的View绘制流程是最消耗CPU时间片的操作，尤其是在ViewPager缓存Fragment的情况下，如果在View绘建的同时还进行多个Fragment的数据加载，那用户体验简直是爆炸（不仅浪费流量，而且还造成不必要的卡顿）。。。因此，需要对Fragment们进行懒加载策略。什么是懒加载？就是被动加载，当Fragment页面可见时，才从网络加载数据并显示出来。

当Fragment的可见状态发生变化时就会调用这个函数，boolean参数isVisibleToUser代表当前的Fragment是否可见。
如果这么简单地调用函数就能实现懒加载的话，那也没什么好说的，但是这里又有一个巨坑，则是因为这个setUserVisibleHint函数是游离在Fragment生命周期之外的，它的执行有可能早于onCreate和onCreateView，然而既然要时间数据的加载，就必须要在onCreateView创建完视图过后才能使用，不然就会返回空指针崩溃，懒加载的重点也是在这儿，那么我们来分析，实行懒加载必须满足哪些条件呢？

1.View视图加载完毕，即onCreateView（）执行完成 2.当前Fragment可见，即setUserVisibleHint（）的参数为true 3.初次加载，即防止多次滑动重复加载

ViewPager中获取当前界面的Fragment注意事项

尝试解决：使用FragmentManager.findFragmentById()但出现问题

onPageSelected方法调用在setPrimaryItem之前，所以在onPageSelected方法里面去获取当前界面的fragment会是之前保存的状态。onPageSelected方法在切换执行一次，后者可能执行多次。
**这种方式有一个缺陷 setPrimaryItem()是在 viewpager的滑动监听执行完后才会调用的；所以在滑动监听中获取当前显示的Fragment 是不对的。

Android总结之Fragment

Fragment懒加载

1 定义三个变量分别记录三个条件状态：isViewCreated,isVisibleToUser,isLoaded
2 在适当的回调方法中，更新这三个变量
3 触发懒加载时，要判断三个条件都满足时，才加载数据。

Android基础：Fragment，看这篇就够了

Fragment的优势有以下几点：

• 模块化（Modularity）：我们不必把所有代码全部写在Activity中，而是把代码写在各自的Fragment中。
• 可重用（Reusability）：多个Activity可以重用一个Fragment。
• 可适配（Adaptability）：根据硬件的屏幕尺寸、屏幕方向，能够方便地实现不同的布局，这样用户体验更好

Fragment和View的比较

Fragment和View都有助于界面组件的复用，这在大型工程里边是特别重要的，但是二者又有所区别。

1、Fragment的复用粒度更大。Fragment有完整的生命周期，从代码设计角度讲可以提高内聚性，不同情况下还可以设计不同的Fragment，比如横屏和竖屏情况下View的显示不一样，那么可以建立2个不同的Fragment去处理，代码上面可以有效的扩展。

从形态上讲和Activity更为接近，当然从编程角度上看也比View更为复杂。但是Fragment可以组装更多的View同一展示，而且生命周期有助于资源的管理。

2、简单的直接view，复杂的才用fragment，fragment资源消耗比较大。

3、一个fragment必须总是绑定到一个activity中，虽然fragment有自己的生命周期，但同时也被它的宿主activity的生命周期直接影响。
大部分情况下，Fragment用来封转UI的模块化组件；但是也可以创建没有UI的Fragment来提供后台行为，该行为会一直持续到Activity重新启动。这特别适合于定期和UI交互的后台任务或者当因配置改变而导致Activity重新启动是，保存状态变得特别重要的场合。

注意：当Activity因为配置发生改变（屏幕旋转）或者内存不足被系统杀死，造成重新创建时，我们的fragment会被保存下来，但是会创建新的FragmentManager，新的FragmentManager会首先会去获取保存下来的fragment队列，重建fragment队列，从而恢复之前的状态。

[整] Android Fragment 生命周期图

fragments的大部分状态都和activitie很相似，但fragment有一些新的状态。

• onAttached() —— 当fragment被加入到activity时调用（在这个方法中可以获得所在的activity）。
• onCreateView() —— 当activity要得到fragment的layout时，调用此方法，fragment在其中创建自己的layout(界面)。
• onActivityCreated() —— 当activity的onCreated()方法返回后调用此方法
• onDestroyView() —— 当fragment中的视图被移除的时候，调用这个方法。
• onDetach() —— 当fragment和activity分离的时候，调用这个方法。

一旦activity进入resumed状态（也就是running状态），你就可以自由地添加和删除fragment了。因此，只有当activity在resumed状态时，fragment的生命周期才能独立的运转，其它时候是依赖于activity的生命周期变化的。

setChecked方法触发onCheckedChanged监听器问题

在recyclerview onCheckedChanged自动调用

   @Override
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
        //防止初始化的时候出发监听
        if (!buttonView.isPressed()) {
            return;
        }
        doSomeThing();
}

LitePal设置默认值的注意事项

对于LitePal数据库而言，存储boolean值为true的时候可以直接用LitePal存储对象的方式存储，若存储的对象中boolean为false，需要调用setToDefault(String name)方法存储，其中参数name为对象中Boolean属性的名称，为字符串。

解决Android中TextView多行显示的最后一行被遮住一半的bug

将TextView的PaddingButtom设置一个切当的值即可解决（单行文字高度的一半就可以，例如10dp）。

android判断输入框EditText是否为空

一，通过判断输入值长度是否为零

String serch_textip=mEdit1.getText().toString().trim();
if(serch_textip.length()==0)                              //判断IP输入框是否为空
{Toast.makeText(MainActivity.this,"请输入ip", Toast.LENGTH_LONG).show();}

二，比较输入值是否为Empty

String serch_textip=mEdit1.getText().toString().trim();
if(serch_textip.isEmpty())                                  //判断IP输入框是否为空
{Toast.makeText(MainActivity.this,"请输入IP", Toast.LENGTH_LONG).show();}

三，比较输入值是否为null或者“ ”

String serch_textinfo =mEdit.getText().toString();
if(null == serch_textinfo || "".equals(serch_textinfo))
{Toast.makeText(this,"请输入Info", Toast.LENGTH_LONG).show();}  //判断Info输入框是否为空

string.trim()究竟去掉了什么？

trim()方法实际上trim掉了字符串两端Unicode编码小于等于32（\u0020）的所有字符。

trim()方法实际上的行为并不是”去掉两端的空白字符“，而是”截取中间的非空白字符“。

android EditText最多显示多高，超出的滑动显示

android:maxHeight=”120dp”

Android常见输入inputType类型

android中showSoftInput不起作用

Android 手动显示和隐藏软键盘

1、方法一(如果输入法在窗口上已经显示，则隐藏，反之则显示)

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);

2、方法二（view为接受软键盘输入的视图，SHOW_FORCED表示强制显示）

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(view,InputMethodManager.SHOW_FORCED);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0); //强制隐藏键盘

3、调用隐藏系统默认的输入法

((InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(WidgetSearchActivity.this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);  (WidgetSearchActivity是当前的Activity)

4、获取输入法打开的状态

InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
boolean isOpen=imm.isActive();//isOpen若返回true，则表示输入法打开

Android软键盘弹出时不把布局顶上去的解决方法

Android:windowSoftInputMode=”stateVisible|adjustResize”，这样会让屏幕整体上移
Android:windowSoftInputMode=”adjustPan”这样键盘就会覆盖屏幕。

android:windowSoftInputMode

Activity 的主窗口与包含屏幕软键盘的窗口之间的交互方式。该属性的设置会影响两点内容：

• 当 Activity 成为用户注意的焦点时，软键盘的状态为隐藏还是可见。
• 对 Activity 主窗口所做的调整 — 是否将其尺寸调小，为软键盘腾出空间；或当软键盘遮盖部分窗口时，是否平移其内容以使当前焦点可见。

该设置必须是下表所列的其中一项值，或一个“state...”值加上一个“adjust...”值的组合。在任一组中设置多个值（例如，多个“state...”值）均会产生未定义的结果。各值之间使用竖线 (|) 进行分隔。例如：

以下设置的值（“stateUnspecified”和“adjustUnspecified”除外）会替换主题中设置的值。

该属性是 API 级别 3 中的新增属性。

RecycleView 点击事件

关于recycleview点击事件的问题 #608
一开始我接触的就是通过Adapter设置RecycleView的点击事件监听函数.但是发现其实这样相当于把点击事件从RecycleView里面分离出来.然后在后期发现可以在onTouchEvent函数里面拦截触摸事件然后判断是否触发点击事件.在一些场景下这两钟情况都能很好的把问题处理好.直到现在我的布局文件里面还包含更多的控件的时候,发现第二种办法的弊端.然后把这两种实现方法的原理细看一遍,发现其实他们实现的原理是赤裸裸的不一样.

通过Adapter设置点击事件

通过Adapter设置点击事件,很好理解.本质就是给View绑定事件监听函数.所以可以看到RecycleView是在Adapter#onCreateViewHolder函数里面构造出我们需要的View.当然在这个时候,我们可以在Adapter#onCreateViewHolder或者Adapter#onBindViewHolder函数里面设置点击事件监听函数即可.
在onCreateViewHolder函数里面设置点击事件监听函数

public RvAdapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
       View view;
       final RvAdapter.ViewHolder holder;
       view = mLayoutInflater.inflate(R.layout.item_simple_textview, parent, false);
       holder = new ViewHolder(view);
       view.findViewById(R.id.txtTag).setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View view) {
               Log.i(TAG, mList.get(holder.getLayoutPosition()) + " is click");
           }
       });
       return holder;
   }

  在构造View的同时给View绑定点击事件监听函数,并在监听函数里面持有holder的引用.当回调监听函数的时候通过ViewHolder#getLayoutPosition函数获取position.<br />**操控控件数据时，要用holder的数据设置，不能用view的，否则空指针。**

在onBindViewHolder函数里面设置设置点击事件监听函数
public void onBindViewHolder(final RvAdapter.ViewHolder holder, final int position) {
holder.txtTag.setText(mList.get(position));

   holder.itemView.findViewById(R.id.txtTag).setOnClickListener(new View.OnClickListener() {<br />           @Override<br />           public void onClick(View view) {<br />               Log.i(TAG, mList.get(position) + " is click");<br />           }<br />       });<br />   }
  在绑定事件里面给View绑定点击事件监听函数.

两种办法的区别是也是很明显的.对于第一种方法,因为onCreateViewHolder调用的次数有限的.只当需要创建ViewHolder的时候才会调用,所以我们知道它只需对每一个ViewHolder内含的View创建相应的点击事件监听函数就可以了.但是对于第二种方法,就是每次绑定数据的时候都会创建点击事件监听函数.当然喜欢怎么使用是大家的自由.

总结:通过Adapter设置点击事件,本质上是对View直接设置点击事件监听函数.

菜单

选项菜单和应用栏
参考：
使用方法：
方法一：添加菜单项：onCreateOptionsMenu（Menu menu）中添加menu.add(Menu.NONE,Menu.FIRST+1,5,”删除”).setIcon()———>添加选择菜 单项事件：在onOptionsItemSelected（MenuItem item）中 switch(item.getItemId()),然后添加对应选择事件———>添加关闭菜单事 件：onOptionsMenuClosed(Menu menu),在其中添加代码即可————>添加准备菜单（菜单显示之前的事件),在其中添加代码即可
方法二：添加菜单的样式:在res中创建menu目录，建立 xml,

Android同一Activity中不同Fragment设置不同的menu(ViewPager+Fragment)

onPrepareOptionsMenu是每次在display Menu之前，都会去调用，只要按一次Menu按鍵，就会调用一次。所以可以在这里动态的改变menu。一般使用这个函数时先执行menu.clear().否则如果在这里执行add()的话会不停的追加。

TextToSpeech使用无效问题

创建TextToSpeech实例时会创建服务并绑定到Activity或者Service（取决于在哪里创建实例），所以在销毁这个服务之前应该调用stop()和shutdown()方法来释放TextToSpeech所使用的本地资源。同时，如果使用的是单例模式，必须置空singleton。以防另一个服务需要使用单例的时候，出现问题。

同时，如果在onCreate方法初始化TextToSpeech之后，调用textToSpeech.speak，可能发不出声音，因为textToSpeech可能还没初始化完，所以可以适当延时。或者把代码放到onInit方法里面的else里面执行，即初始化成功后再执行。
可以尝试Application的上下文初始化。

参考资料：Android调用自带TTS文本转语音引擎实现离线语音合成
TextToSpeech的使用

2020-02-24 20:35:49.784 4200-4200/com.example.note E/ActivityThread: Service com.example.note.service.AlarmService has leaked ServiceConnection android.speech.tts.TextToSpeech$Connection@7079c34 that was originally bound here android.app.ServiceConnectionLeaked: Service com.example.note.service.AlarmService has leaked ServiceConnection android.speech.tts.TextToSpeech$Connection@7079c34 that was originally bound here at android.app.LoadedApk$ServiceDispatcher.(LoadedApk.java:1334) at android.app.LoadedApk.getServiceDispatcher(LoadedApk.java:1229) at android.app.ContextImpl.bindServiceCommon(ContextImpl.java:1466) at android.app.ContextImpl.bindService(ContextImpl.java:1438) at android.content.ContextWrapper.bindService(ContextWrapper.java:639) at android.speech.tts.TextToSpeech.connectToEngine(TextToSpeech.java:810) at android.speech.tts.TextToSpeech.initTts(TextToSpeech.java:780) at android.speech.tts.TextToSpeech.(TextToSpeech.java:733) at android.speech.tts.TextToSpeech.(TextToSpeech.java:712) at android.speech.tts.TextToSpeech.(TextToSpeech.java:696) at com.example.note.util.TtsUtil.(TtsUtil.java:31) at com.example.note.util.TtsUtil.getInstance(TtsUtil.java:22) at com.example.note.service.AlarmService.onCreate(AlarmService.java:30) at android.app.ActivityThread.handleCreateService(ActivityThread.java:3405) at android.app.ActivityThread.-wrap5(ActivityThread.java) at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1753) at android.os.Handler.dispatchMessage(Handler.java:102) at android.os.Looper.loop(Looper.java:159) at android.app.ActivityThread.main(ActivityThread.java:6385) at java.lang.reflect.Method.invoke(Native Method) at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1096) at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:883)

TextToSpeech的UtteranceProgressListener触发问题

发通知 PendingIntent 中Intent 内容没有更新

PendingIntent中定义了几个FLAG
android.app.PendingIntent.FLAG_UPDATE_CURRENT
如果PendingIntent已经存在，保留它并且只替换它的extra数据。

PendingIntent中Flags的参数设置

Android延时操作方法

一、使用线程的休眠

new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);//休眠5秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               //延时执行的代码
            }
        }).start();

二、使用TimerTask实现延时操作

        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                /**
                 * 延时执行的代码
                 */
            }
        },1000); // 延时1秒

三、使用Handler的postDelayed()方法

new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                /**
                 * 延时执行的代码
                 */
            }
        },1000); // 延时1秒

注：由于前两种在更新UI时，如果不使用消息处理机制的话，会报如下异常：Only the original thread that created a view hierarchy can touch its views.（只能在主线程中更新UI），为了避免这种错误出现，在使用延时操作的时候推荐使用第三种。

参考Android 延时操作的三种方式

Looper的无限循环为啥不会导致主线程阻塞

Intent传递数据和Bundle传递数据的区别

Intent传递数据和Bundle传递数据是一回事，
Intent传递时内部还是调用了Bundle。

public @NonNull Intent putExtra(String name, int value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putInt(name, value);
        return this;
    }

Bundle类用作携带数据，它类似于Map，用于存放key-value名值对形式的值。相对于Map，它提供了各种常用类型的putXxx()/getXxx()方法，如:putString()/getString()和putInt()/getInt()，putXxx()用于往Bundle对象放入数据，getXxx()方法用于从Bundle对象里获取数据。Bundle的内部实际上是使用了HashMap类型的变量来存放putXxx()方法放入的值。简单地说，Bundle就是一个封装好的包，专门用于导入Intent传值的包。

面试常客：Intent 能传递多大 Size 的数据？

一、序

作为 Android 开发，日常 Coding 时，最频繁的操作应该就是操作 App 内的一系列 Activity。而在 Activity 间传递数据，就需要借助 Intent。
不少资料中写到，Intent 在 Activity 间传递基础类型数据或者可序列化的对象数据。但是 Intent 对数据大小是有限制的，当超过这个限制后，就会触发 TransactionTooLargeException 异常。
那么今天就来聊聊 Intent 传递大数据时，为什么会抛异常，以及如何解决它。

二、为什么会出现异常？

2.1 异常原因

Intent 传递大数据，会出现 TransactionTooLargeException 的场景，这本身也是一道面试题，经常在面试中被问到。

其实这个问题，如果遇到了，查查文档就知道了。
在 TransactionTooLargeException(https://developer.android.com/reference/android/os/TransactionTooLargeException.html) 的文档中，其实已经将触发原因详细说明了。
简单来说，Intent 传输数据的机制中，用到了 Binder。Intent 中的数据，会作为 Parcel 被存储在 Binder 的事务缓冲区(Binder transaction buffer)中的对象进行传输。
而这个 Binder 事务缓冲区具有一个有限的固定大小，当前为 1MB。你可别以为传递 1MB 以下的数据就安全了，这里的 1MB 空间并不是当前操作独享的，而是由当前进程所共享。也就是说 Intent 在 Activity 间传输数据，本身也不适合传递太大的数据。

2.2 Bundle 的锅？

这里再补充一些细节，Intent 使用 Bundle 存储数据，到底是值传递(深拷贝)还是引用传递？
Intent 传输的数据，都存放在一个 Bundle 类型的对象 mExtras 中，Bundle 要求所有存储的数据，都是可被序列化的。
在 Android 中，序列化数据需要实现 Serializable 或者 Parcelable。对于基础数据类型的包装类，本身就是实现了 Serializable，而我们自定义的对象，按需实现这两个序列化接口的其中一个即可。
那是不是只要通过 Bundle 传递数据，就会面临序列化的问题？
并不是，Activity 之间传递数据，首先要考虑跨进程的问题，而 Android 中又是通过 Binder 机制来解决跨进程通信的问题。涉及到跨进程，对于复杂数据就要涉及到序列化和反序列化的过程，这就注定是一次值传递（深拷贝）的过程。
这个问题用反证法也可以解释，如果是引用传递，那传递过去的只是对象的引用，指向了对象的存储地址，就只相当于一个 Int 的大小，也就根本不会出现 TransactionTooLargeException 异常。
传输数据序列化和 Bundle 没有关系，只与 Binder 的跨进程通信有关。
为什么要强调这个呢？
在 Android 中，使用 Bundle 传输数据，并非 Intent 独有的。例如使用弹窗时，DialogFragment 中也可以通过 setArguments(Bundle) 传递一个 Bundle 对象给对话框。
Fragment 本身是不涉及跨进程的，这里虽然使用了 Bundle 传输数据，但是并没有通过 Binder，也就是不存在序列化和反序列化。和 Fragment 数据传递相关的 Bundle，其实传递的是原对象的引用。
有兴趣可以做个试验，弹出 Dialog 时传递一个对象，Dialog 中修改数据后，在 Activity 中检查数据是否被修改了。

三、如何解决这个异常？

3.1 解决思路

知道异常的原因，就好解决了。
既然原因在于 Binder 传输限制了数据的大小，那我们不走 Binder 通信就好了。
可以从数据源上来考虑。
例如 Bitmap，本身就已经实现了 Parcelable 是可以支持序列化的。用 Intent 传输，稍微大一点的图一定会出现 TransactionTooLargeException。当然真是业务场景，肯定不存在传递 Bitmap 的情况。
那就先看看这个图片的数据源。Drawable？本地文件？线上图片？无论数据源在哪里，我们只需要传递一个 drawable_id、路径、URL，就可以还原这张图片，无需将这个 Bitmap 对象传递过去。大数据总有数据源，从数据源还原数据，对我们而言只是调用一个方法而已。
此前阿里发布的《Android 开发者手册》中，就提到了这个问题的解决建议。

阿里给出的方案，是通过 EventBus 来传递数据。

3.2 EventBus 的 粘性事件

很多商业项目其实都用到了 EventBus，这里就简单介绍如何使用 EventBus 的粘性事件来完成数据在 Activity 间的传递。
EventBus 是一个 Android 端优化的 Publish/subscribe 消息总线，简化了应用程序内各个组件间、组件与后台线程间的通信。
在 Activity 中使用 EventBus，需要根据 Activity 的生命周期，成对调用 register() 和 unregister() 方法。普通的事件，只会发生在 register() 之后，在注册前发生的事件，统统都收不到。
这里利用的 EventBus 的粘性事件(Sticky Event)来实现，EventBus 内部维护了一个 Map 对象 stickyEvents，用于缓存粘性事件。
粘性事件使用 postSticky() 方法发送，它会将事件缓存到 stickyEvents 这个 Map 对象中，以待下次注册时，将这个事件取出，抛给注册的组件。以此来达到一个粘性的滞后事件发送和接收。
接下来我们看看 EventBus 粘性事件的使用细节。
1. 注解的区别
粘性事件的注解和普通事件的注解略有区别，需要添加 threadMode 和 sticky 参数。

@Subscribe(threadMode = ThreadMode.MAIN,sticky = true)
public void onStickyEvent(MyStickyEvent event){
    //...
}

注意，这两个额外的参数是必须的。
2. 调用方法的区别
在发送消息的时候，需要使用 postSticky() 来替换掉 post() 方法。
需要注意的是，粘性事件是使用 Map 结构缓存的，并且是使用事件对象类型当 Key 进行缓存，所以对于同类型的数据，它只会缓存最后发送的数据。
3. 注意清理事件
前面也提到，粘性事件是存储在一个 Map 对象中的，它是不会主动清理其中存储的对象的，需要开发者手动清理。
EventBus 提供了两类方法 removeStickyEvent() 和 removeAllStickyEvents() 方法，分别用来清理固定数据以及全部数据。
我们需要在合适的时机，手动的调用这两类方法，清理粘性事件。如果不对粘性事件进行清理，每次 register() 的时候，都会收到粘性事件。
4. EventBus 粘性事件的问题
粘性事件本身是脱离了 Android Intent 数据传递的这一套机制的，要知道 Activity 会在一些特殊情况下被销毁重建，在此情况下，通过 Intent 传递的数据，是可以继续从 Intent 中获取恢复到上一次页面传递的数据。
而通过 EventBus 的粘性事件，则可能在销毁重建时，造成数据丢失。
如果想要使用 EventBus 的粘性事件，来在页面间传递大数据，还是有不少细节，需要根据业务来调整的。

四、小结时刻

今天我们聊到了在 Activity 间，通过 Intent 传递大数据会触发 TransactionTooLargeException 异常的原因，以及如何解决它，最后再简单总结一下。

1. Intent 无法传递大数据是因为其内部使用了 Binder 通信机制，Binder 事务缓冲区限制了传递数据的大小。
2. Binder 事务缓冲区的大小限定在 1MB，但是这个尺寸是共享的，也就是并不是传递 1MB 以下的数据就绝对安全，要视当前的环境而定。
3. 不要挑战 Intent 传递数据大小的极限，对于大数据，例如长字符串、Bitmap 等，不要考虑 Intent 传递数据的方案。
4. 解决大数据传递问题，可以从数据源出发，根据数据的标识，还原数据，或者先持久化再还原。也可以使用 EventBus 的粘性事件来解决。

   reference：https://developer.android.com/reference/android/os/TransactionTooLargeException.html https://www.wanandroid.com/blogimgs/a2609aed-1000-4039-93c3-7541aaa2013b.pdf

【架构】Android较为理想的界面同步机制

深入了解架构组件之ViewModel

[LiveData](https://developer.android.com/reference/androidx/lifecycle/LiveData?hl=zh-cn) 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。

自己动手——快速搭建Android应用服务器

ContentLoadingProgressBar

ContentLoadingProgressBar实现了一个ProgressBar，它在显示之前等待最少的时间被消除。一旦可见，进度条将在最短的时间内可见，从而避免事件可能花费很大的时间（从无到用户可感知的时间）完成时，避免在UI中出现“闪烁”

ProgressDialog过时（废弃）的替代方案

如果想模仿ProgressDialog出现时，用户无法与界面继续交互的效果

getWindow().setFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE, WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

恢复用户与界面的交互
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

线程的中断(interrup)

现在已经不提倡使用stop方法来停止线程，因为那是不安全的，最好的停止线程方式是定义一个类成员变量，然后在循环过程中去判断此变量是否为假，便退出当前循环。但如果线程正在sleep()或wait()中，便无法使用类成员变量来判断，此时可以使用interrup()方法离开run()方法，同时结束线程，但程序会抛出InterruptedException异常。使用如下：

当在开发中遇到需要在activity关闭的时候关闭线程时：
1.可以在线程的Run方法里面设置标记手动关闭. （使用停止的标记位,那么可以保正在真正停止之前完整的运行完）
2.调用Thread.stop()方法也可以，但是会出问题（使用Thread.stop方法停止线程,不能保证这个线程是否完整的运行完成一次）

// 线程类
class MyThread extends Thread {
    volatileboolean mStop = false;         //volatile 用来修饰被不同线程访问和
    @Override
    public void run() {
        while(!mStop) {
            try{
               Thread.sleep(1000);
               // TODO...
            }catch (InterruptedException e) {
               e.printStackTrace();
            }
        }
    }
}
// 启动线程
MyThread myThread = new MyThread();
myThread.start();
// 停止线程
myThread.mStop = true;
myThread.interrupt();

还有另外一个思路来让线程可以及时回收，我们知道context对象与activity是绑定的，我们可以实例application来暂存当前context与当前context进行比较，我们可以优化上面的代码，具体代码如下：

自定义application用来暂存context对象：

public class MyApplication extends Application {
static Context appContext;

@Override
public void onCreate() {
super.onCreate();
}

public static void setContext(Context context) {
appContext = context;
}
}
让线程去做context比较，这样我们就可以忽略activity的生命周期：
private MyThread myThread;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

MyApplication.setContext(this);
myThread = new MyThread(this);
myThread.start();

}

private class MyThread extends Thread {

private boolean stop = false;

private Context context;

public MyThread(Context context) {
this.context = context;
}

@Override
public void run() {
super.run();
while (context == MyApplication.appContext) {
try {
Thread.sleep(1000);
Log.i(“———-“, “running”);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

线程礼让(yield)

sleep()方法使当前运行中的线程睡眠一段时间，这段时间的长短是由参数设定的，yield()方法使当前线程让出CPU占有权，但让出的时间是不可设定的，而且也不会释放锁标志。

使用yield()方法可使同样优先级的线程有进入可执行状态的机会，如果没有相同优先级的线程或者被礼让线程放弃执行权时，原线程会再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用yeild()方法，因为操作系统会为线程自动分配CPU时间片来执行。

线程的优先级

Thrread类中包含的成员变量代表了线程的某些优先级，比如Thread.MIN_PRIORITY（常数1）、Thread.MAX_PRIORITY（常数2）、Thread.NORM_PRIORITY（常数5）。其中每个线程的优先级都在Thread.MIN_PRIORITY ~ Thread.MAX_PRIORITY之间，默认是Thread.NORM_PRIORITY。

线程的优先级可使用setPriority()方法调整，如果使用该方法设置的优先级不在1~10之内，将产生IllegalArgumentException异常。

线程同步（synchronized）

单一程程序中，每次只能做一件事情，它是串行执行的；但多线程程序是可以异步并发处理同一件事情，这样就会发生两个线程抢占资源的问题，使如一个线程定在写数据，而另一个线程刚才在读数据，那么就会产生很多未知的错误情况出现，这也是多线程最危险的事情。

同步块

Java中提供了同步机制，可以有效地防止资源冲突。使用关键字synchronized。如：

public class Person {   
    privateString mName;
    public void setName(String name) {
        synchronized(mName){
           this.mName = name;
        }
    }
}

这里要锁定的是对象类成员变量mName,而且只有在同一个Person对象才行效，否则是互不影响的。比如Person A = new Person()和Person B = newPerson()中，A和B之间是不受synchronized制约的。

public class Person{
    privateString mName;
    public void setName(String name) {
       synchronized(Person.class) {
           this.mName = name;
        }
    }
}

上面这锁是对类级别的，锁定的是Person.class，不管是否同一对象，都会实行同步机制。

使用synchronized用来修饰方法

基本执行过程：当多个线程同时访问被synchronized修饰的方法的时候，有且只有一个线程可以访问，当一个线程在访问的时候，其他线程只能等待。当一个线程访问完毕后下一个线程才可以访问。
原理解析：当方法被synchronized修饰后，如果想要执行该方法就必须获得相应的锁。
锁的说明：每个类又且仅有一个锁（针对静态方法），每个类的示例也是有且仅有一个锁。
当多个线程在同时访问同一个方法的时候，执行该方法就必须获得相应的锁，同时锁只有一个，所以只能有一个线程可以获得锁，所以只有一个线程可以执行，当方法执行完毕，线程会释放锁，其他线程获取该锁，执行方法。
进阶说明：由于每个类只有一个锁，所以当一个类中又多个方法被synchronized修饰的时候，在同一时间内只有一个方法可以获得锁，所以只有一个方法可以执行。

使用synchronized用来修饰代码块

基本说明：当synchronized在修饰代码块的时候需要一个自定义锁，当在多线程访问，代码块的时候，只要获得自定义锁就可以执行。
自定义锁：可以是一个类，也可以是一个实例（可以是Objcet的子类，也可以是当前类自己（this）），当具有相同自定锁的时候，代码块会顺序去执行，当锁不同的时候互相不影响。

（
synchronized(任意自定义对象)与synchronized同步方法共用：使用synchronized(任意自定义对象)进行同步操作，对象监视器必须是同一个对象。不过不是同一个，运行就是异步执行了。）

每个类又且仅有一个锁（针对静态方法），每个类的示例也是有且仅有一个锁。
基本书写格式：synchronized（自定义锁）{同步执行代码块}

关于两种方法的使用：对于修饰方法常常会发生不必要的代码块被同步，同时锁不可以选择，但是使用 简单。对于修饰代码块方法用起来更精确，需要自己制定锁，用起来稍微麻烦一点。

作者：沈凤德
链接：https://www.jianshu.com/p/35af333fdde4
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

静态同步synchronized方法与synchronized(*.class)代码块

synchronized应用在static方法上，那是对当前对应的*.Class进行持锁。

同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。Class锁对类的所有对象实例起作用。

最典型的单例

    private volatile static Test sTest = null;
    private Test () {}
    public static Test getInstance() {
        if (sTest == null) {
            synchronized (Test.class) {
                if (sTest == null) {
                    sTest = new Test();
                }
            }
        }
        return sTest;
    }

附加说明：
1.volatile修饰的变量，在一个线程中被改变时会立刻同步到主内存中，而另一个线程在操作这个变量时都会先从主内存更新这个变量的值。
2.第一个判空是为了避免不必要的同步，第二层判断是为了在null 情况下创建实例

线程间的通信

调用wait()方法和sleep()方法都可以使线程从运行状态进入就绪状态，而sleep()方法的线程是不释放锁的，wait()方法只能在同步块或同步方法中使用，wait()方法的线程是释放锁的。wait()可带参数或不带参数，其中wait(time)的情况跟sleep(time)一样，在一定时间内暂停；而如果wait()无参数情况下是永久无限地等待下去，需要使用notify()或notifyAll()方法才能唤醒。

异步转同步CountDownLatch

CountDownLatch，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。简单地说就是有A和B两个方法都是异步执行，由于某些需求，想让A方法执行完之后再执行B方法。

Atomic系列对象

在多线程下，像i++、++i之类的操作都是不安全的，在使用时不可避免的会用到synchronized关键字进行锁定对象，而Atomic系统对象则通过一种线程安全的操作方法，是以原子方式更新对应值，从而可以不使用synchronized关键字情况下也能达到预期安全效果，而且效率还有可能比synchronized略高，Atomic系列对象有：AtomicBoolean、AtomicInteger、AtomicLong，等。

CopyOnWriteArrayList

CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。

这一般需要很大的开销，但是当遍历操作的数量大大超过可变操作的数量时，这种方法可能比其他替代方法更有效。在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时，它也很有用。“快照”风格的迭代器方法在创建迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作（remove、set和add）不受支持。这些方法将抛出UnsupportedOperationException。允许使用所有元素，包括null。
参考

android 如何正确循环删除list中的数据

当我们使用for循环删除列表中的数据的时候，会存在问题，因为ArrayList的父类AbstractList里有个modCount的字段记录着List的总数，for循环的时候如果增加或者删除了元素，（修改不会影响），此字段会变化，那么在下次for循环的时候检查到跟之前的长度不同（删除后break循环没事），此时会报ConcurrentModificationException异常。

如何正确遍历删除List中的元素，你会吗？

1.通过增强的for循环删除符合条件的多个元素
2.通过增强的for循环删除符合条件的一个元素
3.通过普通的for删除删除符合条件的多个元素
4.通过Iterator进行遍历删除符合条件的多个元素

import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.List;  
public class ListRemove {  
    public static void main(String args[]) {  
        ListRemove lr = new ListRemove();  
        lr.listRemove();  
        lr.listRemoveBreak();  
//      lr.listRemove2();  
//      lr.iteratorRemove();  
    }  
    /** 
     * 使用增强的for循环 
     * 在循环过程中从List中删除元素以后，继续循环List时会报ConcurrentModificationException 
     */  
    public void listRemove() {  
        List<Student> students = this.getStudents();  
        for (Student stu : students) {  
            if (stu.getId() == 2)   
                students.remove(stu);  
        }  
    }  
    /** 
     * 像这种使用增强的for循环对List进行遍历删除，但删除之后马上就跳出的也不会出现异常 
     */  
    public void listRemoveBreak() {  
        List<Student> students = this.getStudents();  
        for (Student stu : students) {  
            if (stu.getId() == 2) {  
                students.remove(stu);  
                break;  
            }  
        }  
    }  
    /** 
     * 这种不使用增强的for循环，每次重新获取list的size遍历的情况运行时不会报错，但是可能删除的结果是错的。 
     */  
    public void listRemove2() {  
        List<Student> students = this.getStudents();  
        for (int i=0; i<students.size(); i++) {  
            if (students.get(i).getId()%2 == 0)  
                students.remove(i);  
        }  
    }  
    /** 
     * 使用Iterator的方式也可以顺利删除和遍历 
     */  
    public void iteratorRemove() {  
        List<Student> students = this.getStudents();  
        System.out.println(students);  
        Iterator<Student> stuIter = students.iterator();  
        while (stuIter.hasNext()) {  
            Student student = stuIter.next();  
            if (student.getId() % 2 == 0)  
                stuIter.remove();  
        }  
        System.out.println(students);  
    }  
    private List<Student> getStudents() {  
        List<Student> students = new ArrayList<Student>() {  
            {  
                int i = 0;  
                while (i++ < 10) {  
                    Student student = new Student(i, "201200" + i, "name_" + i);  
                    this.add(student);  
                }  
            }  
        };  
        return students;  
    }  
}