스칼라 함수 식 프로 그래 밍 테마--스칼라 집합 과 함수

전정 개요:
스칼라 함수 식 프로 그래 밍 주제―함수 식 사상 소개
scala 함수 식 프로 그래 밍 주제--scala 기초 문법 소개
앞에서 scala 의 상용 문법 과 대상 을 대상 으로 하 는 간단 한 지식 을 약간 소 개 했 는데 이번 에는 지난 장 을 보충 한 것 으로 주로 집합 과 함 수 를 소개 할 것 이다.
주의 하 세 요.함수 와 방법 은 다 릅 니 다.방법 은 클래스 에서 정의 되 고 함 수 는 단독으로 존재 할 수 있 습 니 다.(엄 밀 히 말 하면 scala 내부 에서 모든 함수 가 하나의 클래스 입 니 다)
1.scala 집합 소개
지난 장 에서 소개 한 object 의 apply 방법 을 기억 하 십 니까?많은 데이터 구 조 는 사실 그것 을 사 용 했 습 니 다.그래서 우 리 는 직접 List(...)로 List 를 새로 만 들 수 있 습 니 다.자신 이 수 동 으로 new 를 만 들 지 않 아 도 됩 니 다.
PS:scala 의 기본 데이터 구 조 는 변 하지 않 습 니 다.즉,하나의 List 는 새로운 요 소 를 삭제 하거나 추가 할 수 없습니다.물론'가 변 적'인 데이터 구조 도 있 고 나중에 소개 된다.
1.1 List
apply 방법 덕분에 우 리 는 new 를 통 해 데이터 구 조 를 새로 만 들 지 않 을 수 있 습 니 다.

//    ，    List，  List     
scala> val numbers = List(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
numbers: List[Int] = List(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

1.2 원조 Tuple
Tuple 이라는 개념 은 python 에서 광범 위 하 게 응용 되 고 있 으 며,다양한 데이터 형식(Int,String,Double 등)을 한데 묶 을 수 있다.

scala> val tup = (1,1,2.1,"tuple",'c') //             ，     
tup: (Int, Int, Double, String, Char) = (1,1,2.1,tuple,c)

그러나 scala 에서 Tuple 은 길이 제한 이 있 는데 그것 은 하나의 Tuple 이 최대 22 개의 요소 만 있 을 수 있다 는 것 이다.

scala> val tup = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)
tup: (Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)

//  Tuple  22   ，   
scala> val tup = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)
<console>:1: error: too many elements for tuple: 23, allowed: 22
val tup = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)

위 를 볼 수 있 지만 하나의 Tuple 이 22 개의 요 소 를 초과 하면 잘못 보고 합 니 다.왜 22 라 는 신기 한 숫자 인지 에 대해 서 는 통 일 된 논조 가 없 는 것 같다.'The Number 23'이라는 영화 가 있어 서 요.
1.3 맵 과 Option
맵 을 말 하기 전에 먼저 Option 을 소개 해 야 합 니 다.맵 에 저 장 된 것 이 Option 이기 때문에 이 뒤에 소개 합 니 다.
Option 은 옵션 으로 번역 되 었 습 니 다.본질 적 으로 그것 도 옵션 입 니 다.존재 하 는 지 여 부 를 알려 줍 니 다.실례 를 들 어 설명 합 시다.

//Option           
scala> val optionInt = Option(1)
optionInt: Option[Int] = Some(1)

scala> optionInt.get
res8: Int = 1
//   Option     
scala> val optionNone = Option(null)
optionNone: Option[Null] = None
// Option       ， get     ，    
scala> optionNone.get
java.util.NoSuchElementException: None.get
 at scala.None$.get(Option.scala:347)
 at scala.None$.get(Option.scala:345)
 ... 32 elided
//             
scala> optionNone.isEmpty
res11: Boolean = true
//    getOrElse()  ， Option        ，       ，      ，   getOrElse()      
scala> optionNone.getOrElse("this is null") //     
res12: String = this is null
scala> optionInt.getOrElse("this is null") //     
res15: Any = 1

게다가 Map 에 있 는 value 의 유형 은 당신 이 부여 한 데이터 형식 이 아니 라 Option 입 니 다.즉 맵(key->Option,key 1->Option)입 니 다.

scala> val map = Map("test1" -> 1,"test2" -> 2)
map: scala.collection.immutable.Map[String,Int] = Map(test1 -> 1, test2 -> 2)

scala> map.get("test1")
res16: Option[Int] = Some(1)

scala> map.get("test3")
res17: Option[Int] = None

scala> map.get("test3").getOrElse("this is null")
res18: Any = this is null

