La clase List<T> representa la lista de objetos a los que se puede acceder por índice. Viene bajo el espacio de nombres System.Collection.Generic . La clase List se puede usar para crear una colección de diferentes tipos, como números enteros, strings, etc. La clase List<T> también proporciona los métodos para buscar, ordenar y manipular listas.
Características:
- Es diferente de las arrays. Se puede cambiar el tamaño de List<T> dinámicamente , pero las arrays no.
- La clase List<T> puede aceptar nulo como un valor válido para los tipos de referencia y también permite elementos duplicados.
- Si Count se vuelve igual a Capacity, entonces la capacidad de List aumentó automáticamente al reasignar el arreglo interno. Los elementos existentes se copiarán en la nueva array antes de agregar el nuevo elemento.
- La clase List<T> es el equivalente genérico de la clase ArrayList mediante la implementación de la interfaz genérica IList<T>.
- Esta clase puede usar tanto la igualdad como el comparador de pedidos.
- La clase List<T> no se ordena de forma predeterminada y se accede a los elementos mediante un índice de base cero.
- Para objetos List<T> muy grandes, puede aumentar la capacidad máxima a 2 mil millones de elementos en un sistema de 64 bits estableciendo el atributo habilitado del elemento de configuración en verdadero en el entorno de tiempo de ejecución.
Constructores
| Constructor | Descripción |
|---|---|
| Lista<T>() | Inicializa una nueva instancia de la clase List<T> que está vacía y tiene la capacidad inicial predeterminada. |
| Lista<T>(IEnumerable<T>) | Inicializa una nueva instancia de la clase List<T> que contiene elementos copiados de la colección especificada y tiene capacidad suficiente para acomodar la cantidad de elementos copiados. |
| Lista<T>(Int32) | Inicializa una nueva instancia de la clase List<T> que está vacía y tiene la capacidad inicial especificada. |
Ejemplo:
// C# program to create a List<T>
using System;
using System.Collections.Generic;
class Geeks {
// Main Method
public static void Main(String[] args)
{
// Creating a List of integers
List<int> firstlist = new List<int>();
// displaying the number
// of elements of List<T>
Console.WriteLine(firstlist.Count);
}
}
Producción:
0
Propiedades
| Propiedad | Descripción |
|---|---|
| Capacidad | Obtiene o establece el número total de elementos que la estructura de datos interna puede contener sin cambiar el tamaño. |
| Contar | Obtiene el número de elementos contenidos en List<T>. |
| Artículo[Int32] | Obtiene o establece el elemento en el índice especificado. |
Ejemplo:
// C# program to illustrate the
// Capacity Property of List<T>
using System;
using System.Collections.Generic;
class Geeks {
// Main Method
public static void Main(String[] args)
{
// Creating a List of integers
// Here we are not setting
// Capacity explicitly
List<int> firstlist = new List<int>();
// adding elements in firstlist
firstlist.Add(1);
firstlist.Add(2);
firstlist.Add(3);
firstlist.Add(4);
// Printing the Capacity of firstlist
Console.WriteLine("Capacity Is: " + firstlist.Capacity);
// Printing the Count of firstlist
Console.WriteLine("Count Is: " + firstlist.Count);
// Adding some more
// elements in firstlist
firstlist.Add(5);
firstlist.Add(6);
// Printing the Capacity of firstlist
// It will give output 8 as internally
// List is resized
Console.WriteLine("Capacity Is: " + firstlist.Capacity);
// Printing the Count of firstlist
Console.WriteLine("Count Is: " + firstlist.Count);
}
}
Producción:
Capacity Is: 4 Count Is: 4 Capacity Is: 8 Count Is: 6
Métodos
| Método | Descripción |
|---|---|
| Añadir(T) | Agrega un objeto al final de List<T>. |
| AddRange(IEnumerable<T>) | Agrega los elementos de la colección especificada al final de List<T>. |
| como solo lectura() | Devuelve un contenedor ReadOnlyCollection<T> de solo lectura para la colección actual. |
| Búsqueda binaria() | Utiliza un algoritmo de búsqueda binaria para ubicar un elemento específico en la List<T> ordenada o una parte de ella. |
| Claro() | Elimina todos los elementos de List<T>. |
| Contiene (T) | Determina si un elemento está en List<T>. |
| ConvertAll(Convertidor) | Convierte los elementos del List<T> actual a otro tipo y devuelve una lista que contiene los elementos convertidos. |
| Copiar a() | Copia List<T> o una parte de ella en una array. |
| Es igual a (Objeto) | Determina si el objeto especificado es igual al objeto actual. |
| Existe (Predicado<T>) | Determina si List<T> contiene elementos que coinciden con las condiciones definidas por el predicado especificado. |
| Buscar(Predicado<T>) | Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la primera aparición dentro de List<T> completo. |
| BuscarTodo(Predicado<T>) | Recupera todos los elementos que coinciden con las condiciones definidas por el predicado especificado. |
| BuscarÍndice() | Busca un elemento que coincida con las condiciones definidas por un predicado especificado y devuelve el índice de base cero de la primera aparición en List<T> o una parte de ella. Este método devuelve -1 si no se encuentra un elemento que coincida con las condiciones. |
| BuscarÚltimo(Predicado<T>) | Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la última aparición dentro de List<T> completo. |
| Buscarúltimoíndice() | Busca un elemento que coincida con las condiciones definidas por un predicado especificado y devuelve el índice de base cero de la última aparición en List<T> o una parte de ella. |
| ParaCada(Acción<T>) | Realiza la acción especificada en cada elemento de List<T>. |
| ObtenerEnumerador() | Devuelve un enumerador que itera a través de List<T>. |
| Obtener código hash() | Sirve como la función hash predeterminada. |
| ObtenerRango(Int32, Int32) | Crea una copia superficial de un rango de elementos en la fuente List<T>. |
| ObtenerTipo() | Obtiene el Tipo de la instancia actual. |
| Índice de() | Devuelve el índice de base cero de la primera aparición de un valor en List<T> o en una parte de este. |
| Insertar (Int32, T) | Inserta un elemento en List<T> en el índice especificado. |
| InsertarRango(Int32, IEnumerable<T>) | Inserta los elementos de una colección en List<T> en el índice especificado. |
| ÚltimoÍndiceDe() | Devuelve el índice de base cero de la última aparición de un valor en List<T> o en una parte de este. |
| MemberwiseClone() | Crea una copia superficial del objeto actual. |
| Quitar (T) | Elimina la primera aparición de un objeto específico de List<T>. |
| RemoveAll(Predicado<T>) | Elimina todos los elementos que coinciden con las condiciones definidas por el predicado especificado. |
| Eliminar en (Int32) | Quita el elemento en el índice especificado de List<T>. |
| EliminarRango(Int32, Int32) | Elimina un rango de elementos de List<T>. |
| Reverso() | Invierte el orden de los elementos en List<T> o una parte de ella. |
| Clasificar() | Ordena los elementos o una parte de los elementos en List<T> mediante la implementación de IComparer<T> predeterminada o especificada o un delegado de Comparison<T> proporcionado para comparar los elementos de la lista. |
| AArray() | Copia los elementos de List<T> en una nueva array. |
| Enstringr() | Devuelve una string que representa el objeto actual. |
| RecortarExceso() | Establece la capacidad en el número real de elementos en List<T>, si ese número es menor que un valor de umbral. |
| TrueForAll(Predicado<T>) | Determina si todos los elementos de List<T> coinciden con las condiciones definidas por el predicado especificado. |
Ejemplo 1:
// C# Program to check whether the
// element is present in the List
// or not
using System;
using System.Collections.Generic;
class Geeks {
// Main Method
public static void Main(String[] args)
{
// Creating an List<T> of Integers
List<int> firstlist = new List<int>();
// Adding elements to List
firstlist.Add(1);
firstlist.Add(2);
firstlist.Add(3);
firstlist.Add(4);
firstlist.Add(5);
firstlist.Add(6);
firstlist.Add(7);
// Checking whether 4 is present
// in List or not
Console.Write(firstlist.Contains(4));
}
}
Producción:
True
Ejemplo 2:
// C# Program to remove the element at
// the specified index of the List<T>
using System;
using System.Collections.Generic;
class Geeks {
// Main Method
public static void Main(String[] args)
{
// Creating an List<T> of Integers
List<int> firstlist = new List<int>();
// Adding elements to List
firstlist.Add(17);
firstlist.Add(19);
firstlist.Add(21);
firstlist.Add(9);
firstlist.Add(75);
firstlist.Add(19);
firstlist.Add(73);
Console.WriteLine("Elements Present in List:\n");
int p = 0;
// Displaying the elements of List
foreach(int k in firstlist)
{
Console.Write("At Position {0}: ", p);
Console.WriteLine(k);
p++;
}
Console.WriteLine(" ");
// removing the element at index 3
Console.WriteLine("Removing the element at index 3\n");
// 9 will remove from the List
// and 75 will come at index 3
firstlist.RemoveAt(3);
int p1 = 0;
// Displaying the elements of List
foreach(int n in firstlist)
{
Console.Write("At Position {0}: ", p1);
Console.WriteLine(n);
p1++;
}
}
}
Producción:
Elements Present in List: At Position 0: 17 At Position 1: 19 At Position 2: 21 At Position 3: 9 At Position 4: 75 At Position 5: 19 At Position 6: 73 Removing the element at index 3 At Position 0: 17 At Position 1: 19 At Position 2: 21 At Position 3: 75 At Position 4: 19 At Position 5: 73
Referencia:
Publicación traducida automáticamente
Artículo escrito por Kirti_Mangal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA