람다 식 자바 조작부 ON / C ++은 실질적으로 항상 기록되고 스트림 흐름

패키지 com.acm;
수입 인 java.util.ArrayList;
수입 java.util.Arrays;
수입 Collections의;
수입 java.util.Comparator;
수입 java.util.HashMap에;
수입 은 java.util.List;
수입 java.util.Map;
수입 java.util.Map.Entry;
수입 java.util.PriorityQueue;
수입 java.util.Queue;
수입 java.util.stream.Collectors;
수입 java.util.stream.Stream;


/ **
 * 질문 : 람다 식 익명 함수 목적 ----> 자체는 클래스이며
 * 정의 : 람다 식 익명 함수
 * 사용 조건 : 먼저, 그 파라미터에 대응하는 기능 (함수 호출은 미정 동일한 수의 매개 변수를 일으키는 등의 경우뿐만 아니라) 추상 클래스와 추상 클래스 하나 개의 함수이다
 * 사용 방법 :( 파라미터) - 매개 변수의 개수 () 쓸 절약 할 때>, 익명 함수의 시간 체 구현
 * 주 : (1) 입력 변수를 기록하지 않는다 (2), 클래스의 방법 일 수있다 익명 함수 본문을 달성
 * 상기 방법은 형태로하는 정적 클래스 방법은 해당 메소드를 호출하는 경우 : 클래스 또는 메소드 이름의 이름을 전체적으로 참조 : 클래스 이름 :: 메소드 명;
 * 어떤 파라미터 복근 :: 수학 참조가 치환 될 수있는, Math.abs (N)를 매개 변수 쓸 수 없다;
 * list.forEach (System.out에 ::에 println) 및 ss.forEach (항목 ->에서 System.out.println (항목)); 등가 표현
 * /

 / **
 * 단지 C의 람다 식의 표현에서 보충 ++
() 주요 int로
{
    INT NUM = 500;
    // 자동 X = [NUM {COUT << NUM} // X 변수 함수 이름에 대응 [NUM] 외부 캡처
    // 자동 Y = [(INT의 X, INT의 Y) -> INT {COUT << X + Y} // 또는 []로 기록 INT (X, INT의 Y) -> INT {(100)를 반환}; 반환 유형을 추가
    자동 Z = [(INT의 X, Y의 INT) {COUT << X + Y << ENDL} // 화살표없이 ----------> 가장 추천 하나
    // ----- 캡처 외부 변수> [=] 값 포집로 표시 - [참조하면 캡처로 표시
     자동 K = [= () {복귀 NUM} // 하나만 () 파라미터 의미 ---------> 쓸 수 없다
     오토 H = [= {복귀 NUM + 45} // 하나만 () 파라미터 의미 ---------> 쓸 수 없다
     자기 D = - [(INT의 Y) {복귀 NUM};
     자동 S = [= (INT의 b) 가변 {COUT << ++ NUM + 1 << ENDL} // () 외부 변수를 캡쳐하여 표현 가변 값이 변경 될 수있다 -------> 파라미터 추가해야합니다
     // 그러므로 좋은 습관) (대한 참조 매개 변수에 기록되지 않습니다해야합니다
    COUT << H () << ENDL;
}
 * /

/ **
 배열 작업과 관련된 정적 메소드를 정의 도구 * 어레이 배열 --------->
 루트 인터페이스 ------------ * 컬렉션 집합 도구> 단일 세트
 루트 인터페이스 *지도 ------------------------> 설정을 두 번 연속
 수집 툴에 복잡한 연산을 이용 * 스트림 -------------> 인터페이스 함수
 *지도와 flatMap에서 java8 스트림의 차이
 * 차이는 flatMap지도를 flatMap :
 * 역할 맵은 다른 스트림을 하나 개의 스트림으로 맵핑된다 -----> 다른 스트림 맵은 자동 시스템을 참조하는 TEMP (임시) 스트림을 생성 한 후
 * FlatMap 역할을 하나 개의 스트림으로 두 스트림을 병합하는 것
 스트림의 각각의 값을 스트림으로 변환된다 * 다음 유동 스트림으로 평평
 * / 
클래스 streamTest
{
    문자열 STR = "장" ;
     개인 에서 <정수> 목록 = 새로운 새 ArrayList에 <정수> (5. )
     개인 문자열 [] STRs = { "java8", "인가", "간단한", "에", "사용"} ; // 문자열로 각 스트링에 해당지도 strs 효과 [] 엘리먼트 문자열 내부
     // 문자열 []로 문자 java8 선행 문자열로, [] 등의 문자열로 온 등 및 flatMap 역할 문자열 []에 이러한 문자열 []를 걸릴 것입니다
     // 사람들에 여전히 몇 가지 이전에 관련이없는 사람에 해당 단일 문자의 문자열 전에 문자열의 요소,가, 지도 모두들 결혼에 해당하고 혼자
     // 함께 가정을 넣어 flatMap 가정이되었다, 이러한 ---------------> ***** 
    공개  부울 EX2 ()
    {    
        // 문자열 [] = SRC str.split ( "");   // src.split ( ","); 원소 SRC 따라 --->이 수단 분할되는 동작이있는 경우 SRC, 전 기호가 두 스트링들로 분할 한 후 문자
         // : 대 (STRs 문자열 DD)
             // ]에서 System.out.println (DD)
         // Arrays.stream (STRs) .MAP (STR-> str.split ... ( "")) flatMap (STR-> Arrays.stream (STR)) 대해 forEach합니다 (System.out에 :: 인쇄) 
        목록 <문자열> LL = Arrays.stream (STRs) .MAP (STR-> str.split . ( "")) flatMap (STR-> Arrays.stream (STR).)를 수집 (Collectors.toList ());
        에서 System.out.println은 (는 ll.get ( 0 ));
         // 작업의 작용은 문자열에 문자열의 각 문자에 각각 strs 배열이다 
        에는 list.add (15 );
        에는 list.add ( 14 );
        에는 list.add ( 13 );
        목록 <문자열> SS = 새로운 새로운 ArrayList를 <문자열> ();
         // 목록 list.stream = () 한계 (2) .collect (Collectors.toList ());    // 첫 번째 두을, 다른 스킵 N 전에 이동 건너 제한은 제 N 취한다
         // .. 상기 수집 (Collectors.toList ()) SS = list.stream ()지도 (항목 -> Integer.toString를 (아이템)) // 맵 유동 요소는 다른 흐름에 매핑 될 수있다
         // 케이스 중에 문제 형 소자 등이 변경 될 수있다
         // 리스트 list.stream = (). 스킵. (1) .collect (Collectors.toList ()) ; // 의 제 N 요소 이동
         // ..;리스트 list.stream = () 필터 (항목 -> item.equals (15))에 수집 (Collectors.toList ()) // 필터를 설정할 때마다 값리스트 15과 동일한
         //그리고 그 부담 (Collectors.toList ())로 설정하는 집광 소자로 흘러
         // Collections.fill (목록, 100);   // 100 할당 다시 설정 모든 요소가 아닌 경우, 요소의 집합으로 모든 프로세스는 아니다
         // ;에서 System.out.println (Collections.binarySearch (목록 ,. 1))    // 이 반환 찾을 수없는 두 가지로 나누어 세트로 지정된 요소를 찾기 위해 인덱스를 찾을 -1
         // 컬렉션. 정렬 (목록 (ITEM1, ITEM2) -> - ITEM2 ITEM1는)    // 람다 식으로 비교 함수 재구성
         // 상기은, Collections.sort (목록)           // 컬렉션의 요소 정렬
         // Collections.reverse을 (목록);      // 세트 플립의 요소
         // list.forEach합니다 (System.out에 :: println 메소드);
         // ss.forEach (항목 ->에서 System.out.println (항목));
        // distinc.forEach (항목 ->에서 System.out.println (항목)); 
        반환  사실 ;
    }
}

클래스 솔루션
{
    개인 목록 <정수> 목록 = 새로운 ArrayList를 <정수> ();
    개인 지도 <정수, 문자>지도 = 새로운 HashMap의 <정수, 문자> ();
    전용 [] 도착 정수 = {1,2,3,4,5,6,7 };
    
    공공  부울 EX1 ()
    {
        map.put ( 1 'A' );
        map.put ( 2 ', B' );
        map.put ( 3 ', C' );
        map.put ( 4 ', D' );
        문자열 STR = "SD" ;
        str.startsWith는 ( "X");      // 시작 'X'str 문자열로 문자열을 찾을 수 
        str.toUpperCase을 ();        // 문자열 정적 메소드    // 두 필터는 람다 표현 될 수있다 파라미터 
        리스트 = Arrays.asList (ARR);
        트림 <정수> = 스트림 list.stream ();
        stream.forEach (항목 ->에서 System.out.println (아이템 + 3).);            // 이송 중합 방법 스트림 스트림 
        map.forEach ((a, b) - >에서 System.out.println (a + ""+ B ));             // 탐색 방법 람다 식 
        일람 <의 Map.Entry <정수가 SS = >> 캐릭터의 새로운 새로운 ArrayList를 <의 Map.Entry <정수의 문자 >> (EnumMap.entrySet ()); <의 Map.Entry <정수 캐릭터 >> 큐 = 새로운 PriorityQueue 인 <의 Map.Entry <정수 캐릭터 >> ((a, b) -> b.getValue () - a.getValue ()); // 람다表达式的写法 
        큐 <의 Map.Entry <정수 캐릭터 >> = QQ 새로운 PriorityQueue 인 <의 Map.Entry <정수 캐릭터 >> ( 새로운 비교기 <의 Map.Entry <정수 캐릭터 >> () {

            @보수
            공개  INT는 비교 (등록 <정수 캐릭터> arg0에서, 입구 <정수 캐릭터> ARG1) {
                 // TODO 자동 생성 방법 스텁 
                 arg1.getValue () - arg0.getValue ();
            }            
        });                     // 기록 일반 비교 함수 
        queue.add (ss.get (0));    //
         ss.forEach (A->에서 System.out.println (a.getKey () + ""+ A. getValue ()));    // 이송의 일반적인 방법 
        반환  true로를 ;
    }
        
}


공공  클래스 홈페이지 {

    공공  정적  무효 메인 (문자열 []에 args) {
        // 솔루션 공간 = 새로운 솔루션 ();
       // space.ex1 (); 
        streamTest의 SS = 새로운 streamTest ();
        ss.ex2 ();
    }
}

 

추천

출처www.cnblogs.com/z2529827226/p/11780239.html