이런 좋 은 점 은 무엇 입 니까?자바 에 서 는 매번 자바 가 비어 있 는 상황 을 판단 해 야 하 는 고통 을 기억 하 십 니까?scala 에 서 는 이런 고민 들 이 모두 존재 하지 않 는 다.옵션 이 생기 면 엄 마 는 더 이상 NullPointer Exception 을 걱정 하지 않 아 도 된다.
1.4 상용 함수 조합 자
익명 함수
집합 한 함 수 를 조합 하면 익명 함 수 를 먼저 사용 해 야 합 니 다.python 의 lambda 표현 식 을 사용 한 적 이 있다 면 이런 방식 을 잘 알 것 입 니 다.
앞에서 말 했 듯 이 scala 에서 함 수 는 대상 이 고 익명 함수 도 함수 입 니 다.간단 한 예 를 들다.

//        
scala> val addOne = (x: Int) => x + 1
addOne: (Int) => Int = <function1>

scala> addOne(1)
res4: Int = 2

함수 안에 return 을 사용 하지 않 아 도 됩 니 다.맨 뒤의 x+1 은 익명 함수 의 반환 값 입 니 다.
map，reduce
hadop 의 등장 으로 MapReduce 가 엉망 이 되 었 다.Hadoop 의 Mapreduce 는 함수 식 map 와 reduce 에서 기원 되 었 지만 둘 은 다르다.관심 있 는 것 은 제 가 전에 쓴 한 편 을 볼 수 있 습 니 다.
함수 식 안의 맵 은,대충 말 하면,사실은 상당히 반환 값 이 있 는 for 순환 입 니 다.

scala> val list = List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list.map(_ + 1) //   (_+1)           // List      +1，   
res29: List[Int] = List(2, 3, 4)

reduce 에 대해 서도 for 순환 과 같 습 니 다.다만 map 가 순환 할 때마다 현재 요소 가 아 닙 니 다.reduce 는 현재 요 소 를 제외 하고 지난번 순환 의 결과 가 있 습 니 다.예 를 들 어 보 세 요.

scala> list.reduce((i,j) => i + j) //        ，        
res28: Int = 6

예 를 들 어 위의 예 는 1,2,3 개의 수가 있다.첫 번 째 순환 의 두 개 는 1,2,1+2 는 3 이 고 두 번 째 순환 은 지난번 결과 3 과 원래 의 3,3+3 은 6 이 며 결 과 는 6 이다.
filter
filter 의 옛 이름 은 필터 라 는 뜻 입 니 다.filter 에 익명 함수 가 들 어가 불 값 을 되 돌려 줄 수 있 습 니 다.true 로 돌아 가면 보류 하고 false 로 돌아 가 버 립 니 다.

scala> val numbers = List(1, 2, 3, 4)
numbers: List[Int] = List(1, 2, 3, 4)

//    2  0 
scala> numbers.filter((i: Int) => i % 2 == 0)
res0: List[Int] = List(2, 4)

foldLeft
이것 은 reduce 와 유사 하고 옮 겨 다 니 며 현재 요 소 를 제외 하고 지난 번 에 교체 한 결과 도 있 습 니 다.차이 점 은 foldLeft 에 초기 값 이 있 습 니 다.

scala> val numbers = List(1, 2, 3, 4)
numbers: List[Int] = List(1, 2, 3, 4)

//(m: Int, n: Int) => m + n          
scala> numbers.foldLeft(0)((m: Int, n: Int) => m + n)
res30: Int = 10

2.scala 함수
맨 앞에서 함수 가 대상 이 라 고 소개 되 었 습 니 다.그런데 왜 함수 가 바로 실 행 됩 니까?이것 은 사실 object 의 apply 라 는 문법 사탕 덕분이다.
편 함수
편 함수(PartialFunction)는 어떤 의미 에서 볼 때 편 함수 도 scala 에서 매우 중요 한 문법 사탕 이다.
편 함수
PartialFunction[A,B]//A 형식의 인 자 를 받 고 B 형식의 인 자 를 되 돌려 줍 니 다.
특히 scala 에는 편 함 수 를 사용 하 는 키워드 케이스 가 있다.계속 예 를 들 면:

//   case       PartialFunction[Int, String]
scala> val one: PartialFunction[Int, String] = { case 1 => "one" }
one: PartialFunction[Int,String] = <function1>

scala> one(1)
res11: String = Int

scala> one("one")
<console>:13: error: type mismatch;
 found : String("one")
 required: Int
 one("one")

case 키 워드 는 조건 에 맞 는 유형 이나 값 과 일치 합 니 다.맞지 않 으 면 잘못 보 고 됩 니 다.내부 실현 은 소개 하지 않 겠 습 니 다.문법 사탕 을 자주 사용 하 는 것 을 알 면 됩 니 다.
그리고 이 케이스 키 워드 는 바로 scala 모델 의 매 칭 을 실현 하 는 데 없어 서 는 안 될 부분 입 니 다.관심 있 는 동 화 는 저 를 볼 수 있 습 니 다scala 모드 일치 상세 분석
여기 서 흔히 볼 수 있 는 응용 프로그램 을 하나 더 말씀 드 리 겠 습 니 다.함수 조합 자 에 collect 가 있 는데 필요 한 매개 변 수 는 바로 편 함수 입 니 다.다음은 재 미 있 는 예 를 보 겠 습 니 다.

