{"id":13799,"date":"2018-05-04T12:25:13","date_gmt":"2018-05-04T12:25:13","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=13799"},"modified":"2021-12-04T10:15:46","modified_gmt":"2021-12-04T04:45:46","slug":"scala-list","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/scala-list\/","title":{"rendered":"Learn Scala List with Different Methods and Examples"},"content":{"rendered":"

In Scala, we have 6 kinds of collections. These are lists, sets, maps, tuples<\/a><\/strong>, options, and iterators. In this tutorial on Scala list, we will focus on Lists. We will learn to declare a Scala list, Creating Uniform List, Methods on a Scala list, Operations on a Scala list, Reversing a List in Scala Collections, Defining List using:: Nil, Tabulating a Function, Concatenating Scala list.<\/p>\n

So, let’s start learning Scala Lists.<\/p>\n

Introduction of List in Scala Collections<\/h3>\n

A collection holds things. This can be strict or lazy(don\u2019t consume memory until accessed). This can also be mutable(reassignable) or immutable. In this tutorial, we will discuss Lists. Next, we\u2019ll look at Sets. Let\u2019s begin.<\/p>\n

A list of Scala Collections is much like a Scala array<\/a><\/strong>. Except that, it is immutable and represents a linked list. An Array, on the other hand, is flat and mutable. Here\u2019s an Array:<\/p>\n

scala> var a=Array(1,2,'a')\r\na: Array[Int] = Array(1, 2, 97)\r\nscala> a(2)\r\nres3: Int = 97\r\nscala> a(2)=98\r\nscala> a\r\nres5: Array[Int] = Array(1, 2, 98)<\/pre>\n
Declaring a Scala List<\/h3>\n
Now, here\u2019s a Scala list to compare that to:<\/p>\n
scala> var a=List(1,2,'a')\r\na: List[Int] = List(1, 2, 97)\r\nscala> a(2)\r\nres8: Int = 97\r\nscala> a(3)=98\r\n<console>:13: error: value update is not a member of List[Int]\r\n      a(3)=98\r\n      ^\r\nscala> a=List(1,2,\"Ayushi\",true)\r\na: List[Any] = List(1, 2, Ayushi, true)<\/pre>\n
While declaring a Scala list, we can also denote the type of elements it will hold. If it\u2019ll hold more than one kind, we use \u2018Any\u2019. Here are few examples.<\/p>\n
scala> val a:List[Int]=List(1,3,2)\r\na: List[Int] = List(1, 3, 2)\r\nscala> val b:List[Char]=List('a','c','b')\r\nb: List[Char] = List(a, c, b)\r\nscala> val c:List[String]=List(\"Ayushi\",\"Megha\")\r\nc: List[String] = List(Ayushi, Megha)\r\nscala> val d:List[Nothing]=List()\r\nd: List[Nothing] = List()\r\nscala> val e:List[List[Int]]=List(List(1,2,3),List(4,5,6),List(7,8,9))\r\ne: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))<\/pre>\n
Defining Scala List using :: and Nil<\/h3>\n
Think of Nil as an empty list, and :: as cons. If we had to define the above lists this way, we\u2019d:<\/p>\n
scala> val a=1::(2::(\"Ayushi\"::(true::Nil)))\r\na: List[Any] = List(1, 2, Ayushi, true)\r\nscala> val a=1::2::3::Nil\r\na: List[Int] = List(1, 2, 3)\r\nscala> val b='a'::('c'::('b'::Nil))\r\nb: List[Char] = List(a, c, b)\r\nscala> val c=\"Ayushi\"::(\"Megha\"::Nil)\r\nc: List[String] = List(Ayushi, Megha)\r\nscala> val d=Nil\r\nd: scala.collection.immutable.Nil.type = List()\r\nscala> val  e=(1::(2::(3::Nil)))::(4::(5::(6::Nil)))::(7::(8::(9::Nil)))::Nil\r\ne: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))<\/pre>\n
Operations on Lists in Scala<\/h3>\n
We can carry out three operations on a Scala list to get a result:<\/p>\n
a. head<\/h4>\n
This returns the first element of a Scala list.<\/p>\n
scala> e.head\r\nres12: List[Int] = List(1, 2, 3)\r\nscala> b.head\r\nres13: Char = a<\/pre>\n
b. tail<\/h4>\n
This returns the last element of a Scala list.<\/p>\n
scala> c.tail\r\nres14: List[String] = List(Megha)<\/pre>\n
c. isEmpty<\/h4>\n
If the list is empty, this returns a Boolean true; otherwise, false.<\/p>\n
scala> d.isEmpty\r\nres15: Boolean = true\r\nscala> a.isEmpty\r\nres16: Boolean = false<\/pre>\n
Concatenating Lists in Scala<\/h3>\n
We can join or concatenate two Scala lists in one of three ways. Let\u2019s take two lists for this:<\/p>\n
scala> val a=List(1,2,3)\r\na: List[Int] = List(1, 2, 3)\r\nscala> val b=List(4,5,6)\r\nb: List[Int] = List(4, 5, 6)<\/pre>\n
a. The ::: Operator<\/h4>\n
scala> a:::b\r\nres0: List[Int] = List(1, 2, 3, 4, 5, 6)<\/pre>\n
b. The List.:::() Method<\/h4>\n
We can call the :::() method on the first list.<\/p>\n
scala> a.:::(b)\r\nres2: List[Int] = List(4, 5, 6, 1, 2, 3)\r\nscala> a\r\nres3: List[Int] = List(1, 2, 3)<\/pre>\n
c. The List.concat() Method<\/h4>\n
We can also call the concat() method on List in Scala Collections. We pass both the lists as arguments.<\/p>\n
scala> List.concat(a,b)\r\nres5: List[Int] = List(1, 2, 3, 4, 5, 6)<\/pre>\n
Read: Scala Operators with Syntax and Examples <\/a><\/strong><\/p>\n
Creating Uniform Lists in Scala<\/h3>\n
The method List.fill() creates a list and fills it with zero or more copies of an element.<\/p>\n
scala> val f=List.fill(7)(1)\r\nf: List[Int] = List(1, 1, 1, 1, 1, 1, 1)<\/pre>\n
This fills the list with seven instances of the integer 1.<\/p>\n
Tabulating a Function<\/h3>\n
Using the List.tabulate() method with a function, we can tabulate a Scala list. The first argument specifies the dimensions; the second describes the elements(computed from a function).<\/p>\n
scala> val g=List.tabulate(7)(n=>n*2)\r\ng: List[Int] = List(0, 2, 4, 6, 8, 10, 12)<\/pre>\n
We can also pass more than one size argument:<\/p>\n
scala> val h=List.tabulate(3,7)(_*_)\r\nh: List[List[Int]] = List(List(0, 0, 0, 0, 0, 0, 0), List(0, 1, 2, 3, 4, 5, 6), List(0, 2, 4, 6, 8, 10, 12))<\/pre>\n
This made a Scala List holding three Lists of lengths 7 each.<\/p>\n
scala> val i=List.tabulate(7,5)(_*_)\r\ni: List[List[Int]] = List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12), List(0, 4, 8, 12, 16), List(0, 5, 10, 15, 20), List(0, 6, 12, 18, 24))<\/pre>\n
You can see that this creates a List holding 7 Lists each holding 5 elements. These are tables of integers from 0 up.
\nRead: Scala Functions with Syntax and Examples <\/a><\/strong><\/p>\n
Reversing a Scala List<\/h3>\n
This reverses the order of elements in a list using the List.reverse method.<\/p>\n
scala> a\r\nres6: List[Int] = List(1, 2, 3)\r\nscala> a.reverse\r\nres7: List[Int] = List(3, 2, 1)\r\nscala> a\r\nres8: List[Int] = List(1, 2, 3)<\/pre>\n
Methods on a List in Scala<\/h3>\n
We can call the following methods on a Scala List: (Note that these don\u2019t modify the Lists)<\/p>\n
a. def +(elem: A): List[A]<\/h4>\n
This postpends an element to the Scala list.<\/p>\n
scala> a.+(\"2\")\r\nres86: String = List(1, 2, 3)2<\/pre>\n
b. def :::(prefix: List[A]): List[A]<\/h4>\n
This joins the List in the argument to the other List.<\/p>\n
scala> a.:::(List(7,8,9))\r\nres16: List[Int] = List(7, 8, 9, 1, 2, 3)<\/pre>\n
c. def ::(x: A): List[A]<\/h4>\n
This adds an element to a List\u2019s beginning.<\/p>\n
scala> a.::(\"2\")\r\nres17: List[Any] = List(2, 1, 2, 3)<\/pre>\n
d. def addString(b: StringBuilder): StringBuilder<\/h4>\n
This appends all elements of a Scala list to a String Builder.<\/p>\n
scala> var b=new StringBuilder()\r\nb: StringBuilder =\r\nscala> a.addString(b)\r\nres19: StringBuilder = 123\r\nscala> a\r\nres20: List[Int] = List(1, 2, 3)\r\nscala> b\r\nres21: StringBuilder = 123<\/pre>\n
e. def addString(b: StringBuilder, sep: String): StringBuilder<\/h4>\n
This does the same thing, except with a separator between the elements.
\nLet\u2019s first reset b to an empty string.<\/p>\n
scala> b=new StringBuilder()\r\nb: StringBuilder =\r\nscala> a.addString(b,\"*\")\r\nres23: StringBuilder = 1*2*3<\/pre>\n
Read: Scala Data Types <\/a><\/strong><\/p>\n
f. def apply(n: Int): A<\/h4>\n
This selects an element in the Scala List by its index.<\/p>\n
scala> a.apply(2)\r\nres24: Int = 3<\/pre>\n
g. def contains(elem: Any): Boolean<\/h4>\n
If the list contains a certain element, this returns true; otherwise, false.<\/p>\n
scala> a.contains(2)\r\nres25: Boolean = true\r\nscala> a.contains(4)\r\nres26: Boolean = false<\/pre>\n
h. def copyToArray(xs: Array[A], start: Int, len: Int): Unit<\/h4>\n
This copies the elements of a List to an Array. Start decides where to write, and len decides the length of elements to copy.<\/p>\n
scala> var arr=Array(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)\r\narr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\r\nscala>  a.copyToArray(arr,2,3)\r\nscala> arr\r\nres42: Array[Int] = Array(0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)<\/pre>\n
Let\u2019s try changing the length to 2.<\/p>\n
scala> var arr=Array(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)\r\narr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\r\nscala> a.copyToArray(arr,2,2)\r\nscala> arr\r\nres44: Array[Int] = Array(0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)<\/pre>\n
i. def distinct: List[A]<\/strong><\/h4>\n
Let\u2019s take a new Scala List for this.<\/p>\n
scala> var j=List(1,1,4,1,3,2,1)\r\nj: List[Int] = List(1, 1, 4, 1, 3, 2, 1)<\/pre>\n
Distinct returns a new List without duplicates.<\/p>\n
scala> j.distinct\r\nres46: List[Int] = List(1, 4, 3, 2)<\/pre>\n
j. def drop(n: Int): List[A]<\/h4>\n
This returns all elements except the first n.<\/p>\n
scala> j.drop(2)\r\nres47: List[Int] = List(4, 1, 3, 2, 1)<\/pre>\n
k. def dropRight(n: Int): List[A]<\/h4>\n
This returns all elements except the last n.<\/p>\n
scala> j.dropRight(2)\r\nres48: List[Int] = List(1, 1, 4, 1, 3)<\/pre>\n
Read Scala String: Creating String, Concatenation, String Length<\/a><\/strong><\/p>\n
l. def dropWhile(p: (A) => Boolean): List[A]<\/h4>\n
This drops the longest prefix of elements that satisfy the predicate.<\/p>\n
scala> j.dropWhile(x=>{x%2!=0})\r\nres52: List[Int] = List(4, 1, 3, 2, 1)<\/pre>\n
This dropped the elements 1 and 1. Then it stopped at 4 because it doesn\u2019t satisfy the predicate.<\/p>\n
m. def equals(that: Any): Boolean<\/h4>\n
This compares two sequences.<\/p>\n
scala> a.equals(b)\r\nres53: Boolean = false\r\nscala> a.equals(List(1,2,3))\r\nres55: Boolean = true\r\nn. def exists(p: (A) => Boolean): Boolean<\/pre>\n
This returns true if a predicate holds true for any value in the Scala\u00a0 List.<\/p>\n
scala> a.exists(x=>{x%2!=0})\r\nres56: Boolean = true\r\no. def filter(p: (A) => Boolean): List[A]<\/pre>\n
This returns all such values.<\/p>\n
scala> a.filter(x=>{x%2!=0})\r\nres57: List[Int] = List(1, 3)\r\n<\/pre>\n
p. def forall (p: (a) => Boolean) : Boolean<\/h4>\n
This returns true if the predicate holds true for all values in the List.<\/p>\n
scala> a.forall(x=>{x%2!=0})\r\nres58: Boolean = false<\/pre>\n
q. def indexOf(elem: A, from: Int): Int<\/h4>\n
This returns the index of the first occurrence of the element in the List.<\/p>\n
scala> a.indexOf(2)\r\nres61: Int = 1<\/pre>\n
r. def init: List[A]<\/h4>\n
This returns all elements except the last.<\/p>\n
scala> a.init\r\nres62: List[Int] = List(1, 2)<\/pre>\n
s. def iterator: Iterator[A]<\/h4>\n
This creates an iterator over the Scala List.<\/p>\n
scala> a.iterator\r\nres63: Iterator[Int] = non-empty iterator<\/pre>\n
t. def lastIndexOf(elem: A, end: Int): Int<\/h4>\n
This returns the index of the last occurrence of an element, before or at given index.<\/p>\n
scala> List(1,2,1,2,1).lastIndexOf(2)\r\nres64: Int = 3<\/pre>\n
u. def length: Int<\/h4>\n
This returns a List\u2019s length.<\/p>\n
scala> a.length\r\nres65: Int = 3<\/pre>\n
v. def map[B](f: (A) => B): List[B]<\/h4>\n
This applies the function to every element in the list.<\/p>\n
scala> a.map(x=>x*x)\r\nres66: List[Int] = List(1, 4, 9)<\/pre>\n
w. def max: A<\/h4>\n
This returns the highest element.<\/p>\n
scala> a.max\r\nres67: Int = 3<\/pre>\n
x. def min: A<\/h4>\n
This returns the lowest element.<\/p>\n
scala> a.min\r\nres68: Int = 1<\/pre>\n
y. def mkString: String<\/h4>\n
This displays all elements of a list in a String.<\/p>\n
scala> a.mkString\r\nres69: String = 123<\/pre>\n
z. def mkString(sep: String): String<\/h4>\n
This lets us define a separator for mkString.<\/p>\n
scala> a.mkString(\"*\")\r\nres71: String = 1*2*3<\/pre>\n
aa. def reverse: List[A]<\/h4>\n
This reverses a List of Scala Collections.<\/p>\n
scala> a.reverse\r\nres72: List[Int] = List(3, 2, 1)<\/pre>\n
ab. def sum: A<\/h4>\n
This returns the sum of all elements.<\/p>\n
scala> a.sum\r\nres74: Int = 6<\/pre>\n
ac. def take(n: Int): List[A]<\/h4>\n
This returns the first n elements.<\/p>\n
scala> a.take(2)\r\nres75: List[Int] = List(1, 2)<\/pre>\n
ad. def takeRight(n: Int): List[A]<\/h4>\n
This returns the last n elements.<\/p>\n
scala> a.takeRight(2)\r\nres76: List[Int] = List(2, 3)<\/pre>\n
ae. def toArray: Array[A]<\/h4>\n
This returns an Array from a List.<\/p>\n
scala> a.toArray\r\nres78: Array[Int] = Array(1, 2, 3)<\/pre>\n
af. def toBuffer[B >: A]: Buffer[B]<\/h4>\n
This returns a Buffer from a Scala List.<\/p>\n
scala> a.toBuffer\r\nres79: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3)<\/pre>\n
ag. def toSeq: Seq[A]<\/h4>\n
This returns a Seq from a List.<\/p>\n
scala> a.toSeq\r\nres81: scala.collection.immutable.Seq[Int] = List(1, 2, 3)<\/pre>\n
ah. def toSet[B >: A]: Set[B]<\/h4>\n
This returns a Set from a List.<\/p>\n
scala> a.toSet\r\nres82: scala.collection.immutable.Set[Int] = Set(1, 2, 3)<\/pre>\n
ai. def toString(): String<\/h4>\n
This returns a String from a List.<\/p>\n
scala> a.toString\r\nres83: String = List(1, 2, 3)<\/pre>\n
This was all about Scala List. Hope you like our explanation.<\/p>\n
Conclusion<\/h3>\n
This is all about Scala List. Stay tuned for tutorials on other kinds of collections like Sets and Maps. Furthermore, if you have any query, feel free to ask in the comment section.
\nFor reference<\/a>
In Scala, we have 6 kinds of collections. These are lists, sets, maps, tuples, options, and iterators. In this tutorial on Scala list, we will focus on Lists. We will learn to declare a...<\/p>\n","protected":false},"author":6,"featured_media":34770,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[61],"tags":[3160,3633,8694,9281],"class_list":["post-13799","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scala","tag-creating-uniform-list","tag-declare-a-scala-collection-list","tag-methods-on-a-scala-collections-list","tag-operations-on-a-scala-list"],"yoast_head":"\nLearn Scala List with Different Methods and Examples - DataFlair<\/title>\n<meta name=\"description\" content=\"Scala List: Learn to declare Scala list, Creating Uniform List, Operating list, Concatenating Lists, methods on a Scala list, Operations on Scala lists\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/scala-list\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Learn Scala List with Different Methods and Examples - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Scala List: Learn to declare Scala list, Creating Uniform List, Operating list, Concatenating Lists, methods on a Scala list, Operations on Scala lists\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/scala-list\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-05-04T12:25:13+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-12-04T04:45:46+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/Scala-Collections-Lists-01.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Learn Scala List with Different Methods and Examples - DataFlair","description":"Scala List: Learn to declare Scala list, Creating Uniform List, Operating list, Concatenating Lists, methods on a Scala list, Operations on Scala lists","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/scala-list\/","og_locale":"en_US","og_type":"article","og_title":"Learn Scala List with Different Methods and Examples - DataFlair","og_description":"Scala List: Learn to declare Scala list, Creating Uniform List, Operating list, Concatenating Lists, methods on a Scala list, Operations on Scala lists","og_url":"https:\/\/data-flair.training\/blogs\/scala-list\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-05-04T12:25:13+00:00","article_modified_time":"2021-12-04T04:45:46+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/Scala-Collections-Lists-01.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/scala-list\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/2c58ecb4f73a39f0ef993f1ddfcd7b89"},"headline":"Learn Scala List with Different Methods and Examples","datePublished":"2018-05-04T12:25:13+00:00","dateModified":"2021-12-04T04:45:46+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/scala-list\/"},"wordCount":1144,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/Scala-Collections-Lists-01.jpg","keywords":["Creating Uniform List","declare a Scala collection list","methods on a Scala Collections list","Operations on a Scala list"],"articleSection":["Scala Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/scala-list\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/scala-list\/","url":"https:\/\/data-flair.training\/blogs\/scala-list\/","name":"Learn Scala List with Different Methods and Examples - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/Scala-Collections-Lists-01.jpg","datePublished":"2018-05-04T12:25:13+00:00","dateModified":"2021-12-04T04:45:46+00:00","description":"Scala List: Learn to declare Scala list, Creating Uniform List, Operating list, Concatenating Lists, methods on a Scala list, Operations on Scala lists","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/scala-list\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/Scala-Collections-Lists-01.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/Scala-Collections-Lists-01.jpg","width":1200,"height":628,"caption":"Learn Scala List with Different Methods and Examples"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/scala-list\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Scala Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/scala\/"},{"@type":"ListItem","position":3,"name":"Learn Scala List with Different Methods and Examples"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/2c58ecb4f73a39f0ef993f1ddfcd7b89","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"The DataFlair Team provides industry-driven content on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our expert educators focus on delivering value-packed, easy-to-follow resources for tech enthusiasts and professionals.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam2\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/13799","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=13799"}],"version-history":[{"count":6,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/13799\/revisions"}],"predecessor-version":[{"id":104774,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/13799\/revisions\/104774"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/34770"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=13799"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=13799"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=13799"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}