精华内容
下载资源
问答
  • 有序广播与无序广播

    2017-01-06 17:25:00
    无序广播:类似新闻联播,无论你看不看,其都正常播报,无序广播不被终止,数据不被修改 sendBroadcast(intent); 假设在APK-A中实现一个按钮,点击该按钮就会发送一个无序的广播,但是有没有APK接收到该广播...

    有序广播:按照优先级一级一级的进行传递,类似红头文件下发,有序广播可以被终止,数据可以被修改

    sendOrderedBroadcast

    无序广播:类似新闻联播,无论你看不看,其都正常播报,无序广播不能被终止,数据不能被修改

    sendBroadcast(intent);

     

    假设在APK-A中实现一个按钮,点击该按钮就会发送一个无序的广播,但是有没有APK接收到该广播,对于发送无序广播的APK并不关心,如果APK-B配置了接收APK-A发送的广播过滤事件,则APK-B可以接收到该广播

    APK-A中实现代码:

     public void click(View view)
        {
            Intent intent = new Intent();
            intent.putExtra("name", "发送无序广播的内容");
            intent.setAction("myself.broadcastreceiver");
            sendBroadcast(intent);
        }

    APK-B中实现代码:

    1、实现一个类继承BroadcastReceiver并且复写onReceive方法

    public class ReceiverMyselfBroadCast extends BroadcastReceiver
    {
        @Override
        public void onReceive(Context context, Intent intent)
        {
            String name = intent.getStringExtra("name");
            Toast.makeText(context, name, Toast.LENGTH_SHORT).show();
        }
    }

    2、在AndroidManifest.xml中配置事件过滤器

     <receiver android:name=".ReceiverMyself">
                <intent-filter>
                    <action android:name="myself.broadcastreceiver"/>
                </intent-filter>
     </receiver>

     

    转载于:https://www.cnblogs.com/doitbyyourself/p/6257117.html

    展开全文
  • 1、通过一个案例来讲解有序广播与无序广播的使用。 无序广播博是完全异步的,发送广播时所有监听设广播的广播接受者都会接收到此消息,但接收的顺序不确定。 有序广播,会按接受者的优先级接收,只有一个广播接受...

    1、通过一个案例来讲解有序广播与无序广播的使用。
    无序广播博是完全异步的,发送广播时所有监听设广播的广播接受者都会接收到此消息,但接收的顺序不确定。
    有序广播,会按接受者的优先级接收,只有一个广播接受者能接收消息,在此广播接受者中逻辑执行完毕,才会继续传递。
    案例效果图如下

    这里写图片描述
    2、案例实现过程

    布局文件:activity_main.xml

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        android:background="@drawable/stitch_one"
        tools:context="cn.edu.bzu.orderedbroadcast.MainActivity">
    
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_marginTop="80dp"
            android:onClick="send"
            android:text="发送有序广播"
            android:paddingLeft="5dp"
            android:paddingRight="5dp"
            android:background="#FBFBFF"
            android:textSize="20sp"/>
    </RelativeLayout>

    用户界面交互代码:MainActivity.java

    package cn.edu.bzu.orderedbroadcast;
    import android.content.Intent;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
        public void send(View view){
            Intent intent=new Intent();
            intent.setAction("Intercept_Stitch");
            sendOrderedBroadcast(intent,null);
        }
    }

    广播接收:MyBroadcastReceiverOne.java,MyBroadcastReceiverTwo,MyBroadcastReceiverThree

    package cn.edu.bzu.orderedbroadcast;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.util.Log;
    
    public class MyBroadcastReceiverOne extends BroadcastReceiver {
        public MyBroadcastReceiverOne() {
        }
    
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i("MyBroadcastReceiverOne","自定义的广播接收者One,接受到了");
        }
    }
    package cn.edu.bzu.orderedbroadcast;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.util.Log;
    
    public class MyBroadcastReceiverTwo extends BroadcastReceiver {
        public MyBroadcastReceiverTwo() {
        }
    
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i("MyBroadcastReceiverOne","自定义的广播接收者Two,接受到了");
        }
    }
    package cn.edu.bzu.orderedbroadcast;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.util.Log;
    
    public class MyBroadcastReceiverThree extends BroadcastReceiver {
        public MyBroadcastReceiverThree() {
        }
    
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i("MyBroadcastReceiverOne","自定义的广播接收者Three,接受到了");
        }
    }

    清单文件

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="cn.edu.bzu.orderedbroadcast">
    
        <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
            <activity android:name=".MainActivity">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
            <!--注册广播接收者-->
            <receiver
                android:name=".MyBroadcastReceiverOne"
                android:enabled="true"
                android:exported="true">
                <intent-filter android:priority="1000">
                    <action android:name="Intercept_Stitch"></action>
                </intent-filter>
            </receiver>
            <receiver
                android:name=".MyBroadcastReceiverTwo"
                android:enabled="true"
                android:exported="true">
                <intent-filter android:priority="200">
                    <action android:name="Intercept_Stitch"></action>
                </intent-filter>
            </receiver>
            <receiver
                android:name=".MyBroadcastReceiverThree"
                android:enabled="true"
                android:exported="true">
                <intent-filter android:priority="600">
                    <action android:name="Intercept_Stitch"></action>
                </intent-filter>
            </receiver>
        </application>
    
    </manifest>

    Logcat窗口下

    这里写图片描述

    按照顺序排列。若MyBroadcastReceiverTwo优先级同设为1000,并放在MyBroadcastReceiverOne前,

    这里写图片描述

    若改为无序广播则接收的顺序不确定。

    展开全文
  • 1.Normal Broadcast(普通广播):完全异步,同一时刻所有接收者都收到,缺点是不将处理结果传递给下一个接收者,无法终止Broadcast Intent的传播。用sendBroadcast()方法发生普通广播 2.Ordered Broadcast...

    1.Normal Broadcast(普通广播):完全异步,同一时刻所有接收者都能收到,缺点是不能将处理结果传递给下一个接收者,无法终止Broadcast Intent的传播。用sendBroadcast()方法发生普通广播

    2.Ordered Broadcast(有序广播):接收者按预先声明的优先级依次接收Broadcast,优先级高的先接收,可以用android:priority或setPriority()指定,数值越大优先级越高。有序广播可以被终止,优先级高的能终止优先级低的,用abortBroadcast()方法。并且优先收到Broadcast的接收者可以通过setResultExtras(Bundle)方法将结果本接收者的处理结果存入Broadcast中,下一个接收者收到的时候可以用Bundle bundle=getResultExtras(true)来获取上一个接收者的处理结果。用senOrderedBroadcast()发送有序广播。


    下面是一个例子:

    MainActivity.java:

    package com.example.wanglunhui.sortedbroadcast;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    
    
    public class MainActivity extends Activity
    {
       Button send;
       @Override
       public void onCreate(Bundle savedInstanceState)
       {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.main);
          // 获取程序中的send按钮
          send = (Button) findViewById(R.id.send);
          send.setOnClickListener(new OnClickListener()
          {
             @Override
             public void onClick(View v)
             {
                // 创建Intent对象
                Intent intent = new Intent();
                intent.setAction("org.crazyit.action.CRAZY_BROADCAST");
                intent.putExtra("msg", "简单的消息");
                // 发送有序广播
                sendOrderedBroadcast(intent, null);
             }
          });
       }
    }
    
    
    MyReceiver.java里面存入了处理结果并向下一个发送:

    package com.example.wanglunhui.sortedbroadcast;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.os.Bundle;
    import android.widget.Toast;
    
    public class MyReceiver extends BroadcastReceiver
    {
       @Override
       public void onReceive(Context context, Intent intent)
       {
          Toast.makeText(context,    "接收到的Intent的Action为:"
                + intent.getAction() + "\n消息内容是:"
                + intent.getStringExtra("msg")
                , Toast.LENGTH_LONG).show();
          // 创建一个Bundle对象,并存入数据
          Bundle bundle = new Bundle();
          bundle.putString("first", "第一个BroadcastReceiver存入的消息");
          // 将bundle放入结果中
          setResultExtras(bundle);
          // 不取消Broadcast的继续传播
          //abortBroadcast(); // ①若取消时,则下一个接收者不能收到此广播
       }
    }
    

    下一个Receiver:MyReceiver2.java:

    package com.example.wanglunhui.sortedbroadcast;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.os.Bundle;
    import android.widget.Toast;
    
    public class MyReceiver2 extends BroadcastReceiver
    {
       @Override
       public void onReceive(Context context, Intent intent)
       {
          Bundle bundle = getResultExtras(true);
          // 解析前一个BroadcastReceiver所存入的key为first的消息
          String first = bundle.getString("first");
          Toast.makeText(context, "第一个Broadcast存入的消息为:"
             + first, Toast.LENGTH_LONG).show();
       }
    }
    

    AndroidManifest.java用设置优先级:
    <receiver android:name=".MyReceiver">
        <intent-filter android:priority="20">
            <action android:name="org.crazyit.action.CRAZY_BROADCAST" />
        </intent-filter>
    </receiver>
    <receiver android:name=".MyReceiver2">
        <intent-filter android:priority="0">
            <action android:name="org.crazyit.action.CRAZY_BROADCAST" />
        </intent-filter>
    </receiver>

    展开全文
  • 文章目录无序数组和有序数组比较无序数组特点有序数组特点代码实现自己的数组无序数组有序数组 无序数组和有序数组比较 无序数组 增:在数组最后插入 删:找到元素;改为null;后面的元素逐一前移 查:从第一项元素...

    无序数组和有序数组比较

    无序数组

    增:在数组最后插入
    删:找到元素;改为null;后面的元素逐一前移
    查:从第一项元素开始遍历,直至找到该元素或者遍历结束

    特点

    效率:插入数据快,查找数据慢,删除数据慢
    扩展性差:一旦创建后,大小就固定了,不能动态扩展数组元素的个数,有可能造成空间浪费或者空间不足。

    有序数组

    插入:找到插入元素应该插入的位置(根据元素值的大小);将该位置以及以后的全部数据项向后移动一位;在该位置插入元素
    删除:找到要删除的元素;后面的所有元素向前移位
    查找:遍历查找or二分查找

    特点

    效率:插入数据慢,查找数据快(二分查找),删除数据慢。
    扩展性差:一旦创建后,大小就固定了,不能动态扩展数组元素的个数,有可能造成空间浪费或者空间不足。

    代码实现自己的数组

    无序数组

    package demo;
    
    public class unorderedArray {
        //程序的执行入口
        public static void main(String[] args){
            ArrayClass arrayClass = new ArrayClass(100);
    
            //新增元素
            arrayClass.insert(11);
            arrayClass.insert(23);
            arrayClass.insert(45);
            arrayClass.insert(21);
            arrayClass.insert(66);
            arrayClass.insert(77);
            arrayClass.insert(66);
    
            //显示新增的数据
            arrayClass.display();
    
            //删除数据77
            arrayClass.delete(23);
    
            //显示新增的数据
            arrayClass.display();
    
            //查找
            System.out.println(arrayClass.find(11));
            System.out.println(arrayClass.find(1));
    
            //修改
            arrayClass.modifyFirst(66,77);
    
            //显示新增的数据
            arrayClass.display();
    
            //修改
            arrayClass.modifyAll(77,100);
    
            //显示新增的数据
            arrayClass.display();
    
        }
    }
    
    /**
     * 创建一个封装数组的类
     */
    
    class ArrayClass{
        private long[] arr; //被封装的数组
        private int nElems; //数组中存在的元素的个数,当前的数组长度
    
        //通过类的构造方法初始化
        public ArrayClass(int maxSize){ //数组的最大长度
            arr = new long[maxSize]; //初始化被封装的数组
            nElems = 0;
        }
    
        //新增数据项,数组元素
        public void insert(long data){
            arr[nElems] = data;
            nElems ++;
        }
    
        //查找某一特定的数据项
        //找到返回true,否则返回false
        public boolean find(long searchData){
            int i;
            for (i=0;i<nElems;i++){
                if(searchData == arr[i]){
                    break;//找到了就直接终止循环,此时i不再++,就等于对应元素的索引值
                }
            }
            if(i == nElems){
                return false;
            }
            else{
                return true;
            }
        }
    
        //删除指定的数据项
        public void delete(long targetDate){
            //首先找到要删除的数据
            int i;
            for (i=0;i<nElems;i++){
                if(targetDate == arr[i]){
                    break;//找到了就直接终止循环,此时i不再++,就等于对应元素的索引值
                }
            }
            if(i == nElems){
                System.out.println("没有找到要删除的数据");
            }
            else{
                for(int j =i;j<nElems;j++){
                    arr[j] = arr[j+1]; //删除数组中要删除的元素
                }
                nElems --; //数组长度-1
            }
        }
    
        //遍历数据结构中的各个数据项
        public void display(){
            for(int i=0;i<nElems;i++){
                System.out.print(arr[i] + "  ");
            }
            System.out.println();//加一个换行符
        }
    
        /**
         * 以下内容是自己加的
         */
        //修改数组内容(全部相同内容都改)
        public void modifyAll(long originalData, long targetData){
            for(int i=0;i<nElems;i++){
                if(arr[i]==originalData){
                    arr[i] = targetData;
                }
            }
        }
    
        //修改数组内容(全部相同内容都改)
        public void modifyFirst(long originalData, long targetData){
            for(int i=0;i<nElems;i++){
                if(arr[i]==originalData){
                    arr[i] = targetData;
                    break;
                }
            }
        }
    }
    

    有序数组

    package demo;
    
    public class OrderedArray {
        //程序的执行入口
        public static void main(String[] args){
    
            OrderArray orderArray = new OrderArray(100);
            orderArray.insert(15);
            orderArray.insert(44);
            orderArray.insert(55);
            orderArray.insert(22);
            orderArray.insert(1);
            orderArray.insert(99);
    
            orderArray.display();
    
            System.out.println(orderArray.find(55));
    
            orderArray.delete(22);
    
            orderArray.display();
        }
    }
    
    
    /**
     *封装有序数组
     */
    class OrderArray{
        private long[] arr;
        private int nElems;
    
        //构造方法
        public OrderArray(int maxSize){
            arr = new long[maxSize];
            nElems =0;
        }
    
        //插入新的数据项
        public void insert(long data){
            //找到插入数据的位置
            int i;
            for(i=0;i<nElems;i++){
                if(arr[i]> data){
                    break;
                }
            }
    
            //判断找没找到
            if(i<nElems){//找到了插入位置
                for(int j=nElems;j>i;j--){
                    if(j<arr.length){//判断数组是否还有空间
                        arr[j]=arr[j-1];
                    }
                }
                arr[i] = data;
                nElems ++;
            }
            else{//没找到,,要插入的元素比数组中其他元素都大
                if(nElems<arr.length){//还有位置
                    arr[nElems] = data;
                    nElems ++;
                }
            }
        }
    
        //遍历数组
        public void display(){
            for(int i=0;i<nElems;i++){
                System.out.print(arr[i]+"  ");
            }
            System.out.println();
        }
    
        //查找(二分查找)
        //找到了就返回数组在数组中的索引值,没找到就返回数组的当前长度
        public int find(long searchData){
            int lowerBound = 0;
            int upperBound = nElems-1;
            int curint; // 对数组进行二分的时候,中间元素对应的索引值
    
            while(true){
                curint = (lowerBound + upperBound) / 2; //自动取整
                if(arr[curint] == searchData){
                    return curint; //return不仅会结束while循环,还会结束find方法
                }else if(lowerBound>upperBound) {
                    //数组中没有要查找的元素
                    return nElems;
                }else{
                    if(arr[curint] > searchData){
                        upperBound = curint-1;
                    }else{
                        lowerBound = curint+1;
                    }
                }
            }
        }
    
        //删除指定元素
        public void delete(long data){
            int i = find(data);
            if(i<nElems){//数据纯在
                for(int j = i;j<nElems;j++){
                    arr[j] = arr[j+1];
                }
                nElems --;
            }
        }
    
    }
    
    展开全文
  • 对于材料的亚铁磁性,引人冷无序能后,从理论上得到了奈尔磁相变温度TN相相关的能量kBTN与有序能Eorder的比值变化,以及冷无序能Ed与有序能的比值Ed Eorder 的变化规律.当顺磁居里温度相关的能量kBθP远大于有序能E...
  • 前言 消息中间件作为分布式系统的重要成员,各大公司及开源均有许多解决方案。目前主流的开源解决方案包括RabbitMQ、...然而难也不代表没有方法或者“套路”,熟悉一下原理实现,多看几个框架的源码后多总结势必
  • 无序hashsethashmap让其有序 http://blog.csdn.net/RabbitEatPumpkin/article/details/4730544 今天迭代hashmap时,hashmap并不按照put的顺序,迭代输出值。用下述方法可以: HashMap&...
  • BroadcastReceiver.onReceive默认是在主线程(UI线程)执行的,这也是老生常谈的“千万不在广播接收器做耗时操作,会ANR!”的真正原因
  • LeetCode两数之和问题描述解法一:暴力遍历解法二:两遍哈希解法三:一遍哈希 问题描述 ...但是,你不重复利用这个数组中同样的元素。 示例: 给定: nums = [2, 7, 11, 15], target = 9 因为 :nums[...
  • 一、两种Broadcast: · 普通广播(Normal Broadcast):用sendBroadcast()方法发送。... ps:接收无序广播的接收器接收到广播的顺序也是有序的,接收无序广播的接收器也一样可以设置优先级的。如果
  • 单向链表不自我删除,需要靠辅助节点,而双向链表可以,所有单链表删除节点总是找到temp,temp是待删除节点的前一个节点 思路: (1)遍历:和单链表一样,只是可以向前、也可以向后查找 (2) 添加(默认添加到...
  • 有序广播发短信

    2017-07-13 18:17:41
    1.有序广播与无序广播的区别:  有序广播:sendOrderBroadcast();来发送信息。而设置接收信息的快慢(通过设置优先级)。也可以消息是否传播。  无序广播:sendBroadcast();或是sendStiky()发送信息。接收顺序...
  • 无序列表的标签格式 <ul> <li>...</li> </ul>...使用无序列表需要注意,在<...标签,即不出现其它<li>..</li>标签同级的标签 有序列表的标签格式 <ol...
  • HTML的基本知识(五)——无序列表、有序列表、自定义列表 茫茫人海,有多少擦肩而过?漫漫一生,有多少真诚守候? 很开心在CSDN你相遇、相知、相惜、相守。一个人只有不断地写作,才能才不被人海湮没。 但不论...
  • 尽管学术上对大数据、人工智能和云计算的概念解释林林总总,对大众来说甚至是含混晦涩,在多次的部委内部讲课和公开演讲中,他的概念定义解析,却以简驭繁、意蕴深刻,更是天高云淡、回味无穷。 “把无序变有...
  • 大家看到了其本形式与无序列表的一样,只是在外围标签上名称不同。无序是UL,有序就变成OL了。所不同的是有序列表将会有比无序更多的标签属性。  在网站制作的案例中,大部分讲到了CSS无序列表的应用,而jb51.net更...
  • 集合(set)类型也是用来保存多个的字符串元素,但和列表类型不一样的是,集合中不允许有重复元素,并且集合中的元素是无序的,不通过索引下标获取元素。如图2-22所示,集合user:1:follow包含着"it"、"music"、...
  • Android广播的发送接收

    千次阅读 2015-12-22 14:42:10
    有序广播与无序广播的区别 无序广播:只要是广播接收者指定了接收的事件类型,就可以接收到发送出来的广播消息。不修改消息。 有序广播:发送的广播消息会按照广播接收者的优先级从高到低,一级一级的发送消息...
  • 有序链表的基本用法

    千次阅读 2018-07-30 23:25:29
    有序链表:链表本身是一种无序的数据结构,元素的插入和删除不保证顺序性,但是有没有有序的链表呢?答案是肯定的,我们在单链表中插入元素时,只需要将插入的元素头结点及其后面的结点比较,从而找到合适的位置...
  • 序言 ...Zset跟Set之间可以有并集运算,因为他们存储的数据字符串集合,不有一样的...zset叫做有序集合,而set是无序的,zset怎么做到有序的呢?就是zset的每一个成员都有一个分数之对应,并且分数是可以重
  • 新标准定义了4个无序关联容器,这些容器不是使用...无序容器提供了与有序容器相同的操作。这意味着我们在map和set操作也用于unordered_map和unordered _set。类似的,无需容器也有允许重复关键字的版本。示例程序:
  • 方法通过对沈阳文化艺术中心上部网壳钢结构进行分析,将非常规无序的屋面网架结构拆分成常规有序的单元体,利用有限元分析软件MIDAS Gen建立结构的整体模型,进行整体稳定性分析.结果绝大多数主次杆件的比值均在...
  • RocketMQ常见问题-消息有序

    千次阅读 2020-05-05 16:44:58
    RocketMQ做到顺序消费,但是单独依赖RocketMQ做不到消息有序性,保证消息有序性必须进行业务干预。 通常来讲,顺序消费是指消息的消费顺序和消息的投递顺序保持一致,但是消息有序性是指消息参数的顺序消息最终...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 461
精华内容 184
关键字:

有序能与无序能