非花非雾--
非花非雾--

android，java只是知识点总结

List  ,HashMap  ,set ,HashTable ,eventBus ,LitPal  ,OkHttp   ,Glide ,热修复，线程安全，线程池，6.0以及5.0权限管理，7.0分屏画中画；材料设计语言，蓝牙，wifi，ViewDrapHelper,动画，排序，RandomAccess,Rxjava，注解，设计模式。类设计，项目结构设计。功能设计。泛型数据结构。SqlLiteOpenHelper。内存泄漏。adb命令等等

1、使用aapt进行apk信息的查看

 

aapt  dump dadging   跟上apk路径

（必须要注意要配置aapt 环境变量）


2、特殊字符在string.xml中需要进行转义

一般需要注意的就是< 、> 、@，?等等

可以使用" ]]>  类似这样进行包装；

也可以是使用 \ ,使用

比如颜文字

   

        ⊙▽⊙

        ( ؕؔʘ̥̥̥̥ ه ؔؕʘ̥̥̥̥ )?

        ( •̅_•̅ )

        " ]]>

        (๑￣ ̫ ￣๑)

        눈_눈

        ᕙ(⇀‸↼‵‵)ᕗ

        ( ・᷄ ᵌ・᷅ )

        (৹ᵒ̴̶̷᷄﹏ᵒ̴̶̷᷅৹)

        ( ˉ ⌓ ˉ ๑)

        o(〃\'▽\'〃)o

        ₍₍ (̨̡ ‾᷄ᗣ‾᷅ )̧̢ ₎₎

        ( ¬_¬)

        (　ﾟ皿ﾟ)

        (▭-▭)✧

        π_π

        (¬ω¬)

        (｡•ˇ‸ˇ•｡)

        (｡･ω･｡)ﾉ♡

        ू(ʚ̴̶̷́ .̠ ʚ̴̶̷̥̀ ू)

        ლ(●ↀωↀ●)ლ

        (ﾉ￣д￣)ﾉ

        ⸂⸂⸜(രᴗര๑)⸝⸃⸃

        -_-||

        ɿ(｡･ɜ･)ɾ

        p(´⌒｀｡q)

        ⊙ω⊙

        ꉂ ೭(˵¯̴͒ꇴ¯̴͒˵)౨”

        (ღ˘⌣˘ღ)

        →_→

        〜(￣△￣〜)

        ←_←

        ؏؏☝ᖗ乛◡乛ᖘ☝؏؏

        \@_@

        (^３^)

        ≥﹏≤

        ^ω^

        ^_^

        \^O^/

        T_T

        ◑▂◐

        -_-#

   


3、android EditText 在获取到焦点的时候就会弹出软键盘，然后是不会执行onClick方法的，因为第一次点击如果是没有获取到焦点的话首先会获取焦点，然后下一次点击才会执行onCLick,如果需要首先执行onCLick的话，那么就要在布局中设置

android:clickable="true"

android:focusableInTouchMode=“false"


然后点击的时候会执行onClick，然后在里边可以设置

mEditText.setFocusable(true);

mEditText.setFocusableInTouchMode(true);

mEditText.requestFocus();

mEditText.requestFocusFromTouch();


然后就可以获取到焦点，然后在做软键盘的弹出


4、EditText 添加onScrollListener ，只在5.0以上（不包括5.0）有这个方法，必须要保证最小编译版本在23


5、关于List源码学习：


List 是一个接口，它继承了Collection接口，Collection继承了Iterable接口，


Iterable里边定义了Iterator，foreach，spliterator这么三个方法

Collection继承了以后在里边添加了add ，remove，clear，hashCode，equals,spliterator,retainAll,

addAll,removeAll,toArray,containsAll,contains等方法

List在继承了以后添加了get，set，indexOf，lastIndexOf，listIterator，subList，replaceAll，sort这几个方法。


我们在使用List的时候都是使用它的实现类ArrayList，LinkedList，Vector。


ArrayList的实现：

在实现了List接口以后我们会重写里边所有的方法，然后实现对应的功能，

ArrayList还继承了AbstracList这个抽象类，这个类继承自AbstractCollection，然后实现了List接口（抽象类的主要作用就是实现共有部分功能）


但是大部分功能都是在ArrayList中进行的实现。

ArrayList提供了三个构造方法

   1、默认的无参构造方法，默认长度为10

    public ArrayList() {

        super();

        this.elementData = EMPTY_ELEMENTDATA;

    }


2、指定集合长度

 public ArrayList(int initialCapacity) {

        super();

        if (initialCapacity < 0)

            throw new IllegalArgumentException("Illegal Capacity: "+

                                               initialCapacity);

        this.elementData = new Object[initialCapacity];

    }

3、以集合为参数 

    public ArrayList(Collection c) {

        elementData = c.toArray();

        size = elementData.length;

        // c.toArray might (incorrectly) not return Object[] (see 6260652)

        if (elementData.getClass() != Object[].class)

            elementData = Arrays.copyOf(elementData, size, Object[].class);

    }


其中的elementData是一个object类型的数组，用来存放集合中的元素。

集合默认长度为10，如果要添加的元素超过了这个长度就会进行扩容，

调用ensureCapacity，ensureExplicitCapacity，ensureExplicitCapacity，grow（）

private void grow(int minCapacity) {

        // overflow-conscious code

        int oldCapacity = elementData.length;

        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)

            newCapacity = minCapacity;

        if (newCapacity - MAX_ARRAY_SIZE > 0)

            newCapacity = hugeCapacity(minCapacity);

        // minCapacity is usually close to size, so this is a win:

        elementData = Arrays.copyOf(elementData, newCapacity);

    }


最后是通过Arrays的copyOf方法复制一个新的长度为newCapacity的数组，新的长度就等于老的长度除以2 + 老的长度，然后在进行下边的判断计算最终的长度。


所以从这些流程可以看到ArrayList在数据频繁添加的过程中会有频繁的扩容操作，因为会有数组的copy过程，如果数据量很大的时候会影响性能，最后是能确定他的最终大小，在初始化的时候直接申请。

而且ArrayList是基于数组来进行数据元素的存储，所以在插入的过程中都会有元素的移动，插入速度相当慢。

查询



6 、adb monkey测试  add monkey -p “包名”  -v “次数”


7、关于进入手机设置界面

可以通过抓包来获取当前ActivityManager来获取，当前跳转的activity的信息。下边是adb 命令

adb logcat | grep ActivityManager


 进入系统设置的所有界面都可以通过Intent


只要设置不同的Settings就可以

Intent appIntent = new Intent();

appIntent  = new Intent(Settings.ACTION_SETTINGS);

context.startActivity(appIntent);


只要替换Settings的值就可以，

如果要进入其中一个应用的详情设置了Settings以后的话还需要传递包名   appIntent.setData(Uri.parse("package:" + context.getPackageName()));



但是android系统没有专门的权限管理。

如果要进入权限管理必须要对不同系统进行区别，然后根据不同的定制系统来进行处理跳转。

//vivo权限管理界面

 appIntent.setClassName("com.iqoo.secure", "com.iqoo.secure.safeguard.PurviewTabActivity"); 



然后可以通过adb 命令来启动一个页面

db shell am start -n com.android.settings/com.letv.leui.settings.LeUIMainSettings




8、关于EventBus源码学习


EventBus 的学习首先从 EventBus这个类开始。


这个类主要是用来进行EventBus的初始化，注册反注册，发送事件或者移除事件，是整个工具所暴露的可以进行操作的一个工作接口。


EventBus在初始化上边有俩种方式：

（1）、通过getDefault()

（2）、通过new EventBus（）

但是实际创建方式都是通过Builder（建造者模式来进行创建）

跟所有的建造者模式一样，都是通过一个私有的构造方法以EventBusBuilder对象为参数来进行对象的创建。


然后调用register来进行注册。在调用register这个方法的时候会传递一个要注册的对象的。

然后会通过反射来获取这个对象中的所有的方法。然后会通过方法来找到其中订阅了EventBus的事件的方法。然后通过subscribe这个方法，把这些方法添加到订阅列表中。

  public void register(Object subscriber) {

        Class subscriberClass = subscriber.getClass();

        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

        synchronized (this) {

            for (SubscriberMethod subscriberMethod : subscriberMethods) {

                subscribe(subscriber, subscriberMethod);

            }

        }

    }


反注册的流程与一般的订阅者都是一样的，把订阅的方法都从订阅队列进行删除。



剩下的就是事件的发送：


因为整个EventBus的架构就是观察者模式。


所以事件发送其实就是通过EventBus对象对所有订阅了这个事件的订阅者进行通知，然后在他订阅的方法里边就可以进行处理。

    public void post(Object event) {

        PostingThreadState postingState = currentPostingThreadState.get();

        List eventQueue = postingState.eventQueue;

        eventQueue.add(event);


        if (!postingState.isPosting) {

            postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();

            postingState.isPosting = true;

            if (postingState.canceled) {

                throw new EventBusException("Internal error. Abort state was not reset");

            }

            try {

                while (!eventQueue.isEmpty()) {

                    postSingleEvent(eventQueue.remove(0), postingState);

                }

            } finally {

                postingState.isPosting = false;

                postingState.isMainThread = false;

            }

        }

    }


然后postSingleEvent ->postSingleEventForEventType->postToSubscription 然后执行真正的事件发送。

  private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {

        switch (subscription.subscriberMethod.threadMode) {

            case POSTING:

                invokeSubscriber(subscription, event);

                break;

            case MAIN:

                if (isMainThread) {

                    invokeSubscriber(subscription, event);

                } else {

                    mainThreadPoster.enqueue(subscription, event);

                }

                break;

            case BACKGROUND:

                if (isMainThread) {

                    backgroundPoster.enqueue(subscription, event);

                } else {

                    invokeSubscriber(subscription, event);

                }

                break;

            case ASYNC:

                asyncPoster.enqueue(subscription, event);

                break;

            default:

                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);

        }

    }

说是发送，其实是通过反射来调用被订阅的方法。（只要我们能拿到被订阅的方法所在的类的对象，就可以执行他里边的方法）

也就是通过EventBus中的invokeSubscriber方法

    void invokeSubscriber(PendingPost pendingPost) {

        Object event = pendingPost.event;

        Subscription subscription = pendingPost.subscription;

        PendingPost.releasePendingPost(pendingPost);

        if (subscription.active) {

            invokeSubscriber(subscription, event);

        }

    }


    void invokeSubscriber(Subscription subscription, Object event) {

        try {

            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);

        } catch (InvocationTargetException e) {

            handleSubscriberException(subscription, event, e.getCause());

        } catch (IllegalAccessException e) {

            throw new IllegalStateException("Unexpected exception", e);

        }

    }


还有些要注意的类，就是HandlerPoster，这个类主要是维护了一个队列，用来管理要发送的事件。他的内在实现其实是通过Handler来进行的。handler就不需要多说了。

AsyncPoster 异步Poster，通过实现Runnable，通过ExectorService 进行线程管理。

BackgroundPoster后台Poster，通过实现Runnable进行实现，通过ExectorService 进行线程管理。

它使用的是Executors.newCachedThreadPool创建的缓存线程池。具体什么事缓存线程池可以看相关的文章。

private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();



总结：

EventBus的整体架构是通过 观察者模式来进行事件的订阅，然后在订阅的事件发生了改变以后通知所有的订阅者。在这个过程中使用到了反射来进行。在订阅的时候通过反射获取到当前对象所定于的方法，在有改变的通过反射执行被订阅的方法，然后就可以处理自己的逻辑。  

在发送事件的时候（post）我们会判断当前事件是在什么线程中执行。然后做相应的处理。

对与事件处理主要使用了Handler（初始化的时候默认是主线程Handler），

使用线程池进行事件的管理。

里边用到了多线程的并发处理：使用ThreadLocal  ，CopyOrWriteArrayList；synchronized。

ThreadLocal 会为每一个线程创建一个副本对象，CopyOrWirteArrayList是通过copy一份数据，然后在Write的时候通过创建一个新的对象，然后对新的对象进行write，然后把新对象赋值给旧对象来保证线程安全。读取的时候通过使用旧的对象来进行，因为读取是不需要关注线程安全问题。

synchronized同步锁，只有持有这个方法的所的对象才能进入这个方法，其他的都要等待。



