list 订阅
list是一个计算机专业术语,在编程语言中List 是类库中的一个类,可以简单视之为双向连结串行,以线性列的方式管理物件集合。 展开全文
list是一个计算机专业术语,在编程语言中List 是类库中的一个类,可以简单视之为双向连结串行,以线性列的方式管理物件集合。
信息
类    型
计算机专业术语
区别于
vector
中文名
list
一般定义
一览表; 明细表; 目录; 名单
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()之间的元素删除。

    展开全文
  • List的使用

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

    List<T>的使用

    定义:List<T>类表示可通过索引访问的对象的强类型列表,提供用于对列表进行搜索、排序和操作的方法。

    作用:
    泛型最常见的用途是泛型集合
    我们在创建列表类时,列表项的数据类型可能是int,string或其它类型,如果对列表类的处理方法相同,
    就没有必要事先指定数据类型,留待列表类实例化时再指定。相当于把数据类型当成参数,这样可以最
    大限度地重用代码,保护类型的安全以及提高性能。

    List的一般用法
    所属命名空间: System.Collections.Generic
    public class List<T>:IList<T>,Icollection<T>,IEnumerable<T>,IList,Icollection,Ienumerable
    List<T>是ArrayList类的泛型等效类,该类使用大小可按需动态增加的数组实现IList<T>泛型接口

    (1)声明 List<T>mlist = new List<T>();
    eg: string[] Arr = {"a","b","c"};
    List<string> mlist = new List<string>(Arr);

    (2)添加一个元素 List.Add(T item) 
    eg: mlist.Add("d");

    (3)添加集合元素
    eg: string[] Arr2 ={"f","g"."h"};
    mlist.AddRange(Arr2);

    (4)在index位置添加一个元素 Insert(int index,T item)
    eg: mlist.Insert(1,"p");

    (5)遍历List中元素

      foreach(T element in mlist) T的类型与mlist声明时一样
         {
           Console.WriteLine(element);
    }

    eg:
    foreach(string s in mlist)
    {
    Console.WriteLine(s);
    }

    (6)删除元素

    List.Remove(T item) 删除一个值
    eg: mlist.Remove("a");

    List.RemoveAt(int index);删除下标为index的元素
    eg: mlist.RemoveAt(0);

    List.RemoveRange(int index,int count); 下标index开始,删除count个元素
    eg:mlist.RemoveRange(3,2);

    (7)判断某个元素是否在该List中

    List.Contains(T item) 返回true或false
    eg:
    if(mlist.Contains"("g"))
    Console.WriteLine("g存在列表中");
    else
    mlist.Add("g");

    (8)给List里面元素排序 List.Sort() 默认是元素每一个字母按升序
    eg: mlist.Sort();

    (9)给List里面元素顺序反转 List.Reverse() 可以与List.Sort()配合使用

    (10)List清空 List.Clear()
    eg: mlist.Clear();

    (11)获得List中元素数目 List.Count() 返回int值
    eg: mlist.count();


    List进阶,强大方法

    (1)List.FindAll方法:检索与指定谓词所定义的条件相匹配的所有元素

    class program
    {
    static void Main(stirng[] args)
    {
    student stu = new student();
    stu.Name="arron";
    List<student> students= new List<student>();
    students.Add(stu);
    students.Add(new student("candy"));
    FindName myname = new FindName("arron");
    foreach(student s in students.FindAll(new Predicate<student>(myname.IsName)))
    { Console.WriteLine(s);}
    }

    public class student
    {
    public string Name{get;set;}
    public student(){}
    public override string ToString()
    {
    return string.Format("姓名:{0}",Name);
    }
    }

    public class FindName
    {
    private string _name;
    public FindName(string Name)
    { this._name=Name;}
    public bool IsName(student s)
    { return (s.Name==_name)?true:false;}
    }


    (2)List.Find方法 搜索与指定谓词所定义的条件相匹配的元素,并返回整个List中的第一个匹配元素

      eg:

    //Predicate是对方法的委托,如果传递给它的对象与委托定义的条件匹配,则该方法返回true,当前List的元素
      被逐个传递给Predicate委托,并在List中间前移动,从第一个元素开始,到最后一个元素结束,当找到匹配项
      时处理停止

      第一种方法 委托给拉姆达表达式:
      eg:  
    string listFind = mlist.Find(name=>
    {
    if(name.length>3)
    return true;
    return false;
    });

    第二种方法 委托给一个函数
    eg:
    public bool ListFind(string name)

    {

    if (name.Length > 3)

    {

    return true;

    }

    return false;

    }

    这两种方法的结果是一样的

    (3) List.FindLast方法 public T FindLast(Predicate<T> match);确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。用法与List.Find相同。


    (4) List.TrueForAll方法: 确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。

    public bool TrueForAll(Predicate<T> match);

    (5) List.Take(n): 获得前n行 返回值为IEnumetable<T>,T的类型与List<T>的类型一样

    E.g.:

    IEnumerable<string> takeList= mList.Take(5);

    foreach (string s in takeList)

    {

    Console.WriteLine("element in takeList: " + s);

    }

    这时takeList存放的元素就是mList中的前5个

    (6) List.Where方法:检索与指定谓词所定义的条件相匹配的所有元素。跟List.FindAll方法类似。

    E.g.:

    IEnumerable<string> whereList = mList.Where(name =>

    {

    if (name.Length > 3)

    {

    return true;

    }

    else

    {

    return false;

    }

    });

    foreach (string s in subList)

    {

    Console.WriteLine("element in subList: "+s);

    }

    这时subList存储的就是所有长度大于3的元素

    (7)List.RemoveAll方法:移除与指定的谓词所定义的条件相匹配的所有元素。

    public int RemoveAll(Predicate<T> match);

    E.g.:

    mList.RemoveAll(name =>

    {

    if (name.Length > 3)

    {

    return true;

    }

    else

    {

    return false;

    }

    });

    foreach (string s in mList)

    {

    Console.WriteLine("element in mList: " + s);

    }

    这时mList存储的就是移除长度大于3之后的元素。

    展开全文
  • 列表(list)的特性

    千次阅读 2018-08-11 21:23:58
    一 什么是 list Python内置的一种数据类型是列表(listlist是一种有序的集合,可以随时添加和删除其中的元素,可以存储任意数据类型的集和 li = [1, 1.2, 2j+3, True, "hello"] print( li, ...
  • Python--(列表)

    2018-05-06 16:40:32
    一.列表的数据项不需要具有相同的类型创建一个列表,只要把逗号分隔的不同数据项实用方括号括起来即可.列表也可以使用切片:原来字符串的切片在这里也可以用 li=['Google','Runnoob',1997,...class 'list'&gt; ['...
  • list  去掉重复

    2014-03-08 10:08:42
    for (int i = 0; i  {  for (int j = listToolkit_PowerMORE.size() - 1; j > i; j--)  {  if (listToolkit_PowerMORE.get(j).getToolkit_Power_id()== (listToolkit_PowerMORE.get(i).getTo
  • java List基本操作

    千次阅读 2019-06-03 17:15:42
    Java List中的常用操作: list中添加,获取,删除元素; list中是否包含某个元素; list中根据索引将元素数值改变(替换); list中查看(判断)元素的索引; 根据元素索引位置进行的判断; 利用list中索引位置...
  • list 详解

    千次阅读 2018-06-10 20:06:46
    1.关于list容器list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的,list中的数据元素是通过链表指针串连成逻辑意义上的线性表,也就是list也具有链表的主要优点,即:在链表的任一...
  • java中List的用法和实例详解

    万次阅读 多人点赞 2010-12-28 10:05:00
    java中List的用法和实例详解 List的用法 List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口,所以List接口拥有Collection接口提供的所有常用方法,又因为List是列表类型...
  • 实现集合List中的元素进行排序

    万次阅读 多人点赞 2016-06-14 22:08:32
    Collections对List集合中的数据进行排序 有时候需要对集合中的元素按照一定的规则进行排序,这就需要用到 Java中提供的对集合进行操作的工具类Collections,其中的sort方法 先看一个简单的例子: public static ...
  • Java数组转List的三种方式及对比

    万次阅读 多人点赞 2018-03-18 00:10:04
    本文介绍Java中数组转为List三种情况的优劣对比,以及应用场景的对比,以及程序员常犯的类型转换错误原因解析。
  • unable to access android sdk add-on list

    万次阅读 多人点赞 2016-01-22 17:01:15
    你也可以查看我的其他同类文章,也会让你有一定的收货!造成这个问题的原因可能有多种,下面两种方法,我亲自测试后可用,如果都不行,请在评论里告诉我,我会尽快帮你分析解决。左侧的文章分类中,Android Studio...
  • Java编程:删除 List 元素的三种正确方法

    万次阅读 多人点赞 2016-11-30 16:44:59
    删除 List 中的元素会产生两个问题: 删除元素后 List 的元素数量会发生变化; 对 List 进行删除操作可能会产生并发问题; 我们通过代码示例演示正确的删除逻辑package com.ips.list;import java.util.ArrayList;...
  • list去重,根据对象某个属性、某几个属性去重 去除List中重复的String List unique = list.stream().distinct().collect(Collectors.toList()); 去除List中重复的对象 // Person 对象 public class ...
  • 有一个场景,就是一个有listlist里面放的是Card对象,Card对象有多个属性值,包括卡用户信息、卡类型cardType,这个list是查询用户卡包得到的卡列表。卡的类型有普卡、金卡、钻卡,等级由低到高排序分别是:普卡、...
  • 数组,List,Set相互转化

    万次阅读 多人点赞 2018-06-03 23:41:29
    转载:https://blog.csdn.net/my_precious/article/details/530102321.数组转化为List:String[] strArray= new String[]{"...List strList= Arrays.asList(strArray);2.数组转SetString[] strArray= new Stri...
  • pandas DataFrame数据转为list

    万次阅读 多人点赞 2017-05-21 22:46:10
    首先使用np.array()函数把DataFrame转化为np.ndarray(),再利用tolist()函数把np.ndarray()转为list,示例代码如下:# -*- coding:utf-8-*- import numpy as np import pandas as pddata_x = pd.read_csv("E:/...
  • Python中如何求列表list的平均数

    万次阅读 多人点赞 2019-09-28 10:12:07
    Python中如何求列表list的平均数 当列表list中只包含数字时,如何求取它的平均数: from numpy import * a = [52,69,35,65,89,15,34] b = mean(a) print(b) 运行结果: 51.285714285714285 ...
  • Android开发:shape和selector和layer-list的(详细说明)

    万次阅读 多人点赞 2013-08-02 09:59:44
    shape和selector是Android UI设计中经常用到的,比如我们要自定义一个圆角Button,点击Button有些效果的变化,就要用到shape和selector。可以这样说,shape和selector在美化控件中的作用是至关重要的。...

空空如也

1 2 3 4 5 ... 20
收藏数 5,027,875
精华内容 2,011,150
关键字:

list