list_listview - CSDN
list 订阅
list是一个计算机专业术语,在编程语言中List 是类库中的一个类,可以简单视之为双向连结串行,以线性列的方式管理物件集合。 展开全文
list是一个计算机专业术语,在编程语言中List 是类库中的一个类,可以简单视之为双向连结串行,以线性列的方式管理物件集合。
信息
中文名
list
一般定义
一览表; 明细表; 目录; 名单
类    型
计算机专业术语
区别于
vector
list一般定义
一览表; 明细表; 目录; 名[清、价目]单list 的特色是在集合的任何位置增加或删除元素都很快,但是不支持随机存取。list 是类库提供的众多容器(container)之一,除此之外还有vector、set、map、…等等。list 以模板方式实现(即泛型),可以处理任意型别的变量,包括使用者自定义的资料型态
收起全文
  • List

    2019-07-21 15:48:13
    1.ArrayList 底层是一个数组,数组查询快,增删慢。 查询时地址连续,有索引,因此查询快。 增删时,由于数组长度不可变,每次都要新建一个数组,并将原数组的数据复制,因此,增删慢。 ArrayList是非同步的,因此...

    在这里插入图片描述
    1.ArrayList
    底层是一个数组,数组查询快,增删慢。
    查询时地址连续,有索引,因此查询快。
    增删时,由于数组长度不可变,每次都要新建一个数组,并将原数组的数据复制,因此,增删慢。
    ArrayList是非同步的,因此执行效率高,但在高并发时容易引起线程安全问题。

    2.LinkedList
    linkedList底层是双向链表链表,因此查询慢,增删快。
    链表地址不连续,每次查询都要从头开始,因此慢
    但在增删时,不改变原来的结构,因此块。
    双向链表是有序的(存储和取出的顺序是一致的),单向链表是无序的。因为双向链表的一条链是用来记录顺序的。
    在这里插入图片描述
    3.vector
    底层和ArrayList一样,但他是同步的。

    展开全文
  • Java中List的详细用法

    2018-09-11 16:36:43
    list中添加,获取,删除元素; list中是否包含某个元素; list中根据索引将元素数值改变(替换); list中查看(判断)元素的索引; 根据元素索引位置进行的判断; 利用list中索引位置重新生成一个新的list(截取...

    目录:
    list中添加,获取,删除元素;
    list中是否包含某个元素;
    list中根据索引将元素数值改变(替换);
    list中查看(判断)元素的索引;
    根据元素索引位置进行的判断;
    利用list中索引位置重新生成一个新的list(截取集合);
    对比两个list中的所有元素;
    判断list是否为空;
    返回Iterator集合对象;
    将集合转换为字符串;
    将集合转换为数组;
    集合类型转换;
    去重复;

    备注:内容中代码具有关联性。

    1.list中添加,获取,删除元素;
      添加方法是:.add(e);  获取方法是:.get(index);  删除方法是:.remove(index); 按照索引删除;  .remove(Object o); 按照元素内容删除;

                List<String> person=new ArrayList<>();
                person.add("jackie");   //索引为0  //.add(e)
                person.add("peter");    //索引为1
                person.add("annie");    //索引为2
                person.add("martin");   //索引为3
                person.add("marry");    //索引为4
    
                person.remove(3);   //.remove(index)
                person.remove("marry");     //.remove(Object o)
    
                String per="";
                per=person.get(1);
                System.out.println(per);    ////.get(index)
    
                for (int i = 0; i < person.size(); i++) {
                    System.out.println(person.get(i));  //.get(index)
                }
    

    2.list中是否包含某个元素;

      方法:.contains(Object o); 返回true或者false

                List<String> fruits=new ArrayList<>();
                fruits.add("苹果");
                fruits.add("香蕉");
                fruits.add("桃子");
                //for循环遍历list
                for (int i = 0; i < fruits.size(); i++) {
                    System.out.println(fruits.get(i));
                }
                String appleString="苹果";
                //true or false
                System.out.println("fruits中是否包含苹果:"+fruits.contains(appleString));
    
                if (fruits.contains(appleString)) {
                    System.out.println("我喜欢吃苹果");
                }else {
                    System.out.println("我不开心");
                }
    

    3.list中根据索引将元素数值改变(替换);

      注意 .set(index, element); 和 .add(index, element); 的不同;

                String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
                List<String> people=new ArrayList<>();
                people.add(a);
                people.add(b);
                people.add(c);
                people.set(0, d);   //.set(index, element);     //将d唐僧放到list中索引为0的位置,替换a白龙马
                people.add(1, e);   //.add(index, element);     //将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位
    
                //增强for循环遍历list
                for(String str:people){
                    System.out.println(str);
                }
    

    4.list中查看(判断)元素的索引;  

      注意:.indexOf(); 和 lastIndexOf()的不同;

                List<String> names=new ArrayList<>();
                names.add("刘备");    //索引为0
                names.add("关羽");    //索引为1
                names.add("张飞");    //索引为2
                names.add("刘备");    //索引为3
                names.add("张飞");    //索引为4
                System.out.println(names.indexOf("刘备"));
                System.out.println(names.lastIndexOf("刘备"));
                System.out.println(names.indexOf("张飞"));
                System.out.println(names.lastIndexOf("张飞"));

    5.根据元素索引位置进行的判断;

    if (names.indexOf("刘备")==0) {
        System.out.println("刘备在这里");
    }else if (names.lastIndexOf("刘备")==3) {
        System.out.println("刘备在那里");
    }else {
        System.out.println("刘备到底在哪里?");
    }

    6.利用list中索引位置重新生成一个新的list(截取集合);

      方法: .subList(fromIndex, toIndex);  .size() ; 该方法得到list中的元素数的和

                List<String> phone=new ArrayList<>();
                phone.add("三星");    //索引为0
                phone.add("苹果");    //索引为1
                phone.add("锤子");    //索引为2
                phone.add("华为");    //索引为3
                phone.add("小米");    //索引为4
                //原list进行遍历
                for(String pho:phone){
                    System.out.println(pho);
                }
                //生成新list
                phone=phone.subList(1, 4);  //.subList(fromIndex, toIndex)      //利用索引1-4的对象重新生成一个list,但是不包含索引为4的元素,4-1=3
                for (int i = 0; i < phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和
                    System.out.println("新的list包含的元素是"+phone.get(i));
                }

    7.对比两个list中的所有元素;

      //两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象

    //1.<br>if (person.equals(fruits)) {
        System.out.println("两个list中的所有元素相同");
    }else {
        System.out.println("两个list中的所有元素不一样");
    }
    //2.       
    if (person.hashCode()==fruits.hashCode()) {
        System.out.println("我们相同");
    }else {
        System.out.println("我们不一样");
    }
    

    8.判断list是否为空;

      //空则返回true,非空则返回false

    if (person.isEmpty()) {
        System.out.println("空的");
    }else {
        System.out.println("不是空的");
    }

    9.返回Iterator集合对象;

    System.out.println("返回Iterator集合对象:"+person.iterator());

    10.将集合转换为字符串;

    String liString="";
    liString=person.toString();
    System.out.println("将集合转换为字符串:"+liString);

    11.将集合转换为数组;

    System.out.println("将集合转换为数组:"+person.toArray());

    12.集合类型转换;

    //1.默认类型
    List<Object> listsStrings=new ArrayList<>();
      for (int i = 0; i < person.size(); i++) {
        listsStrings.add(person.get(i));
    }
    //2.指定类型
    List<StringBuffer> lst=new ArrayList<>();
      for(String string:person){
      lst.add(StringBuffer(string));
    }

    13.去重复;

                List<String> lst1=new ArrayList<>();
                lst1.add("aa");
                lst1.add("dd");
                lst1.add("ss");
                lst1.add("aa");
                lst1.add("ss");
    
                       //方法 1.
                for (int i = 0; i <lst1.size()-1; i++) {
                    for (int j = lst1.size()-1; j >i; j--) {
                        if (lst1.get(j).equals(lst1.get(i))) {
                            lst1.remove(j);
                        }
                    }
                }
                System.out.println(lst1);
    
                       //方法 2.
                List<String> lst2=new ArrayList<>();
                for (String s:lst1) {
                    if (Collections.frequency(lst2, s)<1) {
                        lst2.add(s);
                    }
                }
                System.out.println(lst2);
    

    附完整代码

    package MyTest01;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ListTest01 {
    
        public static void main(String[] args) {
    
                //list中添加,获取,删除元素
                List<String> person=new ArrayList<>();
                person.add("jackie");   //索引为0  //.add(e)
                person.add("peter");    //索引为1
                person.add("annie");    //索引为2
                person.add("martin");   //索引为3
                person.add("marry");    //索引为4
    
                person.remove(3);   //.remove(index)
                person.remove("marry");     //.remove(Object o)
    
                String per="";
                per=person.get(1);
                System.out.println(per);    ////.get(index)
    
                for (int i = 0; i < person.size(); i++) {
                    System.out.println(person.get(i));  //.get(index)
                }
    
    
    
                //list总是否包含某个元素
                List<String> fruits=new ArrayList<>();
                fruits.add("苹果");
                fruits.add("香蕉");
                fruits.add("桃子");
                //for循环遍历list
                for (int i = 0; i < fruits.size(); i++) {
                    System.out.println(fruits.get(i));
                }
                String appleString="苹果";
                //true or false
                System.out.println("fruits中是否包含苹果:"+fruits.contains(appleString));
    
                if (fruits.contains(appleString)) {
                    System.out.println("我喜欢吃苹果");
                }else {
                    System.out.println("我不开心");
                }
    
                //list中根据索引将元素数值改变(替换)
                String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
                List<String> people=new ArrayList<>();
                people.add(a);
                people.add(b);
                people.add(c);
                people.set(0, d);   //.set(index, element)      //将d唐僧放到list中索引为0的位置,替换a白龙马
                people.add(1, e);   //.add(index, element);     //将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位
    
                //增强for循环遍历list
                for(String str:people){
                    System.out.println(str);
                }
    
                //list中查看(判断)元素的索引
                List<String> names=new ArrayList<>();
                names.add("刘备");    //索引为0
                names.add("关羽");    //索引为1
                names.add("张飞");    //索引为2
                names.add("刘备");    //索引为3
                names.add("张飞");    //索引为4
                System.out.println(names.indexOf("刘备"));
                System.out.println(names.lastIndexOf("刘备"));
                System.out.println(names.indexOf("张飞"));
                System.out.println(names.lastIndexOf("张飞"));
    
                //根据元素索引位置进行的判断
                if (names.indexOf("刘备")==0) {
                    System.out.println("刘备在这里");
                }else if (names.lastIndexOf("刘备")==3) {
                    System.out.println("刘备在那里");
                }else {
                    System.out.println("刘备到底在哪里?");
                }
    
                //利用list中索引位置重新生成一个新的list(截取集合)
                List<String> phone=new ArrayList<>();
                phone.add("三星");    //索引为0
                phone.add("苹果");    //索引为1
                phone.add("锤子");    //索引为2
                phone.add("华为");    //索引为3
                phone.add("小米");    //索引为4
                //原list进行遍历
                for(String pho:phone){
                    System.out.println(pho);
                }
                //生成新list
                phone=phone.subList(1, 4);  //.subList(fromIndex, toIndex)      //利用索引1-4的对象重新生成一个list,但是不包含索引为4的元素,4-1=3
                for (int i = 0; i < phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和
                    System.out.println("新的list包含的元素是"+phone.get(i));
                }
    
                //对比两个list中的所有元素
                //两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象
                if (person.equals(fruits)) {
                    System.out.println("两个list中的所有元素相同");
                }else {
                    System.out.println("两个list中的所有元素不一样");
                }
    
                if (person.hashCode()==fruits.hashCode()) {
                    System.out.println("我们相同");
                }else {
                    System.out.println("我们不一样");
                }
    
    
                //判断list是否为空
                //空则返回true,非空则返回false
                if (person.isEmpty()) {
                    System.out.println("空的");
                }else {
                    System.out.println("不是空的");
                }
    
                //返回Iterator集合对象
                System.out.println("返回Iterator集合对象:"+person.iterator());
    
                //将集合转换为字符串
                String liString="";
                liString=person.toString();
                System.out.println("将集合转换为字符串:"+liString);
    
                //将集合转换为数组,默认类型
                System.out.println("将集合转换为数组:"+person.toArray());
    
                ////将集合转换为指定类型(友好的处理)
                //1.默认类型
                List<Object> listsStrings=new ArrayList<>();
                for (int i = 0; i < person.size(); i++) {
                    listsStrings.add(person.get(i));
                }
                //2.指定类型
                List<StringBuffer> lst=new ArrayList<>();
                for(String string:person){
                    lst.add(StringBuffer(string));
                }
    
    
    
    
        }
    
        private static StringBuffer StringBuffer(String string) {
            return null;
        }
    
    
        }
    展开全文
  • C++中list用法详解

    2016-09-20 23:00:21
    1.关于list容器 list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的,list中的数据元素是通过链表指针串连成逻辑意义上的线性表,也就是list也具有链表的主要优点,即:在链表的...

    1.关于list容器

    list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的,list中的数据元素是通过链表指针串连成逻辑意义上的线性表,也就是list也具有链表的主要优点,即:在链表的任一位置进行元素的插入、删除操作都是快速的。list的实现大概是这样的:list的每个节点有三个域:前驱元素指针域、数据域和后继元素指针域。前驱元素指针域保存了前驱元素的首地址;数据域则是本节点的数据;后继元素指针域则保存了后继元素的首地址。其实,list和循环链表也有相似的地方,即:头节点的前驱元素指针域保存的是链表中尾元素的首地址,list的尾节点的后继元素指针域则保存了头节点的首地址,这样,list实际上就构成了一个双向循环链。由于list元素节点并不要求在一段连续的内存中,显然在list中是不支持快速随机存取的,因此对于迭代器,只能通过“++”或“--”操作将迭代器移动到后继/前驱节点元素处。而不能对迭代器进行+n或-n的操作,这点,是与vector等不同的地方。

     

    我想把三个常用的序列式放在一起对比一下是有必要的:

    vector : vector和built-in数组类似,拥有一段连续的内存空间,能非常好的支持随即存取,即[]操作符,但由于它的内存空间是连续的,所以在中间进行插入和删除会造成内存块的拷贝,另外,当插入较多的元素后,预留内存空间可能不够,需要重新申请一块足够大的内存并把原来的数据拷贝到新的内存空间。这些影响了vector的效率,但是实际上用的最多的还是vector容器,建议大多数时候使用vector效率一般是不错的。vector的用法解析可以参考本人的另一篇随笔:http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/08/2627666.html

    list:      list就是数据结构中的双向链表(根据sgi stl源代码),因此它的内存空间是不连续的,通过指针来进行数据的访问,这个特点使得它的随即存取变的非常没有效率,因此它没有提供[]操作符的重载。但由于链表的特点,它可以以很好的效率支持任意地方的删除和插入。

    deque: deque是一个double-ended queue,它的具体实现不太清楚,但知道它具有以下两个特点:它支持[]操作符,也就是支持随即存取,并且和vector的效率相差无几,它支持在两端的操作:push_back,push_front,pop_back,pop_front等,并且在两端操作上与list的效率也差不多。

     

    因此在实际使用时,如何选择这三个容器中哪一个,应根据你的需要而定,具体可以遵循下面的原则
    1. 如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector
    2. 如果你需要大量的插入和删除,而不关心随即存取,则应使用list
    3. 如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque。

     

    2.list中常用的函数

    2.1list中的构造函数:

    list() 声明一个空列表;

    list(n) 声明一个有n个元素的列表,每个元素都是由其默认构造函数T()构造出来的

    list(n,val) 声明一个由n个元素的列表,每个元素都是由其复制构造函数T(val)得来的

    list(n,val) 声明一个和上面一样的列表

    list(first,last) 声明一个列表,其元素的初始值来源于由区间所指定的序列中的元素


    2.2 begin()和end():通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator,可以调用list容器的 end() 函数来得到list末端下一位置,相当于:int a[n]中的第n+1个位置a[n],实际上是不存在的,不能访问,经常作为循环结束判断结束条件使用。


    2.3 push_back() 和push_front():使用list的成员函数push_back和push_front插入一个元素到list中。其中push_back()从list的末端插入,而 push_front()实现的从list的头部插入。


    2.4 empty():利用empty() 判断list是否为空。


    2.5 resize(): 如果调用resize(n)将list的长度改为只容纳n个元素,超出的元素将被删除,如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val),则扩展元素要调用构造函数T(val)函数进行元素构造,其余部分相同。


    2.6 clear(): 清空list中的所有元素。


    2.7 front()和back(): 通过front()可以获得list容器中的头部元素,通过back()可以获得list容器的最后一个元素。但是有一点要注意,就是list中元素是空的时候,这时候调用front()和back()会发生什么呢?实际上会发生不能正常读取数据的情况,但是这并不报错,那我们编程序时就要注意了,个人觉得在使用之前最好先调用empty()函数判断list是否为空。


    2.8 pop_back和pop_front():通过删除最后一个元素,通过pop_front()删除第一个元素;序列必须不为空,如果当list为空的时候调用pop_back()和pop_front()会使程序崩掉。


    2.9 assign():具体和vector中的操作类似,也是有两种情况,第一种是:l1.assign(n,val)将 l1中元素变为n个T(val)。第二种情况是:l1.assign(l2.begin(),l2.end())将l2中的从l2.begin()到l2.end()之间的数值赋值给l1。


    2.10 swap():交换两个链表(两个重载),一个是l1.swap(l2); 另外一个是swap(l1,l2),都可能完成连个链表的交换。


    2.11 reverse():通过reverse()完成list的逆置。


    2.12 merge():合并两个链表并使之默认升序(也可改),l1.merge(l2,greater<int>()); 调用结束后l2变为空,l1中元素包含原来l1 和 l2中的元素,并且排好序,升序。其实默认是升序,greater<int>()可以省略,另外greater<int>()是可以变的,也可以不按升序排列。

    看一下下面的程序:

    复制代码
     1 #include <iostream>
     2 #include <list>
     3 
     4 using namespace std;
     5 
     6 int main()
     7 {
     8     list<int> l1;
     9     list<int> l2(2,0);
    10     list<int>::iterator iter;
    11     l1.push_back(1);
    12     l1.push_back(2);
    13     l2.push_back(3);
    14     l1.merge(l2,greater<int>());//合并后升序排列,实际上默认就是升序
    15     for(iter = l1.begin() ; iter != l1.end() ; iter++)
    16     {
    17         cout<<*iter<<" ";
    18     }
    19     cout<<endl<<endl;
    20     if(l2.empty())
    21     {
    22         cout<<"l2 变为空 !!";
    23     }
    24     cout<<endl<<endl;
    25     return 0;
    26 }
    复制代码

    运行结果:


    2.13 insert():在指定位置插入一个或多个元素(三个重载):

    l1.insert(l1.begin(),100); 在l1的开始位置插入100。

    l1.insert(l1.begin(),2,200); 在l1的开始位置插入2个100。

    l1.insert(l1.begin(),l2.begin(),l2.end());在l1的开始位置插入l2的从开始到结束的所有位置的元素。


    2.14 erase():删除一个元素或一个区域的元素(两个重载)

    l1.erase(l1.begin()); 将l1的第一个元素删除。

    l1.erase(l1.begin(),l1.end()); 将l1的从begin()到end()之间的元素删除。

    展开全文
  • 【JAVA基础】-- List

    2019-06-27 15:51:50
    java8 1.按顺序排列 List<Entity>...list.stream().sorted(Comparator.comparing(Entity::getCreateTime)).collect(Collectors.toList()); //按时间逆序 list.stream().sorted(Compara...

    java8

    1.按顺序排列

    List<Entity> list = new ArrayList();
    //按时间顺序
    list.stream().sorted(Comparator.comparing(Entity::getCreateTime)).collect(Collectors.toList());
    //按时间逆序
    list.stream().sorted(Comparator.comparing(Entity::getCreateTime).reversed()).collect(Collectors.toList());
    //按id从小到大
    List<User> sortUser = list.stream().sorted((u1, u2) -> u1.getId().compareTo(u2.getId())).collect(Collectors.toList());
    ////按id从大到小
    List<User> sortUser = list.stream().sorted((u1, u2) -> u2.getId().compareTo(u1.getId())).collect(Collectors.toList());

     

    List<Integer> integerList = Arrays.asList(4, 5, 2, 3, 7, 9);
    List<Integer> collect = integerList.stream()
            .map(i -> i * i).distinct()
            .collect(Collectors.toList());
    Collections.sort(collect);  //升序
    //collect.sort(Comparator.reverseOrder()); //倒序
    collect.forEach(System.out::println);
    // 如果两个苹果的重量一样重,怎么办?那就再找一个条件进行排序呗
    inventory.sort(comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor))

    2.list分组去重

    分组:

    classEntities.stream().collect(Collectors.groupingBy(ClassEntity::getGrade));

    去重(根据年级和专业,当年级和专业都相同的情况下看做是重复数据):

    List<ClassEntity> distinctClass = classEntities.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getProfessionId() + ";" + o.getGrade()))), ArrayList::new));


    通过hashSet去重(如将classNames去重):该种去重是bean完全相同的时候算重复数据

    List<String> classNameList = new ArrayList(new HashSet(classNames));

    补:java8 快速实现List转map 、分组、过滤等操作

           java找出2个集合相同和不同的元素(以及去除List中的重复元素)

     

    展开全文
  • 因为最近一直在用 C++ 的 list,搜到的那个最高访问的 CSDN 博文写的不够简洁。而官网上的一些例子有些细节没涉及到,得自己再复制下来跑一遍才能搞明白。于是便萌生了写这篇博文的念头,方便自己以后查阅。 本文的...

    因为最近一直在用 C++ 的 list,搜到的那个最高访问的 CSDN 博文写的不够简洁。而官网上的一些例子有些细节没涉及到,得自己再复制下来跑一遍才能搞明白。于是便萌生了写这篇博文的念头,方便自己以后查阅。

    本文的例子都来自官网的介绍:http://www.cplusplus.com/reference/list/list/

    https://en.cppreference.com/w/cpp/container/list 这个网站上的例子可以直接在线运行,修改查看起来十分方便。

    可以使用 C++17 开始引入的 std::experimental::ostream_joiner 来快捷输出 list 中所有元素。使用时记得引入头文件 #include <experimental/iterator>

    std::copy(std::begin(mylist),
              std::end(mylist),
              std::experimental::make_ostream_joiner(std::cout, ", "));
    

    list 实现

    list 容器是由双向链表实现的,因此不能使用下标运算符 [] 访问其中的元素

    使用 list 的时候得加上 #include <list> 头文件以及得在 std 名字空间中使用。

    list 定义和初始化

    只需要简单的 list<TYPE> my_list; 就可以完成对一个 list 的定义了。不需要 new。

    初始化的话就要用到 list 的构造函数
    一个简单的例子是:

      int myints[] = {75,23,65,42,13};
      list<int> mylist (myints, myints+5);
    

    当然我们仍然可以使用一些函数对 list 增加删除元素。

    list 函数介绍

    这里介绍一些我觉得可能比较常用的函数。

    迭代器

    函数名 作用
    begin 将迭代器返回到开头(Return iterator to beginning)
    end 将迭代器返回到最后(Return iterator to end)
    rbegin Return reverse iterator to reverse beginning
    rend Return reverse iterator to reverse end

    C++ 11 标准又新增 cbegin, cend, crbegin 和 crend 这四个函数,返回的都是 const_iterator。

    容量

    函数名 作用
    empty 检查容器是否为空
    size 返回当前容器内元素个数
    max_size 返回当前容器能容纳的最大元素数量

    元素访问

    函数名 作用
    front 访问第一个元素
    back 访问最后一个元素

    更改 list

    函数名 作用
    assign Assign new content to container
    push_front 将元素插入到开头
    pop_front 删除第一个元素
    push_back 将元素插入到最后
    pop_back 删除最后一个元素
    insert 插入元素
    erase 删除元素
    swap 交换两个 list 内容
    resize 改变容器大小
    clear 删除容器所有内容

    C++ 11 标准又增加了 emplace_front, emplace_back, emplace 这三个函数

    操作

    函数名 作用
    splice 合并两个 list
    remove 根据值删除元素
    remove_if 删除满足条件的元素
    unique 删除重复的值
    merge 合并排好序的 list
    sort 对容器内的元素排序
    reverse 将元素反序

    函数举例

    这里介绍一些函数的使用例子,加深理解。函数的排序按字典序排的,方便从目录查找跳转。

    ATTENTION:程序的输出一般写在注释里。

    assign()

    #include <iostream>
    #include <list>
    using namespace std;
    
    template <class T>
    void print_list(list<T> my_list)
    {
    	for (typename list<T>::iterator it = my_list.begin(); it != my_list.end(); ++it)
    		cout << ' ' << *it;
    
    	cout << '\n';
    } 
    
    int main ()
    {
    	list<int> first;
    	list<int> second;
    
    	first.assign (7, 100);                      // 7 ints with value 100
    	print_list(first);
    	// 100 100 100 100 100 100 100
    
    	second.assign (first.begin(),first.end()); // a copy of first
    	print_list(second);
    	// 100 100 100 100 100 100 100
    
    	int myints[]= {1776, 7, 4};
    	first.assign (myints, myints+3);            // assigning from array
    	print_list(first);
    	// 1776 7 4
    
    	cout << "Size of first: " << int (first.size()) << '\n';
    	cout << "Size of second: " << int (second.size()) << '\n';
    	// Size of first: 3
    	// Size of second: 7
    	
    	return 0
    }
    

    begin() —— 对 list 进行顺序遍历

    end() 的代码和这个一模一样。

    #include <iostream>
    #include <list>
    using namespace std;
    
    int main ()
    {
    	int myints[] = {75,23,65,42,13};
    	list<int> mylist (myints,myints+5);
    
    	cout << "mylist contains:";
    	for (list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
    		std::cout << ' ' << *it;
    
    	cout << '\n';
    	// mylist contains: 75 23 65 42 13
    	return 0;
    }
    

    erase()——动态删除

    #include <iostream>
    #include <list>
    using namespace std;
    
    int main ()
    {
    	list<int> mylist;
    	list<int>::iterator it1,it2;
    
    	// set some values:
    	for (int i=1; i<10; ++i) mylist.push_back(i*10);
    
    								// 10 20 30 40 50 60 70 80 90
    	it1 = it2 = mylist.begin(); // ^^
    	advance (it2,6);            // ^                 ^
    	++it1;                      //    ^              ^
    
    	it1 = mylist.erase (it1);   // 10 30 40 50 60 70 80 90
    								//    ^           ^
    
    	it2 = mylist.erase (it2);   // 10 30 40 50 60 80 90
    								//    ^           ^
    
    	++it1;                      //       ^        ^
    	--it2;                      //       ^     ^
    
    	mylist.erase (it1,it2);     // 10 30 60 80 90
    								//        ^
    
    	cout << "mylist contains:";
    	for (it1=mylist.begin(); it1!=mylist.end(); ++it1)
    		cout << ' ' << *it1;
    	cout << '\n';
    
    	return 0;
    }
    

    使用 erase() 函数,我们可以实现动态的删除。

    int main ()
    {
    	list<int> mylist;
    	
    	// set some values:
    	for (int i=1; i<5; ++i) mylist.push_back(i*10);
    	// 10 20 30 40
    
    	cout << "mylist contains:";
    	for (list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    	{
    		if (*it == 30)
    			it = mylist.erase(it);
    		cout << ' ' << *it;
    	}
    	cout << '\n';
    	// mylist contains: 10 20 40
    	
    	return 0;
    }
    

    insert()——插入元素

    insert 的参数还是到官网上查比较好,上面的表格里给出了链接。
    下面的 ^ 表示当前的迭代器指向哪个元素。

    #include <iostream>
    #include <list>
    #include <vector>
    using namespace std;
    
    int main ()
    {
    	list<int> mylist;
    	list<int>::iterator it;
    
    	// set some initial values:
    	for (int i=1; i<=5; ++i) mylist.push_back(i); // 1 2 3 4 5
    
    	it = mylist.begin();
    	++it;       // it points now to number 2           ^
    
    	mylist.insert (it,10);                        // 1 10 2 3 4 5
    
    	// "it" still points to number 2                      ^
    	mylist.insert (it,2,20);                      // 1 10 20 20 2 3 4 5
    
    	--it;       // it points now to the second 20            ^
    
    	vector<int> myvector (2,30);
    	mylist.insert (it,myvector.begin(),myvector.end());
    	// 1 10 20 30 30 20 2 3 4 5
    	//               ^
    	cout << "mylist contains:";
    	for (it=mylist.begin(); it!=mylist.end(); ++it)
    		cout << ' ' << *it;
    	cout << '\n';
    	// mylist contains: 1 10 20 30 30 20 2 3 4 5
    	
    	return 0;
    }
    

    merge() —— 合并两个 list

    #include <iostream>
    #include <list>
    using namespace std;
    
    // compare only integral part:
    bool mycomparison (double first, double second)
    {
    	return ( int(first)<int(second) );
    }
    
    int main ()
    {
    
    	list<double> first, second;
    
    	first.push_back (3.1);
    	first.push_back (2.2);
    	first.push_back (2.9);
    
    	second.push_back (3.7);
    	second.push_back (7.1);
    	second.push_back (1.4);
    
    	first.sort();  // 2.2 2.9 3.1
    	second.sort(); // 1.4 3.7 7.1
    
    	first.merge(second); // 1.4 2.2 2.9 3.1 3.7 7.1
    
    	// (second is now empty)
    
    	second.push_back (2.1);  // 2.1
    
    	first.merge(second, mycomparison);
    
    	cout << "first contains:";
    	for (list<double>::iterator it=first.begin(); it!=first.end(); ++it)
    		cout << ' ' << *it;
    	cout << '\n';
    	// first contains: 1.4 2.2 2.9 2.1 3.1 3.7 7.1
    	
    	return 0;
    }
    

    但是经过我的尝试,好像可以不排序合并:

    int main ()
    {
    	list<double> first, second;
    
    	for (int i=1; i<=5; ++i) first.push_back(i);
    	for (int i=1; i<=5; ++i) second.push_back(i+10);
    
    	first.merge(second);
    	// (second is now empty)
    
    	cout << "first contains:";
    	for (list<double>::iterator it=first.begin(); it!=first.end(); ++it)
    		cout << ' ' << *it;
    	cout << '\n';
    	// first contains: 1 2 3 4 5 11 12 13 14 15
    	
    	return 0;
    }
    

    rbegin() —— 对 list 进行逆向遍历

    #include <iostream>
    #include <list>
    using namespace std;
    
    int main ()
    {
    	list<int> mylist;
    	for (int i=1; i<=5; ++i) mylist.push_back(i);
    
    	cout << "mylist backwards:";
    	for (list<int>::reverse_iterator rit=mylist.rbegin(); rit!=mylist.rend(); ++rit)
    		cout << ' ' << *rit;
    
    	cout << '\n';
    	// mylist backwards: 5 4 3 2 1
    	return 0;
    }
    

    利用『逆向』这个特性,我们还可以用来实现逆向排序。STL 里的 sort 默认是按自然数顺序来排序的,要想实现从大到小排序的效果,我们有三种方法:

    • 自己写比较函数
    struct greater
    {
        template<class T>
        bool operator()(T const &a, T const &b) const { return a > b; }
    };
    
    std::sort(numbers.begin(), numbers.end(), greater());
    
    • 指定比较规则
    std::sort(numbers.begin(), numbers.end(), std::greater<int>());
    
    • 使用 rbegin()
    std::sort(numbers.rbegin(), numbers.rend());   // note: reverse iterators
    

    remove()

    #include <iostream>
    #include <list>
    using namespace std;
    
    int main ()
    {
    	int myints[]= {17,89,7,14};
    	list<int> mylist (myints,myints+4);
    	// 17 89 7 14
    	mylist.remove(89);
    	
    	cout << "mylist contains:";
    	for (list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    		cout << ' ' << *it;
    	cout << '\n';
    	// mylist contains: 17 7 14
    
    	return 0;
    }
    

    它会删除所有匹配的值,也就是说

    	int myints[]= {17,89,7,89,14};
    	list<int> mylist (myints,myints+5);
    	// 17 89 7 89 14
    	
    	mylist.remove(89);
    	// mylist contains: 17 7 14
    

    如果你想像下面这样写的话,会出现死循环。

    int main ()
    {
    	int myints[]= {17,89,7,14};
    	list<int> mylist (myints,myints+4);
    	// 17 89 7 14
    	
    	cout << "mylist contains:";
    	for (list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it) {
    		if (*it == 89) 
    			mylist.remove(89);
    		cout << ' ' << *it;
    	}
    
    	cout << '\n';
    	// 死循环
    
    	return 0;
    }
    

    想要达到上述的效果,可以使用 erase() 函数。具体代码见那一节。

    展开全文
  • List的使用

    2018-01-31 14:24:24
    List的使用 定义:List类表示可通过索引访问的对象的强类型列表,提供用于对列表进行搜索、排序和操作的方法。 作用: 泛型最常见的用途是泛型集合 我们在创建列表类时,列表项的数据类型可能是int,string...
  • List集合

    2019-05-27 17:09:57
    List a = new ArrayList();//多态 a.add(1); a.add(2); a.add(3); Iterator it = a.iterator(); while (it.hasNext()) { System.out.println(it.next()); } 深入 publi...
  • 介绍java中list,set和map 的区别
  • List三种遍历方式

    2020-04-06 16:50:41
    public class ListForeach { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.ad...
  • arrarylist与list

    2018-02-06 21:48:59
    1、什么是ArrayList ArrayList是动态数组。(add()方法)   动态的增加和减少元素 ...实现了ICollection和IList接口 ...ArrayList List = new ArrayList(); for( int i=0;i List.Add(i);   3,几个方法
  • 列表(list)的特性

    2018-08-11 21:23:58
    一 什么是 list Python内置的一种数据类型是列表(listlist是一种有序的集合,可以随时添加和删除其中的元素,可以存储任意数据类型的集和 li = [1, 1.2, 2j+3, True, "hello"] print( li, ...
  • java中List的用法和实例详解 List的用法 List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口,所以List接口拥有Collection接口提供的所有常用方法,又因为List是列表类型...
  • java中的List简单介绍

    2018-09-30 08:59:47
    List是Java中比较常用的集合类,关于List接口有很多实现类,本文就来简单介绍下其中几个重点的实现ArrayList、LinkedList和Vector之间的关系和区别。   List 是一个接口,它继承于Collection的接口。它代表着有序...
  • 有一个场景,就是一个有listlist里面放的是Card对象,Card对象有多个属性值,包括卡用户信息、卡类型cardType,这个list是查询用户卡包得到的卡列表。卡的类型有普卡、金卡、钻卡,等级由低到高排序分别是:普卡、...
  • 有一个场景,就是一个有listlist里面放的是Card对象,Card对象有多个属性值,包括卡用户信息、卡最近使用时间opTime,这个list是查询用户卡包得到的卡列表。 现在有一个需求,就是查询卡列表时,我不需要把所有...
  • list的五种去重方法

    2020-06-05 11:17:34
    面试中经常被问到的list如何去重,一般是口述,不需要代码体现,这个时候,思维一定要清晰,可以罗列出集中去重的方法,以展现你对list数据结构,以及相关方法的掌握,体现你的java基础学的是否牢固 下面,我就将五种方法逐一...
  • list去重,根据对象某个属性、某几个属性去重 去除List中重复的String List unique = list.stream().distinct().collect(Collectors.toList()); 去除List中重复的对象 // Person 对象 public class ...
  • 最近项目中需要对list集合中的重复值进行处理,大部分是采用两种方法,一种是用迭代list集合判断后赋给另一个list集合,一种是用赋给set集合再返回给list集合。 但是赋给set集合后,由于set集合是无序的,原先的...
  • Java中List集合的遍历

    2015-03-06 08:37:14
    一、对List的遍历有三种方式     List list = new ArrayList();   list.add("testone");   list.add(“testtwo”);   ...     第一种:   for(Iterator it = list.iterat
  • Set,List,Map的区别 java集合的主要分为三种类型: Set(集)List(列表)Map(映射) 要深入理解集合首先要了解下我们熟悉的数组: 数组是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型...
1 2 3 4 5 ... 20
收藏数 4,155,113
精华内容 1,662,045
关键字:

list