9、关于RecycleView的使用

使用RecyvleView的方式很简单，跟使用ListView，GridView类似，只是RecycleView可以实现比这俩个控件更多的功能。只要通过LayoutManager进行设置。


RecycleView没有onItemClickListener，需要自己实现。

RecycleView 如果有错位的问题，那么肯定也是跟ListView一样因为复用引起的，其实修改原理都类似。个人觉得只要把复用的View里边的参数都还原成最初的状态（如果view成为最原始的状态，那么只要数据没有问题，就不会有错位的事了），然后通过tag来进行判断，然后在更新View即可。


RecycleView的adapter里边强制使用VIewHolder。为了减少重复创建对象的消耗（主要是会影响性能）。


RecycleView 滚动条的设置使用的是View的通用滚动条设置。

        android:scrollbars=“horizontal"  //设置滚动条的方向

        android:scrollbarAlwaysDrawHorizontalTrack=“true" //设置总是绘制横向滚动条

        android:scrollbarThumbHorizontal=“@drawable/scrollbar_line”//横向滚动条

        android:scrollbarTrackHorizontal=“@drawable/scrollbar_line_track”//横向滚动条的轨道

        android:paddingBottom="20dp"

        android:scrollbarStyle=“outsideInset" //设置显示的位置

        android:fadeScrollbars=“false" //是否一直显示


如果要设置不一样粗细的滚动条与轨道，可以通过使用不同粗细的进度图片来实现，也可以通过

使用shape来自定义滚动条与轨道，自定义的时候滚动条的高度要比轨道的高，这样横向滚动条与轨道就会不一样粗细。


10、fresco是一个很强大的图片加载库，不同的功能都有相对应的库模块来处理。


11、android中点击电源键关闭屏幕的话。如果现在屏幕是竖屏没有任何影响，如果是横屏，会销毁activity，然后在启动这个Activity 。会导致activity数据的丢失。如果只是数据可以通过onSaveInstance进行保存，但是如果正在进行通话或者长连接的功能，会导致功能中断。

解决方式：1、使屏幕常亮

2、设置activity的 

android:configChanges=“orientation|keyboardHidden|screenSize"


12、jni 编译  ：

 （1）首先项目的sdk地址

创建native方法，然后点击studio的make project生成class文件

 （2）然后切换到项目package目录下 （例如 com.xxx.xxx.xx）

        调用 javaH -d  ../jni “包名 + 类名”

  然后会在jni文件夹下生成.h头文件。

然后创建c或c++文件，进行代码的编写，可以直接复制头文件到c或c++文件中。

提供的头文件里边的参数需要自定义名称。是一个空的实现。

（3）配置app.gradle文件 

ndk {


            moduleName"jnilib"


            ldLibs "log", "z", "m"


            abiFilters "armeabi", "armeabi-v7a", "x86"


        }


如果不知道studio支持的ndk可编译版本可以在gradle.properties添加

android.useDeprecatedNdk=true//可使用过时版本


(如果使用studio编译以后运行出现dlopen failed: cannot locate symbol "__aeabi_memcpy" referenced by “/data/app/com.example.chenpengfei.uninstallreceiver-2/lib/arm/libjnilib.so”，那么是因为sdk版本的问题，23及以下，或者更新studio到最新版本)



13、LinkedList源码学习：

关于LinkedList 类的功能来说，也是一个集合容器类，实现了List接口，但是他内部的数据结构跟ArrayList不一样，使用的是链表。而实现链表主要是通过Node这个类。


他继承了AbstractSequentialList，而这个类其实是继承了AbstractList。

他与ArrayList不一样的就是他实现了Deque接口。


因为它是基于Node实现的列表，那么需要关注的就是Node这个类

private static class Node {

        E item;

        Node next;

        Node prev;


        Node(Node prev, E element, Node next) {

            this.item = element;

            this.next = next;

            this.prev = prev;

        }

    }


这个类会保存它上一个节点node，跟下一个节点node。


如果是有俩个节点那么a 节点的next指向b节点 ，pre也指向b，b的pre指向a，next也指向a，这样就形成了一个闭环。实现了双向链表。


如果是三个的话  a 节点的next 指向b ，pre指向c，b 节点的next 指向c，pre指向a，而c节点的next指向a，pre指向b。这样也是一个闭环。


所以LinkedList存储数据的时候特别快。直接把节点的指向改变了就可以了。

但是存储的时候也分几种情况：

如果是直接添加的话不管是添加到首部还是尾部都直接修改节点指向，但是如果是指定下标来进行添加的话，会折半查找到下边的node节点，然后在该节点处修改节点指向。速度会慢点。

但是查询的时候就需要类似上边的折半以后进行查找，然后返回该节点。速度就会比ArrayList慢很多。毕竟人家是实现了RendemAsscess接口，而且内部结构是array，查询没的比啊。



14、Vector源码学习

通过学习ArrayList 与LinkedList以后在学习Vector发现没有太多要注意的地方。

因为Vector是跟ArrayList基本上完全相同的，只是在某些地方有点区别。

Vector是线程安全的，在很多方法上都加了线程锁，synchronize，实现同步。内部结构完全就是ArrayList的结构，只是在容量扩展的时候

这是Vecctor的容量扩展

    private void grow(int minCapacity) {

        // overflow-conscious code

        int oldCapacity = elementData.length;

        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?

                                         capacityIncrement : oldCapacity);

        if (newCapacity - minCapacity < 0)

            newCapacity = minCapacity;

        if (newCapacity - MAX_ARRAY_SIZE > 0)

            newCapacity = hugeCapacity(minCapacity);

        elementData = Arrays.copyOf(elementData, newCapacity);

    }

这是ArrayList的容量扩展

    private void grow(int minCapacity) {

        // overflow-conscious code

        int oldCapacity = elementData.length;

        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)

            newCapacity = minCapacity;

        if (newCapacity - MAX_ARRAY_SIZE > 0)

            newCapacity = hugeCapacity(minCapacity);

        // minCapacity is usually close to size, so this is a win:

        elementData = Arrays.copyOf(elementData, newCapacity);

    }


可以发现在进行容量扩展的时候 newCapacity的值在取值的时候有点区别

