Scala most efficient operator to add to a list - scala

Question

Building a scala list by modifying it incrementally. What is the most efficient "add" operator? In terms of CPU and resource consumption.
For example, from List(1,2,3) we want to create a list of tuples of consecutive numbers. Which gives the result: List((1,2), (2,3))
Method 1 - using :+ operator
def createConsecutiveNumPair1[T](inList: List[T]) : List[(T, T)] = {
var listResult = List[(T, T)]()
var prev = inList(0)
for (curr <- inList.tail)
{
listResult = listResult :+ (prev, curr)
prev = curr
}
listResult
}
Method 2 - using ::= operator
def createConsecutiveNumPair2[T](inList: List[T]) : List[(T, T)] = {
var listResult = List[(T, T)]()
var prev = inList(0)
for (curr <- inList.tail)
{
listResult ::= (prev, curr)
prev = curr
}
listResult
}
TEST
scala> val l1 = List(1,2,3)
l1: List[Int] = List(1, 2, 3)
scala> createConsecutiveNumPair1(l1)
res77: List[(Int, Int)] = List((1,2), (2,3))
scala> createConsecutiveNumPair2(l1)
res78: List[(Int, Int)] = List((2,3), (1,2))
QUESTION: which operator has lowest CPU, resource consumption? Would also appreciate if you can suggest a better scala way to rewrite the method above.

Answer 1

The problem with your first code is that it appends, which is O(n) on List. So the algorithm basically is O(n^2).
It very efficient to prepend on List, because it runs in constant time O(1), which you do in your second algorithm. You could use that and do a reverse at the end to make the result of the two methods equal, which would roughly make it it run in O(n).
However there is already a nice method in the library that does what you want. sliding is what you are looking for. The parameter for sliding defines the size of the tuples.
This would give you a List[List[Int]]:
List(1,2,3,4).sliding(2).toList //List(List(1,2), List(2,3), List(3,4))
If you insist on tuples, you can additionally use collect or map. Be aware that map will throw an exception when the list only has one element.
List(1,2,3,4).sliding(2).collect{
case List(a,b) => (a,b)
}.toList //List((1,2), (2,3), (3,4))

Answer 2

These methods often just call each other (though check the implementation to be sure). List is a singly-linked list, optimized for accessing the head rather than the tail, so adding elements to the front rather than the end is much more efficient. If you want to access / add elements at the end of the list, it's better to use Vector instead.
(As always, if you're asking the question at all you should have automated tooling to be able to tell you the answer. If you're not using a profiler that tells you which parts of your app are slow, it's not worth spending time on this kind of microoptimization - you're almost certainly optimizing the wrong part).