Open In App
Related Articles

Scala ListBuffer

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

A list is a collection which contains immutable data. List represents linked list in Scala. A List is immutable, if we need to create a list that is constantly changing, the preferred approach is to use a ListBuffer. The Scala List class holds a sequenced, linear list of items. A List can be built up efficiently only from back to front. the ListBuffer object is convenient when we want to build a list from front to back. It supports efficient prepend and append operations. Once we are done creating our list, call the toList method. To convert the ListBuffer into a List, Time taken will be constant. To use ListBuffer, scala.collection.mutable.ListBuffer class is imported, an instance of ListBuffer is created. 

Example :

var name = new ListBuffer[datatype]()  // empty buffer is created

var name = new ListBuffer("class", "gfg", "geeksforgeeks")

In the above example, first, an empty buffer is created here datatype indicates the type of data such as integer, string. Then created a buffer with three elements, of type string. Below operation can be performed on ListBuffer –

  • By using L += e we can appends the element e in constant time.
  • By using e +=: L we can prepends the element e in constant time.
  • L.toList In constant time, It returns a list with the contents of the ListBuffer . We should not use the ListBuffer once changing it to a list.

Operations on ListBuffer

Creating instance of ListBuffer: 

Scala

// Scala program to create a ListBuffer
// ListBuffer class is imported
import scala.collection.mutable.ListBuffer
 
// Creating object
object GfG
{
 
    // Main Method
    def main(args: Array[String])
    {
        // Instance of ListBuffer is created
        var name = ListBuffer[String]() 
        name += "GeeksForGeeks"
        name += "gfg"
        name += "Class"
        println(name)
    }
}

                    

Output:

ListBuffer(GeeksForGeeks, gfg, Class)

  Access element from ListBuffer: Element is accessed same as list, ListBuffer(i) is used to accessed ith index element of list. 

Scala

// Scala program to access element of ListBuffer
// ListBuffer class is imported
import scala.collection.mutable.ListBuffer
 
// Creating Object
object GFG
{
     
    // Main Method
    def main(args: Array[String])
    {
        // Instance of ListBuffer is created
        var name = ListBuffer[String]()
        name += "GeeksForGeeks"
        name += "gfg"
        name += "Class"
         
        // Accessing 1th index element of listBuffer
        println(name(1))
    }
}

                    

Output:

gfg

  Adding elements in ListBuffer:

  • Add single element to the buffer
ListBuffer+=( element)
  • Add two or more elements (method has a varargs parameter)
 ListBuffer+= (element1, element2, ..., elementN )
  • Append one or more elements (uses a varargs parameter)
ListBuffer.append( elem1, elem2, ... elemN)

Scala

// Scala program to add element in ListBuffer
// ListBuffer class is imported
import scala.collection.mutable.ListBuffer
 
// Creating Object
object GFG
{
     
    // Main Method
    def main(args: Array[String])
    {
        // Instance of ListBuffer is created
        var name = ListBuffer[String]()
     
        // Adding one element
        name += "GeeksForGeeks"
             
        // Add two or more elements
        name += ("gfg", "class")
         
        // Adding one or more element using append method
        name.append("Scala", "Article")
             
        // Printing ListBuffer
        println(name)
    }
}

                    

Output:

ListBuffer(GeeksForGeeks, gfg, class, Scala, Article)

  Deleting ListBuffer Elements:

  • Remove one element
ListBuffer-= (element)
  • Remove multiple elements
ListBuffer-= (elem1, elem2, ....., elemN)

Scala

// Scala program to delete element from ListBuffer
// ListBuffer class is imported
import scala.collection.mutable.ListBuffer
 
// Creating Object
object GFG
{
     
    // Main Method
    def main(args: Array[String])
    {
        // Instance of ListBuffer is created
        var name = ListBuffer( "GeeksForGeeks", "gfg",
                                "class", "Scala",
                                "Article" )
     
        // Deletes one element
        name -= "GeeksForGeeks"
             
        // Deletes two or more elements
        name -= ("gfg", "class")
         
        // Printing resultant ListBuffer
        println(name)
    }
}

                    

Output:

ListBuffer(Scala, Article)

  Deleting ListBuffer Elements using ListBuffer.remove() : The remove() method is used to delete one element by its position in the ListBuffer, or a series of elements beginning at a starting position. 

Scala

// Scala program for remove method, on ListBuffer
// ListBuffer class is imported
import scala.collection.mutable.ListBuffer
 
// Creating Object
object GFG
{
     
    // Main Method
    def main(args: Array[String])
    {
        // Instance of ListBuffer is created
        var name = ListBuffer( "GeeksForGeeks",
                                "gfg", "class",
                                "Scala", "Article" )
         
        // Removing 0th index element
        name.remove(0)
         
        // Printing resultant ListBuffer
        println(name)
        name.remove(1, 3)
         
        // Printing resultant ListBuffer
        println(name)
    }
}

                    

Output:

ListBuffer(gfg, class, Scala, Article)
ListBuffer(gfg)

In Scala, a ListBuffer is a mutable sequence that represents a resizable array buffer. It allows elements to be added, removed, or updated at any position in constant time, making it useful for scenarios where frequent modifications to a list are required.

Here are some key features and operations of a ListBuffer in Scala:

A ListBuffer is created by invoking its constructor, which takes no arguments:

Scala

import scala.collection.mutable.ListBuffer
 
object ListBufferExample {
  def main(args: Array[String]): Unit = {
    val listBuffer = ListBuffer[Int]()
 
    // Add elements to the list buffer
    listBuffer += 1
    listBuffer += 2
    listBuffer += 3
 
    // Append a sequence of elements to the list buffer
    listBuffer ++= Seq(4, 5, 6)
 
    // Insert an element at a specific index
    listBuffer.insert(2, 10)
 
    // Remove an element from the list buffer
    listBuffer -= 3
 
    // Update an element at a specific index
    listBuffer.update(1, 20)
 
    // Convert the list buffer to an immutable list
    val list = listBuffer.toList
 
    // Print the list buffer and the immutable list
    println("List buffer: " + listBuffer)
    println("List: " + list)
  }
}

                    

Output
List buffer: ListBuffer(1, 20, 10, 4, 5, 6)
List: List(1, 20, 10, 4, 5, 6)

In this example, we create a new ListBuffer and add, remove, and update elements in it. We then convert the ListBuffer to an immutable List and print both the ListBuffer and the List. As we can see from the output, the ListBuffer contains all the elements that were added to it, and the immutable List is a copy of the ListBuffer with the same elements in the same order.

Here are some advantages and disadvantages of using ListBuffer in Scala:

Advantages:

  1. Efficient additions, removals, and updates: ListBuffer provides efficient constant time additions, removals, and updates of elements, making it a good choice for
  2. scenarios where frequent modifications to a list are required.
  3. Flexibility: ListBuffer can be used in a variety of scenarios, including appending to the end of a list, inserting elements at a specific index, and removing elements from a list.
  4. Easy conversion to an immutable list: ListBuffer can be easily converted to an immutable List using the toList method.


Disadvantages:

  1. Mutable state: ListBuffer is a mutable data structure, meaning that its contents can be modified after creation. This can make it more difficult to reason about the behavior of a program and can lead to bugs.
  2. Not thread-safe: Because ListBuffer is mutable, it is not thread-safe by default. This means that multiple threads accessing the same ListBuffer can lead to race conditions and other concurrency-related issues.
  3. Overhead: Compared to immutable lists, ListBuffer has some overhead in terms of memory usage and performance. However, the overhead is generally small and is outweighed by the benefits of efficient modifications to the list.


Last Updated : 09 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads