C# | Clase de lista – Part 1

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *