list介绍和基本使用

最新推荐文章于 2024-09-24 20:20:23 发布
最新推荐文章于 2024-09-24 20:20:23 发布
阅读量1.6k 收藏 5
点赞数 19
分类专栏： c++ 文章标签： c++ list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DR5200/article/details/119669896
版权
本文详细介绍了C++标准库中的list容器，包括其双向链表实现、构造方法、迭代器使用、容量判断、元素访问、成员函数如assign、push_front/pop_front等，以及splice、erase、swap、resize和clear等高级操作。重点展示了如何在实际编程中高效地操作和管理list对象。
摘要由CSDN通过智能技术生成

文章目录

一. list介绍

list文档介绍

1). list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2). list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3). list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝后迭代，已让其更简单高效。
4).与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5). 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)

二. list使用

constructor

1).构造一个空容器

list<int> lt;

2).构造一个含有n个值为val的容器

list<int> lt(10,5);

3).拷贝构造

list<int> lt2(lt);

4). 迭代器区间构造

	int a[] = { 16,2,77,29 };
	list<int> lt2(a,a + 4);
	/*  while(first != last)
	*  {
	*		push_back(*first);
	*		++first;
	*  }
	*/
	print(lt2);
	// swap,find,reverse,sort 常用的算法 <algorithm>
	// 原生指针可以看作天然的迭代器
	sort(a,a + 4);
	sort(a, a + 4, greater<int>());
	// sort排序底层是快速排序，迭代器类型只能是随机迭代器
	// 比如三数取中优化，lt不支持随机访问
	sort(lt.begin(),lt.end());

在这里插入图片描述

list迭代器是双向迭代器，不支持 - 操作，因此报错

这里顺便介绍一下迭代器的类型 :
单向迭代器 : 只能向后依次遍历(只支持++操作) (如 forward_list)
双向迭代器 : 可以向前向后依次遍历(支持++和–操作) (如 list)
随机迭代器 : 可以向前向后随机遍历(支持++ /- - / + / - / += / -= 操作) (如 vector/string)

在这里插入图片描述

iterator

在这里插入图片描述

iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;

#include <iostream>
#include <list>
using namespace std;
int main()
{
	list<int> lt(10, 5);
	//正向迭代器遍历容器
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	// 反向迭代器遍历容器
	list<int>::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << " ";
		rit++;
	}
	cout << endl;
	return 0;
}

capacity

empty

判断容器是否为空

#include <iostream>
#include <list>
using namespace std;
int main()
{
	list<int> lt; 
	cout << lt.empty() << endl; //1
	return 0;
}

size

获取容器中的元素个数

#include <iostream>
#include <list>
using namespace std;
int main()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	cout << lt.size() << endl; //4
	return 0;
}

Element access

front/back

front函数用于获取list容器当中的第一个元素的引用，back函数用于获取list容器当中的最后一个元素的引用

#include <iostream>
#include <list>
using namespace std;
int main()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	cout << lt.front() << endl; //1
	cout << lt.back() << endl; //4
	return 0;
}

Modifiers

assign

将新内容赋值给list容器，替换其当前内容，并相应地修改其大小

1). 将n个值为val的数据分配给容器。
2). 将所给迭代器区间当中的内容分配给容器。

// list::assign
#include <iostream>
#include <list>
using namespace std;
int main ()
{
  	list<int> first;
  	list<int> second;
  	first.assign (7,100);                      // 7 ints with value 100
  	second.assign (first.begin(),first.end()); // a copy of first

  	int myints[]={1776,7,4};
  	first.assign (myints,myints+3);            // assigning from array

  	cout << "Size of first: " << int (first.size()) << endl; // 3
  	cout << "Size of second: " << int (second.size()) << endl; // 7
  	return 0;
}

push_front/pop_front

头插，头删容器中的数据

#include <iostream>
#include <list>
using namespace std;
int main ()
{
  	list<int> mylist (2,100);         // two ints with a value of 100
  	mylist.push_front (200);
  	mylist.push_front (300);

 	cout << "mylist contains:";
  for (list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    	cout << ' ' << *it;
  cout << endl;
  return 0;
  // output 
  // 300 200 100 100
}

#include <iostream>
#include <list>
using namespace std;
int main ()
{
  	list<int> mylist;
  	mylist.push_back (100);
  	mylist.push_back (200);
  	mylist.push_back (300);

  cout << "Popping out the elements in mylist:";
  while (!mylist.empty())
  {
    	cout << ' ' << mylist.front();
    	mylist.pop_front();
  }

  cout << "\nFinal size of mylist is " << mylist.size() << endl;

  return 0;
  // output
  // Popping out the elements in mylist: 100 200 300
  // Final size of mylist is 0
}

push_back/pop_back

尾插，尾删容器中的数据

// list::push_back
#include <iostream>
#include <list>
int main ()
{
  std::list<int> mylist;
  int myint;

  std::cout << "Please enter some integers (enter 0 to end):\n";

  do {
    std::cin >> myint;
    mylist.push_back (myint);
  } while (myint);

  std::cout << "mylist stores " << mylist.size() << " numbers.\n";

  return 0;
}

// list::pop_back
#include <iostream>
#include <list>
int main ()
{
  std::list<int> mylist;
  int sum (0);
  mylist.push_back (100);
  mylist.push_back (200);
  mylist.push_back (300);

  while (!mylist.empty())
  {
    sum+=mylist.back();
    mylist.pop_back();
  }

  std::cout << "The elements of mylist summed " << sum << '\n';

  return 0;
  // output
  // The elements of mylist summed 600
}

insert

1).在指定迭代器位置插入一个数。
2). 在指定迭代器位置插入n个值为val的数。
3).在指定迭代器位置插入一段迭代器区间（左闭右开）。

// inserting into a list
#include <iostream>
#include <list>
#include <vector>
int main ()
{
  std::list<int> mylist;
  std::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            ^

  std::vector<int> myvector (2,30);
  mylist.insert (it,myvector.begin(),myvector.end());
                                                // 1 10 20 30 30 20 2 3 4 5
                                                //               ^
  std::cout << "mylist contains:";
  for (it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
  // output
  // mylist contains: 1 10 20 30 30 20 2 3 4 5
}

#include <iostream>
#include <list>
int main()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	list<int>::iterator pos = find(lt.begin(),lt.end(),3);
	lt.insert(pos,30);
	print(lt);
	cout << *pos << endl; // 3
}

insert 不会导致迭代器失效，因为链表的插入并不会影响 it/pos 所指向的位置

erase

1).删除指定迭代器位置的元素。
2). 删除指定迭代器区间（左闭右开）的所有元素。

// erasing from list
#include <iostream>
#include <list>
int main ()
{
  std::list<int> mylist;
  std::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
                             //        ^
// it1 已经失效
  std::cout << "mylist contains:";
  for (it1=mylist.begin(); it1!=mylist.end(); ++it1)
    std::cout << ' ' << *it1;
  std::cout << '\n';

  return 0;
 // Output:
//  mylist contains: 10 30 60 80 90
}

#include <iostream>
#include <list>
using namespace std;
int main()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	list<int>::iterator pos = find(lt.begin(), lt.end(), 3);
	// pos迭代器失效
	lt.erase(pos);
	print(lt);
	cout << *pos << endl;
}

erase 会导致迭代器失效，因为链表的删除会使 pos 所指向的位置被释放，从而 pos 成为野指针

swap

swap用于交换两个容器的内容

// swap lists
#include <iostream>
#include <list>
int main ()
{
  std::list<int> first (3,100);   // three ints with a value of 100
  std::list<int> second (5,200);  // five ints with a value of 200

  first.swap(second);

  std::cout << "first contains:";
  for (std::list<int>::iterator it=first.begin(); it!=first.end(); it++)
    std::cout << ' ' << *it;
  std::cout << '\n';

  std::cout << "second contains:";
  for (std::list<int>::iterator it=second.begin(); it!=second.end(); it++)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
//  Output:

//	first contains: 200 200 200 200 200 
//	second contains: 100 100 100 
}

resize

1). 若 n 小于当前容器的 size ，size 减少到 n
2). 若 n 大于当前容器的 size，尾插入数据直到 n，值用 val 来填充

// resizing list
#include <iostream>
#include <list>
int main ()
{
  std::list<int> mylist;

  // set some initial content:
  for (int i=1; i<10; ++i) mylist.push_back(i);

  mylist.resize(5);
  mylist.resize(8,100);
  mylist.resize(12);

  std::cout << "mylist contains:";
  for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;
  // output
  // mylist contains: 1 2 3 4 5 100 100 100 0 0 0 0
}

clear

清空容器，使容器的 size 成为 0

// clearing lists
#include <iostream>
#include <list>
int main ()
{
  std::list<int> mylist;
  std::list<int>::iterator it;

  mylist.push_back (100);
  mylist.push_back (200);
  mylist.push_back (300);

  std::cout << "mylist contains:";
  for (it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  mylist.clear();
  mylist.push_back (1101);
  mylist.push_back (2202);

  std::cout << "mylist contains:";
  for (it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
  // output
  // mylist contains: 100 200 300 
 //  mylist contains: 1101 2202
}

operations

splice

splice函数用于两个list容器数据之间的转移，其有三种拼接方式：

1).将整个容器拼接到另一个容器的指定迭代器位置。
2).将容器当中的某一个数据拼接到另一个容器的指定迭代器位置。
3).将容器指定迭代器区间的数据拼接到另一个容器的指定迭代器位置。