//  list   Any  
scala> val list:List[Any] = List(1, 3, 5, "seven")
list: List[Any] = List(1, 3, 5, seven)

//  map   ，  map         
scala> list.map { case i: Int => i + 1 }
scala.MatchError: seven (of class java.lang.String)
 at $anonfun$1.apply(<console>:13)
 at $anonfun$1.apply(<console>:13)
 at scala.collection.immutable.List.map(List.scala:277)
 ... 32 elided

 //    collect     ，  collect         ，              ，                 
scala> list.collect { case i: Int => i + 1 }
res15: List[Int] = List(2, 4, 6)

collect 가 받 은 매개 변 수 는 편 함수 이기 때문에 편 함수 의 특성 을 자동 으로 사용 하고 일치 하지 않 는 데이터 형식 을 자동 으로 걸 러 냅 니 다.map 는 할 수 없습니다.
부분 응용 함수
일부 응용 이란 한 함 수 를 호출 할 때 일부 매개 변수 만 전달 할 수 있다 는 뜻 이다.이렇게 하면 새로운 함수 가 생 성 됩 니 다.실례 를 들 어 보 겠 습 니 다.

//               
scala> def partial(i:Int,j:Int) : Unit = {
 | println(i)
 | println(j)
 | }
partial: (i: Int,j: Int)Unit

//           ，        ，        
scala> val partialFun = partial(5,_:Int)
partialFun: Int => Unit = <function1>

//            
scala> partialFun(10)
5
10

일부 응용 함 수 는 주로 코드 재 활용 과 일정한 코드 가 독성 을 증가 시 키 는 역할 을 합 니 다.
물론 더 재 미 있 는 용법 이 있 으 니 나중에 얘 기 할 기회 가 있 으 면 다시 이야기 하 자.
함수 코 리 화
처음에는 코 리 화 를 들 었 을 때 이상 했다.코 리?뭐야?
나중에 야 알 게 되 었 습 니 다.사실은 코 리 는 curry 음역 에서 왔 습 니 다.이것 은 인명 이 고 바로 코 리 화 된 발명자 입 니 다.
코 리 화 는 여러 개의 매개 변 수 를 받 아들 이 는 함 수 를 하나의 단일 매개 변수(최초 함수 의 첫 번 째 매개 변수)를 받 아들 이 는 함수 로 바 꾸 고 남 은 매개 변 수 를 받 아들 이 고 결 과 를 되 돌려 주 는 새로운 함수 기술 이다.
구체 적 으로 어떻게 사용 하 는 지 봅 시다.

//            ，        
scala> def curring(i:Int)(j: Int): Boolean = {false}
curring: (i: Int)(j: Int)Boolean

//              ，       
scala> val curringVal:(Int => (Int => Boolean)) = curring _
curringVal: Int => (Int => Boolean) = <function1>

//             ，         
scala> val curringVal_1 = curringVal(5)
curringVal_1: Int => Boolean = <function1>

//            ，        
scala> curringVal_1(10)
res32: Boolean = false

코 리 화 는 사실 하나의 함 수 를 호출 체인 으로 바 꾸 는 과정 으로 위의 일부 응용 함수 와 비슷 해 보인다.
이 몇 부분 은 처음 보면 그것 이 도대체 무슨 소 용이 있 는 지 모 르 겠 지만,사실 이러한 기능 의 주요 용 도 는 함수 식 의존 주입 이다.이 부분 기술 을 통 해 의존 하 는 함 수 를 매개 변수 로 상층 함수 에 전달 할 수 있다.편폭 에 한 하여 여기 서 먼저 생략 하고,뒤에 다시 소개 하 겠 습 니 다.
결어:
이번에 소 개 된 것 은 scala 집합의 일부 내용 과 일부 함수 의 특성 이다.다시 한 번 말 하지만 함 수 는 사실 대상 이다.
나 는 새로운 것 을 배 울 때 문법 과 같은 고정된 규칙 을 가 진 것들 이 있다 는 관점 을 가지 고 있다.다 기억 할 필 요 는 없고 대략적인 원리 만 알 면 이미지 가 있 으 면 됩 니 다.
예 를 들 어 scala 의 함수 식 프로 그래 밍 이나 자바 의 OOP 는 먼저 문법 을 다 배 운 다음 에 관련 프로 그래 밍 이념 을 배 울 필요 가 없다.이것 은 내 가 보기 에는 약간 본말 이 뒤 바 뀐 것 같다.
나의 일반적인 방법 은 먼저 대략적인 문법 을 익 힌 후에 언어의 정 수 를 배 우 는 것 이다.모 를 때 구체 적 인 문법 을 거꾸로 조회 하고 목표 가 생 긴 후에 문법 은 오히려 그렇게 무미건조 하지 않 게 되 었 다.
이상 은 단지 나의 개인 적 인 견해 일 뿐 이 니,이 편 은 이것으로 끝났다.
스칼라 함수 식 프로 그래 밍 주제 인 스칼라 집합 과 함수 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 스칼라 함수 식 프로 그래 밍 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 바 랍 니 다!