ArrayList是直接扩展为原来容量的3/2,但是Vector因为有 一个容量扩充的参数capacityIncrement

，如果不为0，那么每次扩展是在原来的基础上增加capacityIncrement的长度，否则就是原来的2倍。


因为跟ArrayList很相似，学习的过程中发现比较一下这几个实现了List接口的类更有用：


ArrayList、Vecotr、LinkedList的区别（源码角度）：


区别:

1、ArrayList、Vector使用的是数组的数据结构来进行数据的存储，实现了RandomAccess接口提供快速随机访问。 而LinkedList是通过链表这样的数据接口来存储数据，他实现了Deque接口，在随机访问方面性能很差，因为需要遍历这个链表中的节点（虽然是折半以后的遍历，但是一样很慢）

2、容量扩展对于LinkedList来说是没有任何关系的，因为它不需要。但是对于ArrayList于Vector来说这是很重要的点。因为他们的初始容量都是10，除非你指定了他的容量。但是在把数据进行添加的过程中，他们会检查容量是否足够存放数据，如果不够就要进行容量的扩展。容量的扩展是通过创建一个新的容量的数组，然后指向上一个数组对象，创建的方式是调用一个系统的arrayCopy方法。

数据量很大的话对与性能有很大影响，使用的时候根据需要可以指定初始容量。

这就是他们之间的又一个不同点，插入效率，很明显LinkedList很快，但是Vector与ArrayList很慢


Android 虚拟现实开发

开发者中心地址：https://vr.google.com/daydream/developers/


按需要下载自己需要的sdk已经开发工具


15、HashMap源码学习

 HashMap是一个存储键值对的容器类，通过学习他的源码来熟悉他的实现。

首先说下HashMap 1.8之前，最基本的实现是通过维护一个Entry[]的数组已经单链表来实现的数据存储。


就是当我们在创建一个HashMap以后，通过调用put方法，会进行很多判断，最后把我们要存放的数据添加到Entry[]数组中。

public V put(K key, V value) {  

    if (key == null)  

        return putForNullKey(value);  

    // 得到key的哈希码  

    int hash = hash(key);  

    // 通过哈希码计算出bucketIndex  

    int i = indexFor(hash, table.length);  

    // 取出bucketIndex位置上的元素，并循环单链表，判断key是否已存在  

    for (Entry e = table[i]; e != null; e = e.next) {  

        Object k;  

        // 哈希码相同并且对象相同时  

        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  

            // 新值替换旧值，并返回旧值  

            V oldValue = e.value;  

            e.value = value;  

            e.recordAccess(this);  

            return oldValue;  

        }  

    }  


    // key不存在时，加入新元素  

    modCount++;  

    addEntry(hash, key, value, i);  

    return null;  

}  

但是在1.8以后，为了实现快速查找，添加了红黑树。里边维护的数组变为了Node[]数组，一个实现Map.Entry接口的类。这应该是1.8改动最大的地方。


 1     public V put(K key, V value) {

 2     // 对key的hashCode()做hash

 3     return putVal(hash(key), key, value, false, true);

 4 }

 5

 6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

 7                boolean evict) {

 8     Node[] tab; Node p; int n, i;

 9     // 步骤①：tab为空则创建

10     if ((tab = table) == null || (n = tab.length) == 0)

11         n = (tab = resize()).length;

12     // 步骤②：计算index，并对null做处理 

13     if ((p = tab[i = (n - 1) & hash]) == null) 

14         tab[i] = newNode(hash, key, value, null);

15     else {

16         Node e; K k;

17         // 步骤③：节点key存在，直接覆盖value

18         if (p.hash == hash &&

19             ((k = p.key) == key || (key != null && key.equals(k))))

20             e = p;

21         // 步骤④：判断该链为红黑树

22         else if (p instanceof TreeNode)

23             e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);

24         // 步骤⑤：该链为链表

25         else {

26             for (int binCount = 0; ; ++binCount) {

27                 if ((e = p.next) == null) {

28                     p.next = newNode(hash, key,value,null);

                        //链表长度大于8转换为红黑树进行处理

29                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  

30                         treeifyBin(tab, hash);

31                     break;

32                 }

                    // key已经存在直接覆盖value

33                 if (e.hash == hash &&

34                     ((k = e.key) == key || (key != null && key.equals(k))))                                            break;

36                 p = e;

37             }

38         }

39        

40         if (e != null) { // existing mapping for key

41             V oldValue = e.value;

42             if (!onlyIfAbsent || oldValue == null)

43                 e.value = value;

44             afterNodeAccess(e);

45             return oldValue;

46         }

47     }

 

48     ++modCount;

49     // 步骤⑥：超过最大容量 就扩容

50     if (++size > threshold)

51         resize();

52     afterNodeInsertion(evict);

53     return null;

54 }

跟所有的容器类一样，这个类里边也定义size， modcout，loadFactor（负载因子），threshold(判断是否需要扩展的界限 他的值等于初始容量乘以 负载因子)，默认的初始容量是 1<< 4 ,


Hash主要是通过散列表来进行存储，通过计算key的hash值，然后计算要存放的下标，然后放到数组中对应的位置。如果计算出来的hash相同，那么比较key是否相等，如果相等，那么久覆盖旧值，返回旧值，如果不相同，那么创建Node对象，然后与该位置中的Node链表进行连接，使Node链表的最新的节点是新创建的Node对象。


HashMap的扩容是扩容为 原来的2倍。


因为HashMap是通过散列表来进行存储，所以会有空间的浪费，也就是用空间换取时间。

查找的时候通过计算key的hash值，然后计算在数组中的下标，可以快速的进行查找。

HashMap中使用链表主要是为了解决碰撞问题，也就是会有相同的Hash值的问题。




16、HashSet源码：


HashSet用来存放单一数据，不在是键值对，而且存储到其中的数据没有顺序，但是他可以保证数据不会重复（前提是你要重新hashCode 以及equals方法）。

因为HashSet的底层实现是通过HashMap来进行实现的。通过他的构造方法可以看到：

    public HashSet(int initialCapacity) {

        map = new HashMap<>(initialCapacity);

    }



   public HashSet(int initialCapacity, float loadFactor) {

        map = new HashMap<>(initialCapacity, loadFactor);

    }


 public HashSet(Collection c) {

        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));

        addAll(c);

    }



