精华内容
下载资源
问答
  • while一边一边
    万次阅读
    2016-03-04 20:04:59

    实现一边录音一边转化为文字的功能

    我们知道,讯飞可以实现在线语音转化功能,可以将语音实时的进行翻译,同时录音,但是这个实时转为文字功能,不是长连接,是个短连接,导致没法长时间的实现一边录音一边转换功能,本文便是为此完成的一种思路设计。

    主要动作:本来实现的是一直去检测录音,当语音识别库停止录音后重启语音识别,让继续实现转换。这里因为出现一个问题,当再次重启时,之前的录音文件则会丢掉,这样使得我们本地的录音文件不完整,于是换了一种新的思路。主要依据于语音识别可以传语音数据,让识别。那么我们可以去做如此设计:让本地一直录音,录音过程实时将录音数据传给语音识别,完成转换功能。思路描述完成,具体实现代码:(不能提供完整的代码,给出主要代码)

        private void creatAudioRecord() {
            // 获得缓冲区字节大小
            bufferSizeInBytes = AudioRecord.getMinBufferSize(AudioFileFunc.AUDIO_SAMPLE_RATE,
                    AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
            // 创建AudioRecord对象
            audioRecord = new AudioRecord(AudioFileFunc.AUDIO_INPUT, AudioFileFunc.AUDIO_SAMPLE_RATE,
                    AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSizeInBytes);
        }
           private void writeDateToFileAndRecongnizer() {
            // new一个byte数组用来存一些字节数据,大小为缓冲区大小
            byte[] audiodata = new byte[bufferSizeInBytes];
            FileOutputStream fos = null;
            int readsize = 0;
            try {
                File file = FileUtils.makeFilePath(getOutBase(), mOutPcm);
                if (file.exists()) {
                    file.delete();
                }
                fos = new FileOutputStream(file);// 建立一个可存取字节的文件
            } catch (Exception e) {
                e.printStackTrace();
            }
            while (mIsRecognizer && !Thread.currentThread().isInterrupted()) {
                readsize = audioRecord.read(audiodata, 0, bufferSizeInBytes);
                if (AudioRecord.ERROR_INVALID_OPERATION != readsize && fos != null) {
                    try {
                        mSpeechRecognizer.writeAudio(audiodata, 0, audiodata.length);
                        fos.write(audiodata);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            try {
                if (fos != null)
                    fos.close();// 关闭写入流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        mSpeechRecognizer = SpeechRecognizer.createRecognizer(DiaryPost.this, mInitListener);
         /**
         * 初始化监听器。
         */
        private InitListener mInitListener = new InitListener() {
    
            @Override
            public void onInit(int code) {
                L.d("SpeechRecognizer init() code = " + code);
                if (code != ErrorCode.SUCCESS) {
                    showToast("初始化失败,错误码:" + code);
                }
            }
        };
        /**
         * 听写监听器。
         */
        private RecognizerListener recognizerListener = new RecognizerListener() {
    
            @Override
            public void onBeginOfSpeech() {
                if (!mIsRecognizer) {
                    onRecognizerEnd();
                }
            }
    
            @Override
            public void onError(SpeechError error) {
                if (mIsRecognizer) {
                    onRecognizerStart();
                }
            }
    
            @Override
            public void onEndOfSpeech() {
                if (mIsRecognizer) {
                    onRecognizerStart();
                }
            }
    
            @Override
            public void onResult(RecognizerResult results, boolean isLast) {
                showResult(results);
                if (isLast) {
                    // TODO 最后的结果
                }
            }
    
            @Override
            public void onVolumeChanged(int i, byte[] bytes) {
                if (mIsRecognizer) {
                    int decibel = calculateDecibel(bytes);
                    mVisualizer.receive(decibel);
                }
    
            }
    
            @Override
            public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
            }
        };
    
           private void showResult(RecognizerResult results) {
            String text = JsonParser.parseIatResult(results.getResultString());
            mSpeechRecognizerIndex++;
            mSpeechRecognizerResults.put(mSpeechRecognizerIndex, text);
            StringBuffer resultBuffer = new StringBuffer();
            for (int key : mSpeechRecognizerResults.keySet()) {
                resultBuffer.append(mSpeechRecognizerResults.get(key));
            }
            mEditText.setText(resultBuffer.toString());
            mEditText.setSelection(mEditText.length());
        }
    
           public void bindParams() {
            SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
            // 清空参数
            mSpeechRecognizer.setParameter(SpeechConstant.PARAMS, null);
            mSpeechRecognizer.setParameter(SpeechConstant.AUDIO_SOURCE, "-1");
            // 设置听写引擎
            mSpeechRecognizer.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
            // 设置返回结果格式
            mSpeechRecognizer.setParameter(SpeechConstant.RESULT_TYPE, "json");
            String lag = sp.getString("iat_language_preference",
                    "mandarin");
            if (lag.equals("en_us")) {
                // 设置语言
                mSpeechRecognizer.setParameter(SpeechConstant.LANGUAGE, "en_us");
            } else {
                // 设置语言
                mSpeechRecognizer.setParameter(SpeechConstant.LANGUAGE, "zh_cn");
                // 设置语言区域
                mSpeechRecognizer.setParameter(SpeechConstant.ACCENT, lag);
            }
    
            // 设置语音前端点:静音超时时间,即用户多长时间不说话则当做超时处理
            mSpeechRecognizer.setParameter(SpeechConstant.VAD_BOS, sp.getString("iat_vadbos_preference", "3000"));
    
            // 设置语音后端点:后端点静音检测时间,即用户停止说话多长时间内即认为不再输入, 自动停止录音
            mSpeechRecognizer.setParameter(SpeechConstant.VAD_EOS, sp.getString("iat_vadeos_preference", "1000"));
    
            // 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
            mSpeechRecognizer.setParameter(SpeechConstant.ASR_PTT, sp.getString("iat_punc_preference", "1"));
    
            // 设置听写结果是否结果动态修正,为“1”则在听写过程中动态递增地返回结果,否则只在听写结束之后返回最终结果
            // 注:该参数暂时只对在线听写有效
            mSpeechRecognizer.setParameter(SpeechConstant.ASR_DWA, sp.getString("iat_dwa_preference", "0"));
        }
    
            private void onRecognizerStart() {
            Intent intent = new Intent();
            bindParams();
            mSpeechRecognizer.startListening(recognizerListener);
        }
    更多相关内容
  • List如何一边遍历,一边删除

    千次阅读 2020-06-13 18:39:30
    // clear to let GC do its work } 所以在第2次获取元素时,modCount和expectedModCount的值就不相等了,所以抛出了异常ConcurrentModificationException 那么List一边遍历一边删除正确的实现方法有哪些呢?...

    1、foreach抛出ConcurrentModificationException

            List<String> strList = new ArrayList<>();
            strList.add("Java");
            strList.add("Docker");
            strList.add("SpringCloud");
            for (String str : strList) {
                if ("Java".equals(str)) {
                    strList.remove(str);
                }
            }
            System.out.println(strList);
    

    报错信息如下:

    在这里插入图片描述

    在这里插入图片描述

    通过其生成的字节码可以看出,foreach循环在实际执行时使用的是Iterator,使用的核心方法是hasnext()next()

    ArrayList类中Iterator的实现如下:

        private class Itr implements Iterator<E> {
            int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such
          	//初始化的时候expectedModCount等于modCount
            int expectedModCount = modCount;
    
            Itr() {}
    
            public boolean hasNext() {
                return cursor != size;
            }
    
            @SuppressWarnings("unchecked")
            public E next() {
              	//调用checkForComodification,校验modCount是否等于expectedModCount,如果不等于抛出异常ConcurrentModificationException
                checkForComodification();
                int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length)
                    throw new ConcurrentModificationException();
                cursor = i + 1;
                return (E) elementData[lastRet = i];
            }
    
            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    
            @Override
            @SuppressWarnings("unchecked")
            public void forEachRemaining(Consumer<? super E> consumer) {
                Objects.requireNonNull(consumer);
                final int size = ArrayList.this.size;
                int i = cursor;
                if (i >= size) {
                    return;
                }
                final Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length) {
                    throw new ConcurrentModificationException();
                }
                while (i != size && modCount == expectedModCount) {
                    consumer.accept((E) elementData[i++]);
                }
                // update once at end of iteration to reduce heap write traffic
                cursor = i;
                lastRet = i - 1;
                checkForComodification();
            }
    
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }
    

    调用next()方法获取下一个元素时,调用了checkForComodification()校验modCount是否等于expectedModCount,如果不等于抛出异常ConcurrentModificationException

    在上面的案例中,刚开始modCountexpectedModCount的值都为3,所以第1次获取元素是没问题的,但是当执行完strList.remove(str)modCount的值就被修改成了4

        public boolean remove(Object o) {
            if (o == null) {
                for (int index = 0; index < size; index++)
                    if (elementData[index] == null) {
                        fastRemove(index);
                        return true;
                    }
            } else {
                for (int index = 0; index < size; index++)
                    if (o.equals(elementData[index])) {
                        fastRemove(index);
                        return true;
                    }
            }
            return false;
        }
    
        private void fastRemove(int index) {
            modCount++;
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
        }
    

    所以在第2次获取元素时,modCountexpectedModCount的值就不相等了,所以抛出了异常ConcurrentModificationException

    那么List一边遍历一边删除正确的实现方法有哪些呢

    1)、使用Iteratorremove()方法

    2)、JDK1.8新增的removeIf()方法

    3)、使用for循环正序遍历

    4)、使用for循环倒序遍历

    2、使用Iteratorremove()方法

            List<String> strList = new ArrayList<>();
            strList.add("Java");
            strList.add("Docker");
            strList.add("SpringCloud");
            Iterator<String> iterator = strList.iterator();
            while (iterator.hasNext()) {
                if ("Java".equals(iterator.next())) {
                    iterator.remove();
                }
            }
            System.out.println(strList);
    

    ArrayList中的Itr实现源码如下:

            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                  	//expectedModCount、modCount这2个变量的值又相等了
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    

    每次删除一个元素,都会将modCount的值重新赋值给expectedModCount,这样2个变量就相等了

    3、JDK1.8新增的removeIf()方法

            List<String> strList = new ArrayList<>();
            strList.add("Java");
            strList.add("Docker");
            strList.add("SpringCloud");
            strList.removeIf(str -> "Java".equals(str));
            System.out.println(strList);
    

    或者

            List<String> strList = new ArrayList<>();
            strList.add("Java");
            strList.add("Docker");
            strList.add("SpringCloud");
            strList.removeIf("Java"::equals);
            System.out.println(strList);
    

    Collection接口中removeIf()方法默认实现采用的也是Iteratorremove()方法

        default boolean removeIf(Predicate<? super E> filter) {
            Objects.requireNonNull(filter);
            boolean removed = false;
            final Iterator<E> each = iterator();
            while (each.hasNext()) {
                if (filter.test(each.next())) {
                    each.remove();
                    removed = true;
                }
            }
            return removed;
        }
    

    4、使用for循环正序遍历

            List<String> strList = new ArrayList<>();
            strList.add("Java");
            strList.add("Docker");
            strList.add("SpringCloud");
            for (int i = 0; i < strList.size(); ++i) {
                String str = strList.get(i);
                if ("Java".equals(str)) {
                    strList.remove(i--);
                }
            }
            System.out.println(strList);
    

    正序遍历需要修正下标,因为刚开始元素是:

    0 Java
    1 Docker
    2 SpringCloud
    

    第一次循环将Java删除后,元素的下标变成下面这样:

    0 Docker
    1 SpringCloud
    

    如果不修正下标,第二次循环时i的值是1,也就是取到了SpringCloud,这样就导致元素Docker被跳过检查了

    5、使用for循环倒序遍历

            List<String> strList = new ArrayList<>();
            strList.add("Java");
            strList.add("Docker");
            strList.add("SpringCloud");
            for (int i = strList.size() - 1; i >= 0; --i) {
                String str = strList.get(i);
                if ("SpringCloud".equals(str)) {
                    strList.remove(i);
                }
            }
            System.out.println(strList);
    

    倒序遍历不需要修正下标,因为刚开始元素是:

    0 Java
    1 Docker
    2 SpringCloud
    

    第一次循环将SpringCloud删除后,元素的下标变成下面这样:

    0 Java
    1 Docker
    

    第二次循环时i的值是1,也就是取到了元素Docker,不会导致跳过元素,所以不需要修正下标

    参考:

    https://blog.csdn.net/zwwhnly/article/details/104987143

    展开全文
  • 使用List数组实现一边遍历一边删除

    千次阅读 2021-01-21 15:52:56
    public class ListForTest { ... //List如何一边遍历,一边删除? ArrayList<User> userList = Lists.newArrayList( new User().setId("A").setName("张三"), new User().setId("B").setNa

    使用list数组一边遍历一遍删除

    public class ListForTest {
        public static void main(String[] args) {
            //List如何一边遍历,一边删除?
            ArrayList<User> userList = Lists.newArrayList(
                    new User().setId("A").setName("张三"),
                    new User().setId("B").setName("李四"),
                    new User().setId("C").setName("王五"),
                    new User().setId("D").setName("甲"),
                    new User().setId("E").setName("乙"),
                    new User().setId("F").setName("丙")
            );
            userList.add(new User("F", "丁"));
            System.out.println(userList + "原数据");
            Map<String, String> map = userList.stream().collect(Collectors.toMap(User::getId, User::getName, (k1, k2) -> k1));
            System.out.println("去重后的数据"+map);
            //map转对象
            JSONArray jsonArray = new JSONArray();
            jsonArray.add(map);
            List<User> users = jsonArray.toJavaList(User.class);
            System.out.println("map转list<user>结果为: "+users);
            //错误方法
    //        test1(userList);
            //使用Iterator的remove()方法
    //        iteratorRemove(userList);
            //使用for循环正序遍历
    //        ascForRemove(userList);
            //使用for循环倒序遍历
    //        descForRemove(userList);
            //jdk1.8 方法 List.removeIf()
    //        jdk8Remove(userList);
        }
    
        private static void jdk8Remove(ArrayList<User> userList) {
            userList.removeIf(user -> "乙".equals(user.getName()));
            System.out.println(userList + "jdk1.8 方法 List.removeIf(), 删除乙");
        }
    
        private static void descForRemove(ArrayList<User> userList) {
            for (int i = userList.size() - 1; i >= 0; i--) {
                String name = userList.get(i).getName();
                if ("甲".equals(name)) {
                    userList.remove(i);
                }
            }
            System.out.println(userList + "使用for循环倒序遍历, 删除甲");
        }
    
        private static void ascForRemove(ArrayList<User> userList) {
            for (int i = 0; i < userList.size(); i++) {
                String name = userList.get(i).getName();
                if ("王五".equals(name)) {
                    userList.remove(i);
                    i--;
                }
            }
            System.out.println(userList + "使用for循环正序遍历, 删除王五");
        }
    
        private static void iteratorRemove(ArrayList<User> userList) {
            Iterator<User> iterator = userList.iterator();
            while (iterator.hasNext()) {
                User next = iterator.next();
                if ("李四".equals(next.getName())) {
                    iterator.remove();
                }
            }
            System.out.println(userList + "使用Iterator的remove()方法,删除李四");
        }
    
        private static void test1(ArrayList<User> userList) {
            for (User user : userList) {
                if ("张三".equals(user.getName())) {
                    userList.remove(user);
                }
            }
            System.out.println(userList);
        }
    }
    
    

    在这里插入图片描述

    展开全文
  • 文章目录 1、首先是倒序遍历,因为我们删除后面的并不影响前面的 2、正序遍历删除,每删一个... while (iterator.hasNext()) { if (iterator.next() % 2 == 0) { iterator.remove(); } } System.out.println(list); } }

    在这里我就不展示错误的方式了。

    下面都假设我们要删除ArrayList中模2等于0的数

    1、首先是倒序遍历,因为我们删除后面的并不影响前面的

    public class Main {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            list.add(2);
            list.add(3);
            list.add(1);
            list.add(6);
            list.add(5);
            for (int i = list.size() - 1; i >= 0; i--) {
                if (list.get(i) % 2 == 0) {
                    list.remove(i);
                }
            }
            System.out.println(list);
        }
    }
    

    2、正序遍历删除,每删一个给下标减一

    public class Main {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            list.add(2);
            list.add(3);
            list.add(1);
            list.add(6);
            list.add(5);
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i) % 2 == 0) {
                    list.remove(i);
                    i = i - 1;
                }
            }
    
            System.out.println(list);
        }
    }
    

    3、使用list的removeIf()方法删除[推荐做法]

    public class Main {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            list.add(2);
            list.add(3);
            list.add(1);
            list.add(6);
            list.add(5);
    
            list.removeIf(i -> i  % 2 == 0);
            System.out.println(list);
        }
    }
    

    4、使用Iterator删除

    public class HelloWorld {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            list.add(2);
            list.add(3);
            list.add(1);
            list.add(6);
            list.add(5);
            Iterator<Integer> iterator = list.iterator();
            while (iterator.hasNext()) {
                if (iterator.next() % 2 == 0) {
                    iterator.remove();
                }
            }
            System.out.println(list);
        }
    }
    
    展开全文
  • set一边遍历一边删除

    2020-07-02 15:52:30
    set一边遍历一边删除 Set<String> set = new HashSet<String>(); set.add("a"); set.add("b"); set.add("c"); Set<String> setsSet = new HashSet<String>(set); Iterator<...
  • Java面试题:List一边遍历,一边删除

    千次阅读 2020-06-23 09:54:41
    // while (iterator.hasNext()) { // if (iterator.next().equals("a")) { // iterator.remove(); // } // } // // 正向for循环,记得i --,因为删除一个元素后,其他元素都会前移; // for (int i = 0; i (); i++) ...
  • while(iterator.hasNext()){ String str = iterator.next(); if ("a".equals(str)){ list.remove(str); } } } } 这种方式会抛出和增强for循环一样的异常,引起的原因相同。 四、迭代器的remove方法 package ...
  • vector对象一边遍历一边删除元素

    千次阅读 2017-04-11 21:43:35
    今天做携程的笔试题,附加编程题是删除一行字符串里面的标点符号,关于一边遍历一边删除的问题,坑踩到好几次了,真是好气啊,明明很简单的问题,写下来防止自己忘了 自己忘了else的条件了,结果最后老不出结果,一...
  • 谈谈Python中的while循环语句

    千次阅读 2020-12-24 12:23:26
    前言python中有两种循环,while和for,两种循环的区别是,while循环之前,先判断一次,如果满足条件的话,再循环,for循环的时候必须有一个可迭代的对象,才能循环,比如说得有一个数组。循环里面还有两个比较重要的...
  • Python中for循环与while循环

    千次阅读 2020-11-24 08:38:06
    一、循环的分类在Python中循环分为while循环和for循环,最终实现效果相同二、while的语法while 条件:条件成立重复执行的代码1条件成立重复执行的代码2......2.1 示例需求:实现重复执行5次print('媳妇儿,我错了')...
  • while用法

    千次阅读 2019-08-01 04:30:10
    He's out banging other women over the head with a club, while she sits at home trying to get the mastodon smell out of the carpet!---《老友记》第一季 第二集 He's out banging other women over the head...
  • 【Java面试题】List如何一边遍历,一边删除?

    万次阅读 多人点赞 2020-03-20 12:10:36
    List如何一边遍历,一边删除?
  • 02条件语句和while循环三目运算a = 6#原判断语句if a > 5:print(True)else:print(False)#三目运算print(True if a >5 else False)逻辑运算1. 三种逻辑运算与逻辑 and两边为真则为真或逻辑 or一边为真则为真非...
  • 有关while的几种用法

    千次阅读 2021-05-21 14:24:39
    While这个是英语学习中经常会遇到的,相信大家应该都不陌生,那么你清楚它的用法吗?下面学习啦小编为大家总结while的几种常见的用法,欢迎大家一起学习。while的用法:作并列连词用,意思为“而,然而”,表对比but...
  • 循环结构 编写的代码可能被执行多次 什么是循环 ​ 程序中反复执行的相同或相似代码的现象 循环的要素 1、循环次数(循环变量) ...while循环结构 1)while循环 while(条件){ //条件为真时运行的代码 }...
  • python while 循环

    千次阅读 2018-12-03 17:38:29
    #用while来循环 while,翻译成中文是“当…的时候”,这个单词在英语中,常常用来做为时间状语,while … someone do somthing,这种类型的说法是有的。在python中,它也有这个含义,不过有点区别的是,“当…时候”...
  • Java集合怎么一边删除一边遍历

    千次阅读 2016-12-09 22:33:55
    问题描述:  Java 新手容易犯一个错误,就是遍历集合的同时删除集合的元素。那么程序会发生什么呢?下面举个小例子。...所以,可以采用Iterator中的remove()方法来实现集合的一边删除一边遍历。
  • 主线程:前面要开启一个主窗口root_window,然后进入到调用子线程que = Queue.Queue()#消息队列th1=threading.Thread(target=th_work)#设定子线程th1.setDaemon(True)#守护线程th1.start()#开启子线程while True:...
  • while语句编程,输入一组整型数据,然后显示每次将输入数据进行累加运算后的结果
  • map>::iterator it=co.begin(); while(it!=co.end()){ if(it->second==0)co.erase(it);  it++; } 不管删不删除,都是it++;
  • when和while的区别

    千次阅读 2019-07-06 20:09:00
    when和while的区别①when是at or during the time that, 既指时间点,也可指一段时间;while是during the time that,只指一段时间,因此when引导的时间状语从句中的动词可以是终止性动词,也可以是延续性动词,而...
  • MySql 一边一边

    千次阅读 2014-08-21 20:51:25
     while((temp=buffer.readLine())!=null){  System.out.println(temp);  bw.write(temp+"\n");  bw.flush();  }  bw.close();  fw.close();  buffer.close();  }  }finally{  JdbcYh...
  • was mutated while being enumerated.' 当程序出现这个提示的时候,是因为你一边便利数组,又同时修改这个数组里面的内容,导致崩溃,网上的方法如下: NSMutableArray*arrayTemp=xxx; ...
  • while(1){ sleep(1); for(i=0;i;i++){ r.id=i; r.length=i; r.width=i; vec.push_back(r); } } return NULL; } void * delete4(void *argc){ while(1){ vector<Rect>::iterator it=vec...
  • 问题1:集合不能一边遍历一边删除

    千次阅读 2017-08-13 22:28:33
    上面的代码会报错,ConcurrenModificationException异常,原因是,集合不可以一边遍历一边删除。ConcurrentModificationException是Java集合的一个快速失败(fail-fast)机制,防止多个线程同时修改同一个集合的元素...
  • C++ vector一边遍历一边删除元素

    千次阅读 2014-12-04 11:38:03
    转自:  ... ...使用iterator迭代器对vector进行...while ( it != ObjectVector . end ()){ if ((* it )-> IsAlive ()){ it ++; } else { it = ObjectVector . erase ( it ); } }
  • 两天前骤降的气温依然没有恢复,甚至又开始下起了雪来,慢慢悠悠飘下来的雪花好像一点留在这里的想法都没有,一边一边化,好不容易才捕获到一点 慢慢悠悠地下雪,就导致小区里面,,,满是泥水:(取完快递回来的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,247
精华内容 27,698
关键字:

while一边一边