Java8和Scala的面向對象和函數式編程有什么不同

這篇文章主要講解了“Java8和Scala的面向對象和函數式編程有什么不同”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java8和Scala的面向對象和函數式編程有什么不同”吧！

面向對象和函數式編程的混合：Java 8和Scala的比較

Scala是一種混合了面向對象和函數式編程的語言。它常常被看作Java的一種替代語言，程序員們希望在運行于JVM上的靜態類型語言中使用函數式特性，同時又期望保持Java體驗的一致性。和Java比較起來，Scala提供了更多的特性，包括更復雜的類型系統、類型推斷、模式匹配、定義域語言的結構等。除此之外，你可以在Scala代碼中直接使用任何一個Java類庫。

Scala簡介

HelloWorld

命令式Scala

object Beer {
	def main(args: Array[String]){
		var n : Int = 2
		while( n <= 6 ){
			println(s"Hello ${n} bottles of beer")
			n += 1
		}
	}
}

輸出

Hello 2 bottles of beer
Hello 3 bottles of beer
Hello 4 bottles of beer
Hello 5 bottles of beer
Hello 6 bottles of beer

函數式Scala

Java 8以更加函數式的方式實現

public class Foo {
	public static void main(String[] args) {
		IntStream.rangeClosed(2, 6)
		.forEach(n -> System.out.println("Hello " + n +
		" bottles of beer"));
	}
}

Scala來實現

object Beer {
	def main(args: Array[String]){
		2 to 6 foreach { n => println(s"Hello ${n} bottles of beer") }
	}
}

基礎數據結構：List、Set、Map、Tuple、Stream以及Option

創建集合

在Scala中創建集合是非常簡單的

val authorsToAge = Map("Raoul" -> 23, "Mario" -> 40, "Alan" -> 53)

Java中那樣手工添加每一個元素：

Map<String, Integer> authorsToAge = new HashMap<>();
authorsToAge.put("Raoul", 23);
authorsToAge.put("Mario", 40);
authorsToAge.put("Alan", 53);

Scala輕松地創建List（一種單向鏈表）或者Set（不帶冗余數據的集合）

val authors = List("Raoul", "Mario", "Alan")
val numbers = Set(1, 1, 2, 3, 5, 8)

Scala中，關鍵字val表明變量是只讀的，并由此不能被賦值（就像Java中聲明為final的變量一樣）。而關鍵字var表明變量是可以讀寫的。

不可變與可變的比較

Scala的集合有一個重要的特質我們應該牢記在心，那就是我們之前創建的集合在默認情況下是只讀的。這意味著它們從創建開始就不能修改。

更新一個Scala集合會生成一個新的集合

val numbers = Set(2, 5, 3);
val newNumbers = numbers + 8 //這里的操作符+會將8添加到Set中，創建并返回一個新的Set對象
println(newNumbers)
println(numbers)

Java中提供了多種方法創建不可修改的（unmodifiable）集合。下面的代碼中，變量newNumbers是集合Set對象numbers的一個只讀視圖：

Set<Integer> numbers = new HashSet<>();
Set<Integer> newNumbers = Collections.unmodifiableSet(numbers);

這意味著你無法通過操作變量newNumbers向其中加入新的元素。不過，不可修改集合僅僅是對可變集合進行了一層封裝。通過直接訪問numbers變量，你還是能向其中加入元素。

與此相反，不可變（immutable）集合確保了該集合在任何時候都不會發生變化，無論有多少個變量同時指向它。

使用集合

val fileLines = Source.fromFile("data.txt").getLines.toList()
val linesLongUpper = fileLines.filter(l => l.length() > 10)
	.map(l => l.toUpperCase())

元組

Java目前還不支持元組

Scala提供了名為元組字面量

val raoul = ("Raoul", "+ 44 887007007")
val alan = ("Alan", "+44 883133700")

Scala支持任意大小的元組

val book = (2014, "Java 8 in Action", "Manning")
val numbers = (42, 1337, 0, 3, 14)

你可以依據它們的位置，通過存取器（accessor） _1、_2（從1開始的一個序列）訪問元組中的元素，比如：

println(book._1)
println(numbers._4)

Stream

Scala也提供了對應的數據結構，它采用延遲方式計算數據結構，名稱也叫Stream！不過Scala中的Stream提供了更加豐富的功能，讓Java中的Stream有些黯然失色。Scala中的Stream可以記錄它曾經計算出的值，所以之前的元素可以隨時進行訪問。

除此之外，Stream還進行了索引，所以Stream中的元素可以像List那樣通過索引訪問。注意，這種抉擇也附帶著開銷，由于需要存儲這些額外的屬性，和Java 8中的Stream比起來，Scala版本的Stream內存的使用效率變低了，因為Scala中的Stream需要能夠回溯之前的元素，這意味著之前訪問過的元素都需要在內存“記錄下來”（即進行緩存）。

Option

Java8的Optional

public String getCarInsuranceName(Optional<Person> person, int minAge) {
	return person.filter(p -> p.getAge() >= minAge)
				.flatMap(Person::getCar)
				.flatMap(Car::getInsurance)
				.map(Insurance::getName)
				.orElse("Unknown");
}

在Scala語言中，你可以使用Option使用Optional類似的方法實現該函數：

def getCarInsuranceName(person: Option[Person], minAge: Int) = person.filter(_.getAge() >= minAge)
			.flatMap(_.getCar)
			.flatMap(_.getInsurance)
			.map(_.getName).getOrElse("Unknown")

函數

Scala中的一等函數

def isJavaMentioned(tweet: String) : Boolean = tweet.contains("Java")
def isShortTweet(tweet: String) : Boolean = tweet.length() < 20

Scala語言中，你可以直接傳遞這兩個方法給內嵌的filter，如下所示

val tweets = List(
	"I love the new features in Java 8",
	"How's it going?",
	"An SQL query walks into a bar, sees two tables and says 'Can I join you?'"
)
tweets.filter(isJavaMentioned).foreach(println)
tweets.filter(isShortTweet).foreach(println)

現在，讓我們一起審視下內嵌方法filter的函數簽名：

def filter[T](p: (T) => Boolean): List[T]

匿名函數和閉包

匿名函數

val isLongTweet : String => Boolean
	= (tweet : String) => tweet.length() > 60

val isLongTweet : String => Boolean
	= new Function1[String, Boolean] {
	def apply(tweet: String): Boolean = tweet.length() > 60
}

isLongTweet.apply("A very short tweet")

如果用Java，你可以采用下面的方式：

Function<String, Boolean> isLongTweet = (String s) -> s.length() > 60;
boolean long = isLongTweet.apply("A very short tweet");

isLongTweet("A very short tweet")

閉包

閉包是一個函數實例，它可以不受限制地訪問該函數的非本地變量。不過Java 8中的Lambda表達式自身帶有一定的限制：它們不能修改定義Lambda表達式的函數中的本地變量值。這些變量必須隱式地聲明為final。

Scala中的匿名函數可以取得自身的變量，但并非變量當前指向的變量值。

def main(args: Array[String]) {
	var count = 0
	val inc = () => count+=1
	inc()
	println(count)
	inc()
	println(count)
}

不過在Java中，下面的這段代碼會遭遇編譯錯誤，因為count隱式地被強制定義為final：

public static void main(String[] args) {
	int count = 0;
	Runnable inc = () -> count+=1;//錯誤：count必須為final或者在效果上為final
	inc.run();
	System.out.println(count);
	inc.run();
}

科里化

Java的示例

static int multiply(int x, int y) {
	return x * y;
}
int r = multiply(2, 10);

static Function<Integer, Integer> multiplyCurry(int x) {
	return (Integer y) -> x * y;
}

Stream.of(1, 3, 5, 7)
	.map(multiplyCurry(2))
	.forEach(System.out::println);

Scala提供了一種特殊的語法可以自動完成這部分工作。

def multiply(x : Int, y: Int) = x * y
val r = multiply(2, 10);

該函數的科里化版本如下：

def multiplyCurry(x :Int)(y : Int) = x * y
val r = multiplyCurry(2)(10)

val multiplyByTwo : Int => Int = multiplyCurry(2)
val r = multiplyByTwo(10)

類和trait

更加簡潔的Scala類

由于Scala也是一門完全的面向對象語言，你可以創建類，并將其實例化生成對象。

class Hello {
	def sayThankYou(){
		println("Thanks for reading our book")
	}
}
val h = new Hello()
h.sayThankYou()

getter方法和setter方法

單純只定義字段列表的Java類，你還需要聲明一長串的getter方法、setter方法，以及恰當的構造器。多麻煩啊！

public class Student {
	private String name;
	private int id;

	public Student(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
}

Scala語言中構造器、getter方法以及setter方法都能隱式地生成，從而大大降低你代碼中的冗余：

class Student(var name: String, var id: Int)
val s = new Student("Raoul", 1)
println(s.name)
s.id = 1337
println(s.id)

Scala的trait與Java8的接口對比

Scala還提供了另一個非常有助于抽象對象的特性，名稱叫trait。它是Scala為實現Java中的接口而設計的替代品。trait中既可以定義抽象方法，也可以定義帶有默認實現的方法。trait同時還支持Java中接口那樣的多繼承，所以你可以將它們看成與Java 8中接口類似的特性，它們都支持默認方法。trait中還可以包含像抽象類這樣的字段，而Java 8的接口不支持這樣的特性。

trait Sized{
	var size : Int = 0
	def isEmpty() = size == 0
}

class Empty extends Sized//一個繼承自trait Sized的類
println(new Empty().isEmpty())//打印輸出true

你可以創建一個Box類，動態地決定到底選擇哪一個實例支持由trait Sized定義的操作

class Box
val b1 = new Box() with Sized //在對象實例化時構建trait
println(b1.isEmpty()) //打印輸出true
val b2 = new Box()
b2.isEmpty() //編譯錯誤：因為Box類的聲明并未繼承Sized

感謝各位的閱讀，以上就是“Java8和Scala的面向對象和函數式編程有什么不同”的內容了，經過本文的學習后，相信大家對Java8和Scala的面向對象和函數式編程有什么不同這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！