public HashSet() {

        map = new HashMap<>();

    }


如果对HashMap源码了解的话很简单就可以看懂。


HashSet提供了add方法进行数据的添加，也提供了容器类基本的功能。

比如删除，是否包含，是否为空等等。

使用HashSet的时候遍历数据是通过HashMap的KeySet这个类进行的。

final class KeySet extends AbstractSet {

        public final int size()                 { return size; }

        public final void clear()               { HashMap.this.clear(); }

        public final Iterator iterator()     { return new KeyIterator(); }

        public final boolean contains(Object o) { return containsKey(o); }

        public final boolean remove(Object key) {

            return removeNode(hash(key), key, null, false, true) != null;

        }

        public final Spliterator spliterator() {

            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);

        }

        public final void forEach(Consumer action) {

            Node[] tab;

            if (action == null)

                throw new NullPointerException();

            if (size > 0 && (tab = table) != null) {

                int mc = modCount;

                for (int i = 0; i < tab.length; ++i) {

                    for (Node e = tab[i]; e != null; e = e.next)

                        action.accept(e.key);

                }

                if (modCount != mc)

                    throw new ConcurrentModificationException();

            }

        }

    }



从这个可以看出，我们可以是用ForEach，或者迭代器。


HashSet实现数据不重复就是重写了HashCode以及Equals方法：

是在他所继承的AbstractSet这个类中书写的：


使用HashSet的时候要注意他不是线程安全的，需要重新要存放数据的HashCode 与Equals方法。

HashSet没有办法实现快速存取，如果需要如果需要获取到某一个位置的数据可以先调用 toArray方法转换为数组，然后进行查找.返回的数据顺序与插入的顺序相反。


HashMap的keySet的效率比entrySet效率低，因为keySet是通过迭代key来进行迭代，entrySet通过迭代Node对象来进行，不需要通过key进行value的查找，所以速度更快。



17、Popwindow源码学习：


关于popWindow的源码其中最主要的是show 以及dismiss的原理；

做过悬浮窗开发的人肯定知道，如果我们要创建一个悬浮在当前Activity或者这个android系统上边的话，需要使用到的一个类肯定是WindowManager，通过WindowManager的addView的方法添加到界面上去，如果只是添加到当前Activity的话



18、Toast源码学习

也是通过WindowManager来进行实现的。

toast主要是通过TN这个类来进行最终的显示以及隐藏，如果要自己来控制显示以及隐藏可以通过反射来获取Toast中的mTN对象，然后通过这个对象用反射来调用show以及dismiss。

Toast中TN源码：

private static class TN extends ITransientNotification.Stub {
        final Runnable mShow = new Runnable() {
            @Override
            public void run() {
                handleShow();
            }
        };

        final Runnable mHide = new Runnable() {
            @Override
            public void run() {
                handleHide();
                // Don't do this in handleHide() because it is also invoked by handleShow()
                mNextView = null;
            }
        };

        private final WindowManager.LayoutParams mParams = new WindowManager.LayoutParams();
        final Handler mHandler = new Handler();    

        int mGravity;
        int mX, mY;
        float mHorizontalMargin;
        float mVerticalMargin;


        View mView;
        View mNextView;

        WindowManager mWM;

        TN() {
            // XXX This should be changed to use a Dialog, with a Theme.Toast
            // defined that sets up the layout params appropriately.
            final WindowManager.LayoutParams params = mParams;
            params.height = WindowManager.LayoutParams.WRAP_CONTENT;
            params.width = WindowManager.LayoutParams.WRAP_CONTENT;
            params.format = PixelFormat.TRANSLUCENT;
            params.windowAnimations = com.android.internal.R.style.Animation_Toast;
            params.type = WindowManager.LayoutParams.TYPE_TOAST;
            params.setTitle("Toast");
            params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
                    | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                    | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
        }

        /**
         * schedule handleShow into the right thread
         */
        @Override
        public void show() {
            if (localLOGV) Log.v(TAG, "SHOW: " + this);
            mHandler.post(mShow);
        }

        /**
         * schedule handleHide into the right thread
         */
        @Override
        public void hide() {
            if (localLOGV) Log.v(TAG, "HIDE: " + this);
            mHandler.post(mHide);
        }

        public void handleShow() {
            if (localLOGV) Log.v(TAG, "HANDLE SHOW: " + this + " mView=" + mView
                    + " mNextView=" + mNextView);
            if (mView != mNextView) {
                // remove the old view if necessary
                handleHide();
                mView = mNextView;
                Context context = mView.getContext().getApplicationContext();
                String packageName = mView.getContext().getOpPackageName();
                if (context == null) {
                    context = mView.getContext();
                }
                mWM = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
                // We can resolve the Gravity here by using the Locale for getting
                // the layout direction
                final Configuration config = mView.getContext().getResources().getConfiguration();
                final int gravity = Gravity.getAbsoluteGravity(mGravity, config.getLayoutDirection());
                mParams.gravity = gravity;
                if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {
                    mParams.horizontalWeight = 1.0f;
                }
                if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {
                    mParams.verticalWeight = 1.0f;
                }
                mParams.x = mX;
                mParams.y = mY;
                mParams.verticalMargin = mVerticalMargin;
                mParams.horizontalMargin = mHorizontalMargin;
                mParams.packageName = packageName;
                if (mView.getParent() != null) {
                    if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
                    mWM.removeView(mView);
                }
                if (localLOGV) Log.v(TAG, "ADD! " + mView + " in " + this);
                mWM.addView(mView, mParams);
                trySendAccessibilityEvent();
            }
        }

        private void trySendAccessibilityEvent() {
            AccessibilityManager accessibilityManager =
                    AccessibilityManager.getInstance(mView.getContext());
            if (!accessibilityManager.isEnabled()) {
                return;
            }
            // treat toasts as notifications since they are used to
            // announce a transient piece of information to the user
            AccessibilityEvent event = AccessibilityEvent.obtain(
                    AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED);
            event.setClassName(getClass().getName());
            event.setPackageName(mView.getContext().getPackageName());
            mView.dispatchPopulateAccessibilityEvent(event);
            accessibilityManager.sendAccessibilityEvent(event);
        }        

        public void handleHide() {
            if (localLOGV) Log.v(TAG, "HANDLE HIDE: " + this + " mView=" + mView);
            if (mView != null) {
                // note: checking parent() just to make sure the view has
                // been added...  i have seen cases where we get here when
                // the view isn't yet added, so let's try not to crash.
                if (mView.getParent() != null) {
                    if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
                    mWM.removeView(mView);
                }

                mView = null;
            }
        }
    }




19、反射学习

关于java的反射：首先反射就是在程序运行的过程中可以动态的修改其状态以及行为的一种能力。

现在我们使用反射大部分是通过修改某一个类的其中一个对象的引用或者对其值的修改，达到修改对象的行为。

如果要对类中的方法或者实现进行修改就需要进行字节码注入操作，不在反射的学习中。

 关于反射主要是通过Class这个类以及

java.lang.reflect

这个包下边Method，Field等等的来实现的。

20、android切换到桌面

 Intent mHomeIntent;

                            mHomeIntent = new Intent(Intent.ACTION_MAIN, null);

                            mHomeIntent.addCategory(Intent.CATEGORY_HOME);

                            mHomeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);


                            startActivity(mHomeIntent);



21、关于String ,StringBuffer,StringBuilder的比较


String 类是一个final类型的类，它是不能被修改的，也就是说

String s = “aaaaaa”

s = s + “bbbbb”

因为String 是不能被修改的，所以上边的在执行的时候是重新创建一个String 对象，然后 赋值给s 。

所以如果在使用的时候是对String 对象来进行操作，是十分的耗时的，但是如果是直接对字符串进行操作，那么速度很快，都是jvm来进行操作的。


StringBuilder、StringBuffer是可变字符串对象，我们所有对字符串的操作都在这个对象上边，如果是对字符串对象进行操作的话，速度上要比String快上很多很多。


他们俩个都是继承了AbstractStringBuilder这个抽象类，在这个类中实现了大部分的功能，比如getValue，setLength，append ，reverse，等等，这个类还实现了CharSequence接口， 所以StringBuffer与StringBuilder都是在AbstractStringBuilder的基础上又进行了扩展，他们都实现了相同的三个接口java.io.Serializable, Appendable, CharSequence。


而他们俩个的区别就在于线程安全:  


StringBuffer：线程安全 ，是因为它里边很多方法都是上锁的，通过synchronized来进行修饰的，所以在多线程中操作时是不会引起对象的因多线程操作而发生的数据不一致问题。

StringBuilder：非线程安全，与StringBuffer正好相反，所有的方法都么有加锁。但是如果在非多线程操作中，速度比StringBuffer要快。

22、6.0多进程无法安装总是提示安装失败。应用之间交互也需要设置关联启动

23、

5.0以后获取正在运行的程序只能获取到当前应用。而后台正在运行的服务以及应用都只能通过获取服务然后通过service或者process来进行判断。

因为6.0以后应用如果设置多进程是无法安装的。

获取方式：

 /**
     * 方法描述：判断某一Service或者应用是否正在运行
     *
     * @param context     上下文
     * @param serviceName Service的全路径： 包名 + service的类名 （如果是判断应用是否安装直接传递包名）
     * @return true 表示正在运行，false 表示没有运行
     */
    public static boolean isServiceRunning(Context context, String serviceName) {
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List runningServiceInfos = am.getRunningServices(200);
        if (runningServiceInfos.size() <= 0) {
            return false;
        }
        for (ActivityManager.RunningServiceInfo serviceInfo : runningServiceInfos) {
            Log.e("TAG", serviceInfo.service.getClassName());
            if (serviceInfo.process.equals(serviceName)) {
                return true;
            }
        }
        return false;
    }

24、android aidl进程间通信要注意的点；

现在在做一个sdk用来让讯飞可以与我们公司的应用进行开发。

因为是要在进程间通信，所以肯定会使用Aidl来进行。

但是要注意的几点就是:

(1)进程间通信的话最好是不要把提供服务的service设置为独立的进程，要保证跟应用在同一个进程(2)还有就是进程间通信必



25、查看当前应用cpu内、存使用情况

adb shell

top -m 15 -s cpu  //查询当前cpu占用前十的应用 

dumpsys meminfo //查看手机上所有的内存信息

dumpsys battery//查看电量信息

dumpsys  meminfo “要查看的应用的包名” //查询某一个应用的包名


top -d 1 |  grep com.guoyi.qinghua  //查询某一个应用的cpu使用情况

26、关于android 的应用程序cpu占用率问题

1、图片加载（图片加载使用好第三方框架，尽量不要使用Bitmap.create的方法）

   android动画对于cpu的消耗还是很大的，如果是可以通过自定实现的动画使用自定义动画，如过是复杂动画，能用ObjectAnimator实现就不要用ValueAnimator来进行实。

不要使用动画来更新自定义的进度条或者是会根据时间间隔变化的View。可以用Timer或者Handler来替换。

可以减小图片的大小。

2、线程 （线程确保执行完成，或者可以手动控制）

3、布局加载（布局尽量减少布局层数）

4、网络（在进程网络访问的时候要先判断网状态）

5、定位（降低定位的时间间隔）

6、直播软件的编解码（在使用七牛播放器的时候，设置硬解码cpu的占有率比软解码低一半，如果cpu占用太高切换硬解码是一个好的选择）


27、android logo 尺寸 

DENSITY SIZE LOCATION RATIO SCREEN MARGIN
XXXHDPI 192×192 drawable-xxxhdpi 4 640 DPI 12 to 16 pixels
XXHDPI 144×144 drawable-xxhdpi 3 480 DPI 8 to 12 pixels
XHDPI 96×96 drawable-xhdpi 2 320 DPI 6 to 8 pixels
HDPI 72×72 drawable-hdpi 1.5 240 DPI 4 to 6 pixels
MDPI 48×48 drawable-mdpi 1 160 DPI 3 to 4 pixels
MDPI 48×48 drawable (Cupcake) 1 160 DPI 3 to 4 pixels
LDPI 36×36 drawable-ldpi 0.75 120 DPI 2 to 3 pixels
NA 512×512 Google Play NA NA As required

28、ython环境配置以后在使用中出现的问题

python代码需要在开头插入

#!/usr/bin/python

用来生名python支持，然后通过import可以导入需要的类。

如果出现 -bash: ./****.py: /usr/bin/python^M: bad interpreter: No such file or directory

那么应该是不同系统编码格式引起的：在windows系统中编辑的.sh .py文件可能有不可见字符，所以在linux系统下执行会报以上异常信息。一般是因为windows行结尾和linux行结尾标识不同造成的。

解决：

1）在windows下转换： 

利用一些编辑器如UltraEdit或EditPlus等工具先将脚本编码转换，再放到Linux中执行。转换方式如下（UltraEdit）：File-->Conversions-->DOS->UNIX即可。 

2）linux下直接替换：

sed -i 's/^M//g'  filename （注意^M 在linux 下写法 按^M 是回车换行符,输入方法是按住CTRL+v,松开v,按m)

3）也可在Linux中转换： 

首先要确保文件有可执行权限 

#sh>chmod a+x filename 


然后修改文件格式 

#sh>vi filename 


利用如下命令查看文件格式 

:set ff 或 :set fileformat 


可以看到如下信息 

fileformat=dos 或 fileformat=unix 


利用如下命令修改文件格式 

:set ff=unix 或 :set fileformat=unix 


:wq (存盘退出) 或者使用:wq! 进行保存


最后再执行文件 

#sh>./filename   

如果配置了全局的python环境变量的话可以直接使用xxxx.py来执行py文件，或者要通过./xxxx.py


29、Bitmap.createBitmap中参数的理解

x的值不能小于0，width 不能小于0；

x+width 的值不能小于0，也不能大于原bitmap的宽度，

y的值与height与上边规则相同，

而通过这个方法创建的btimap是通过x与y来控制要截取的bitmap的起始位置，最后的width与height用来确定从x与y的位置截取开始到什么时候结束。


30、如果.9图片不正规可能导致android studio编译出现多线程问题


31、studio中svn的使用

studio中使用svn可以更新指定文件，也可以提交指定文件。

svn指定版本更新会把指定版本以下的代码都更新下来，不会更新指定版本以上的代码

svn 中revert 复原代码，只能复原没有提交的文件，如果提交时没有办法复原


32、RecycleView 的scrollToPosition方法，如果剩下的item个数不够一屏幕的话无法滚动。

但是可以使用 scrollBy（int x, int y） 滚动屏幕的宽度的距离就可以。

33、内存泄漏的理解，如何防止内存泄漏（以及内存泄漏会引起的问题）

关于内存泄漏其实最难的是定位问题出现。一个良好的代码习惯，能避免掉很多内存泄漏，但是也不能规避过所有的。以前都是在内存泄漏以后使用工具进行内存分析，找到内存泄漏的地方，然后进行修改，现在发现一个内存泄漏检测比较简单的一个工具leakcanary，可以去gitHub上直接查看源码，然后简单集成下就可以了。

内存泄漏：内存泄漏就是一个对象被别的对象引用，导致他应该被释放回收的时候，没有办法释放，对内存的持续占用，会导致android应用在给别的功能分配内存的时候，可能没有办法分配给这个功能那么多的内存，然后gc开始查找可以释放的内存，但是因为内存泄漏了（也就是那么没有办法释放的对象都是强引用），gc查找以后也不能释放出足够这个功能所需要占用的内存的时候，那么就会出现内存泄漏。

内存泄漏的解决办法：可以加大android系统给应用分配的内存上限，但是这个是治标不治本，最主要还是要修改内存泄漏的根本原因。一般发生内存泄漏的地方有（1）匿名内部类的使用（因为匿名内部类一般都会持有当前对象的引用，那么在内部类对象没有释放的时候，那么他所持有的引用也不会消失，就会导致内存泄漏）如果可以在Application中添加的回调监听，一定不要放在activity中，因为那样的话，在回调没有回调的时候，引用也会一直持有；（2）在开发中发现 集合类很容易引起内存泄漏，一般尽量不要把集合类创建为static类型，否则的话他里边的对象都不会得到释放，除非是从集合中移除。可以参考的文章：http://blog.csdn.net/u012808234/article/details/74942491

34、屏幕适配是android一直以来都很坚挺的问题呢，因为android的开源性，各个厂商的定制，等等，导致android手机的分辨率是千奇百怪，但是我们适配一般也只适配主流的分辨率，不是所有。

那么在适配的过程中如何用最小的成本来适配最多屏幕，就是我们开发需要考虑的问题。

android 中推荐使用match_parent,warp_parent, xxxdl ,xxxsp,主要就是为了适配。


dp(dip或者叫dpi) 代表的是单位英寸内的像素点个数，他是跟像素无关，跟屏幕密度有关的。

android中屏幕密度越大也就是单位英寸内的像素点越多。屏幕显示的更清晰。

密度的计算方式：1920x1080  5英寸手机（对角线的长度，也就是手机左上角跟右下角的长度）

√（1920^2+1080^2）=2202.9071


2202.9/5=468.7021（ppi)≈469ppi

如果在480px 跟240px上 如果密度相同，那么1dp所占的大小也是相等的。这就是跟像素无关

160ppi         1dp  1px   

320ppi         1dp  2px

480ppi         1dp  3px

密度因子以160为基础，也就是160 密度因子是1，密度因子= 密度/160 

dp转px    px = dp ✖️密度因子


知道了这个，但是如果只是简单的设置dp还是不能够适配大多数屏幕：

适配方式：

1、布局适配，根据不同分辨率创建不同的布局

优点是简单明了，只要根据不同的屏幕创建不同的布局即可，但是会导致的问题就是，布局文件的增多，如果里边对于图片的使用很多的话，那么会导致app打包以后的大小变的很大，要适配大部分屏幕，工作量比较大

2、布局的时候通过比例来进行适配，比如一个按钮占屏幕的几分之几

优点就是一套布局可以适配所有的屏幕，但是不是所有的布局都能用比例来适配

3、使用一套布局，然后创建不同分辨率的dimens.xml (创建不同分辨率的values比如values_480x1280)

4、一些动画或者效果，客户端如果可以实现的话，而且不是特别难的话，最好是自定义，动态的适配分辨率

5、在代码中动态修改控件的宽度等等参数


你可能感兴趣的:(Android,开发经验)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • Java 并发包之线程池和原子计数 lijingyao8206 Java计数ThreadPool并发包java线程池
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。     这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
  • java编程思想 抽象类和接口 百合不是茶 java抽象类接口
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持   1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错)   抽象方法 : 在方法中仅有声明而没有方法体    package com.wj.Interface;
  • [房地产与大数据]房地产数据挖掘系统 comsci 数据挖掘
           随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间...        所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产     &nb
  • 数组队列总结 沐刃青蛟 数组队列
          数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。      以下是数组队列的功能实现代码：   import List.Student; public class
  • Oracle存储过程无法编译的解决方法 IT独行者 oracle存储过程　
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。   1.     查看无效对象 XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
  • 重装系统之后oracle恢复 文强chu oracle
    前几天正在使用电脑，没有暂停oracle的各种服务。 突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 直接把我的c盘给格式化了 并且清理了注册表，再装系统。 然后的结果就是我的oracl
  • python学习二（ 一些基础语法） 小桔子 pthon基础语法
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 1.ptyhon的源文件以UTF-8编码格式 2. /   除 结果浮点型 //  除 结果整形 %   除 取余数 *   乘 **  乘方 eg 5**2 结果是5的2次方25 _&
  • svn 常用命令 aichenglong SVN版本回退
    1 svn回退版本   1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 两者的区别:   revert this version:表示回退到当前版本(该版本后的版本全部作废)   revert chanages from this versio
  • 某小公司面试归来 alafqq 面试
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 老拿这些对付毕业生的东东来吓唬我。。 面试官很刁难，问了几个问题，记录下； 1，包的范围。。。public,private,protect. --悲剧了 2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 4，stru
  • 动态数组的存储速度比较 集合框架 百合不是茶 集合框架
    集合框架： 自定义数据结构(增删改查等) package 数组; /** * 创建动态数组 * @author 百合 * */ public class ArrayDemo{ //定义一个数组来存放数据 String[] src = new String[0]; /** * 增加元素加入容器 * @param s要加入容器
  • 用JS实现一个JS对象，对象里有两个属性一个方法 bijian1013 js对象
    <html> <head> </head> <body> 用js代码实现一个js对象，对象里有两个属性，一个方法 </body> <script> var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){
  • 探索JUnit4扩展：使用Rule bijian1013 java单元测试JUnitRule
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 1. Rule       &n
  • [Gson一]非泛型POJO对象的反序列化 bit1129 POJO
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 1. POJO对象不包含任何泛型的字段 2. POJO对象包含泛型字段，例如泛型集合或者泛型类 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO    
  • 【Kakfa五】Kafka Producer和Consumer基本使用 bit1129 kafka
    0.Kafka服务器的配置 一个Broker， 一个Topic Topic中只有一个Partition（）   1. Producer： package kafka.examples.producers; import kafka.producer.KeyedMessage; import kafka.javaapi.producer.Producer; impor
  • lsyncd实时同步搭建指南——取代rsync+inotify ronin47
    1. 几大实时同步工具比较 1.1 inotify + rsync 最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果 bylijinnan java
    public class IsBinTreePostTraverse{ static boolean isBSTPostOrder(int[] a){ if(a==null){ return false; } /*1.只有一个结点时，肯定是查找树 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是 6 {6,5}对应的BST是
  • MySQL的sum函数返回的类型 bylijinnan javaspringsqlmysqljdbc
    今天项目切换数据库时，出错 访问数据库的代码大概是这样： String sql = "select sum(number) as sumNumberOfOneDay from tableName"; List<Map> rows = getJdbcTemplate().queryForList(sql); for (Map row : rows
  • java设计模式之单例模式 chicony java设计模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的结构 　　单例模式的特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 　　饿汉式单例类   publ
  • javascript取当月最后一天 ctrain JavaScript
    <!--javascript取当月最后一天--> <script language=javascript> var current = new Date(); var year = current.getYear(); var month = current.getMonth(); showMonthLastDay(year, mont
  • linux tune2fs命令详解 daizj linuxtune2fs查看系统文件块信息
    一.简介： tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 二.用法： Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
  • 做有中国特色的程序员 dcj3sjt126com 程序员
      从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
  • Android：TextView属性大全 dcj3sjt126com textview
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
  • tomcat虚拟目录安装及其配置 eksliang tomcat配置说明tomca部署web应用tomcat虚拟目录安装
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 1.-------------------------------------------tomcat  目录结构 config：存放tomcat的配置文件 temp  ：存放tomcat跑起来后存放临时文件用的 work   ： 当第一次访问应用中的jsp
  • 浅谈：APP有哪些常被黑客利用的安全漏洞 gg163 APP
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 1. 应用反编译漏洞：APK 包非常容易被反编译成可读
  • C#根据网址生成静态页面 hvt Web.netC#asp.nethovertree
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法：   bool CreateHtmlFile(string url, string path) { //http://keleyi.com/a/bjae/3d10wfax.htm stri
  • SVG 教程 （一） 天梯梦 svg
    SVG 简介 SVG 是使用 XML 来描述二维图形和绘图程序的语言。 学习之前应具备的基础知识： 继续学习之前，你应该对以下内容有基本的了解： HTML XML 基础 如果希望首先学习这些内容，请在本站的首页选择相应的教程。 什么是SVG？ SVG 指可伸缩矢量图形 (Scalable Vector Graphics) SVG 用来定义用于网络的基于矢量
  • 一个简单的java栈 luyulong java数据结构栈
    public class MyStack { private long[] arr; private int top; public MyStack() { arr = new long[10]; top = -1; } public MyStack(int maxsize) { arr = new long[maxsize]; top
  • 基础数据结构和算法八：Binary search sunwinner AlgorithmBinary search
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 刘星宇 c面试
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 1.gets()函数 问：请找出下面代码里的问题： #include<stdio.h> int main(void) {     char buff[10];     memset(buff,0,sizeof(buff));
  • ITeye 7月技术图书有奖试读获奖名单公布 ITeye管理员 活动ITeye试读
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 7月试读活动回顾： http://webmaster.iteye.com/blog/2092746 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《Java性能优化权威指南》