// splicing lists
#include <iostream>
#include <list>
int main ()
{
  std::list<int> mylist1, mylist2;
  std::list<int>::iterator it;

  // set some initial values:
  for (int i=1; i<=4; ++i)
     mylist1.push_back(i);      // mylist1: 1 2 3 4

  for (int i=1; i<=3; ++i)
     mylist2.push_back(i*10);   // mylist2: 10 20 30

  it = mylist1.begin();
  ++it;                         // points to 2

  mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4
                                // mylist2 (empty)
                                // "it" still points to 2 (the 5th element)
                                          
  mylist2.splice (mylist2.begin(),mylist1, it);
                                // mylist1: 1 10 20 30 3 4
                                // mylist2: 2
                                // "it" is now invalid.
  it = mylist1.begin();
  std::advance(it,3);           // "it" points now to 30

  mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end());
                                // mylist1: 30 3 4 1 10 20

  std::cout << "mylist1 contains:";
  for (it=mylist1.begin(); it!=mylist1.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  std::cout << "mylist2 contains:";
  for (it=mylist2.begin(); it!=mylist2.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
  // output
  // mylist1 contains: 30 3 4 1 10 20
  // mylist2 contains: 2
}

remove

remove函数用于删除容器当中被指定的元素，和erase不同，erase是删除迭代器位置的值

// remove from list
#include <iostream>
#include <list>
int main ()
{
  int myints[] = {17,89,7,14};
  std::list<int> mylist (myints,myints+4);

  mylist.remove(89);

  std::cout << "mylist contains:";
  for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
  // Output:
  // mylist contains: 17 7 14
}

remove_if

remove_if函数用于删除容器当中满足条件的元素。

// list::remove_if
#include <iostream>
#include <list>

// a predicate implemented as a function:
bool single_digit (const int& value) { return (value<10); }

// a predicate implemented as a class:
struct is_odd {
  bool operator() (const int& value) { return (value%2)==1; }
};

int main ()
{
  int myints[]= {15,36,7,17,20,39,4,1};
  std::list<int> mylist (myints,myints+8);   // 15 36 7 17 20 39 4 1

  mylist.remove_if (single_digit);           // 15 36 17 20 39

  mylist.remove_if (is_odd());               // 36 20

  std::cout << "mylist contains:";
  for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
 // Output:
 // mylist contains: 36 20
}

unique

unique函数用于删除容器当中连续的重复元素(配合sort使用)。

// list::unique
#include <iostream>
#include <cmath>
#include <list>

// a binary predicate implemented as a function:
bool same_integral_part (double first, double second)
{ return ( int(first)==int(second) ); }

// a binary predicate implemented as a class:
struct is_near {
  bool operator() (double first, double second)
  { return (fabs(first-second)<5.0); }
};

int main ()
{
  double mydoubles[]={ 12.15,  2.72, 73.0,  12.77,  3.14,
                       12.77, 73.35, 72.25, 15.3,  72.25 };
  std::list<double> mylist (mydoubles,mydoubles+10);
  
  mylist.sort();             //  2.72,  3.14, 12.15, 12.77, 12.77,
                             // 15.3,  72.25, 72.25, 73.0,  73.35

  mylist.unique();           //  2.72,  3.14, 12.15, 12.77
                             // 15.3,  72.25, 73.0,  73.35

  mylist.unique (same_integral_part);  //  2.72,  3.14, 12.15
                                       // 15.3,  72.25, 73.0

  mylist.unique (is_near());           //  2.72, 12.15, 72.25

  std::cout << "mylist contains:";
  for (std::list<double>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
  // mylist contains: 2.72 12.15 72.25
}

sort

sort 默认将容器中的数据排成升序，排降序可以用 greater<>

// list::sort
#include <iostream>
#include <list>
#include <string>
#include <cctype>

// comparison, not case sensitive.
bool compare_nocase (const std::string& first, const std::string& second)
{
  unsigned int i=0;
  while ( (i<first.length()) && (i<second.length()) )
  {
    if (tolower(first[i])<tolower(second[i])) return true;
    else if (tolower(first[i])>tolower(second[i])) return false;
    ++i;
  }
  return ( first.length() < second.length() );
}

int main ()
{
  std::list<std::string> mylist;
  std::list<std::string>::iterator it;
  mylist.push_back ("one");
  mylist.push_back ("two");
  mylist.push_back ("Three");

  mylist.sort();

  std::cout << "mylist contains:";
  for (it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  mylist.sort(compare_nocase);

  std::cout << "mylist contains:";
  for (it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
 // mylist contains: Three one two
//  mylist contains: one Three two
}

reverse

reverse函数用于将容器当中元素的位置进行逆置。

// reversing list
#include <iostream>
#include <list>

int main ()
{
  std::list<int> mylist;

  for (int i=1; i<10; ++i) mylist.push_back(i);

  mylist.reverse();

  std::cout << "mylist contains:";
  for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;
  // mylist contains: 9 8 7 6 5 4 3 2 1
}
【C++STL基础入门】list基本使用
m0_62599305的博客
10-13 1779
STL（Standard Template Library）是C++标准库的一个重要组成部分，提供了一套丰富的数据结构和算法，可以大大简化C++程序的开发过程。其中，list容器是STL提供的一种双向链表实现的数据结构，具有高效的插入和删除操作，适用于需要频繁插入和删除元素的场景。本文将介绍list容器的基本使用方法，包括头文件的引入、定义和构造函数、属性函数以及运算符和算法的示例代码。STL（标准模板库）的list是C++中的一种数据结构，用于存储和操作链表。
Python学习笔记 - 探索列表List和的使用
Mr数据杨
04-27 8416
列表（List）是Python中最常用的数据结构之一，用于存储有序的元素。本文详细探讨了Python列表的各个方面，包括基本操作、高级应用，以及与其他数据结构的比较。概述了列表的基础特性，例如可变性、有序性和索引。通过多个实例详细解释了如何进行列表的创建、修改和删除。除此之外还涵盖了列表与字典、集合和元组的关系，以及如何使用列表进行数据查询和数据整合。这里为读者提供了全面而详细的Python列表使用指南。从基础概念到高级技巧，都能在这里找到详细的解释和示例。
List的使用
h1091068389的博客
04-22 1830
list
List介绍
u013135520的博客
07-25 194
List实现了collection接口 ArrayList 以数组实现的列表，不支持同步 利用索引位置可以快速定位访问 不适合指定位置的插入、删除操作 适合变动不大的，主要用于查询的数据 和java数组相比，其容量是可以动态调整的 ArrayList在元素填满容器的时会自动扩充容器大小的50% import java.util.ArrayList; import java.ut...
list的使用方法
最新发布
xushiladeng的专栏
09-24 406
list使用举例
List的介绍
阿辉爱睡觉的博客
03-13 730
什么是List 在集合框架中，List是一个接口，继承自Collection。 Collection也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示： Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下： 站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作。 常见接口介绍 方法 解释 boolean add(E e) 尾插 e void add(int inde
list的用法
feihuxiaozi的专栏
09-01 1万+
list     STL 中的list 就是一 双向链表，可高效地进行插入删除元素。 list不支持随机访问。所以没有 at(pos)和operator[]。 list 对象list1, list2 分别有元素list1(1,2,3),list2(4,
Node的介绍和基本使用(更新ing)
热门推荐
qq_46065861的博客
11-11 1万+
自己的有道云 一、什么是Node? node是一个基于Chrome V8引擎的javascript运行环境，是运行在服务器端的javascript 可以使用node搭建服务器，连接数据库。让前端开发人员走向后端开发。 Node.js使用了一个事件驱动、非阻塞I/O口，使其轻量且高效 Node的包管理工具npm,是全球最大的开源库生态系统 二、为什么要学习node? 他很火 他很强 三、node的环境搭建参考笔记： 自己有道云 检测是否安装成功 四、交互式解析器 Node 自带了交互式解释器，可以执行以下任
java基础之List和Set集合详细介绍
wushan的博客
08-05 2035
一、集合 1、集合介绍 2、Java中的集合分类 3、Collection接口 4、迭代器 5、迭代器使用细节 5.1、获取元素异常 5.2、一次判断只调用一次next方法 5.3、遍历的时候不能使用集合自身的增删方法 二、List集合 1、List接口介绍 2、ListIterator接口 3、ArrayList类 3.1、ArrayList介绍 3.2、ArrayList演示 3.3、ArrayList底层结构 4、LinkedList类 4.1、LinkedList介绍
python排序方法sorted和list.sort()使用讲解
yinyoudamo的博客
07-28 4920
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
List的用法和使用
ashfiqa的博客
09-26 4418
一、泛型 接下来我们就来看一段代码 我们会发现当把MyArrayList中定义int类型的数组时，向其中添加的元素就只能是int类型，添加其他类型就会报错，而当我们用Object类型代替时，Object过于通用。针对上述问题，我们引入泛型来进行修改，让代码更加的通用。 ...
List简介
f381226200的博客
06-22 577
List简介ArrayListLinkedList小结 List 接口继承自 Collection，在上一章 Java 容器 中已经介绍过，List 接口在 Collection 的基础上添加了大量的方法，使得可以在 List 的中间插入和移除元素。List 有两种类型： ArrayList，它随机访问元素速度较快，但是在 List 的中间插入和移除元素时较慢； LinkedList，它可以以较...
list的使用
想要上进的coder的博客
06-19 2196
一、list的介绍 list 二、list的使用 2.1list的构造函数 2.2list迭代器的使用 2.3list相关的容量大小相关的函数 2.4list数据的访问相关的函数 2.5list的数据调整相关的函数
LIST组件使用总结
weixin_34234823的博客
12-25 259
第一节、首先，看看是如何将数据添加进LIST组件中，以及如何显示鼠标点击的对象。1、静态生成方法：my_list.addItem("labe"l,data);实例：新建文件，将LIST组件拖至场景中。并将LIST组件的实例名称修改为“my_list”，在第一帧添加如下代码：System.useCodepage=true;var my_list:mx.controls.List;my_list.ad...
list的介绍与使用
weixin_43552133的博客
10-05 820
list基本内容
list组件的基本使用
weixin_61460113的博客
03-08 144
van-list组件的基本使用,移动端列表刷新
掌握Python List与Tuple使用技巧
知识点二：列表(list)的基本使用 列表是用方括号[]表示的一个有序的元素集合。列表中的元素可以是不同的数据类型，包括数字、字符串甚至是其他列表。列表的常见操作包括创建、访问、添加、修改和删除元素等。 - ...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值