lambda -- Java8

29096 ワード
Java 
1.       
	Java 8                   ，      default     ，           
	//Formula                
	public interface Formula {
		//  
		double calculate(int a);
		
		//  
		default double sqrt(int a){
			return Math.sqrt(a);
		}
	}

	main:
	Formula f = new Formula() {
		@Override
		public double calculate(int a) {
			return a+1;
		}
	};
	System.out.println(f.calculate(4));
	System.out.println(f.sqrt(8));

	  :             ，
	        .             


2.Lambda    
	2.1   Lambda   
	  :
	public class LambdaTest1 {
	
		public static void main(String[] args) {
			
			//    list         
			List list = Arrays.asList
			("hello","tom","apple","bbc");
			//            
			Collections.sort(list, new Comparator(){
				@Override
				public int compare(String o1, String o2) {
					return -o1.compareTo(o2);
				}
			});
			
			//  Lambda   
			Collections.sort(list,(String s1,String s2)->{
				return s1.compareTo(s2);
			});
			
			//     
			//1.          
			//2.              
			Collections.sort(list,(s1,s2)->s1.compareTo(s2));
			
			System.out.println(list);
			
		}
		
	}

	2.2 Functional  
	“     ”                ，       lambda               。              ，                    。
	     lambda                     ，              ，            @FunctionalInterface   ，                                  。
	  :
	public class LambdaTest2 {
	
		public static void main(String[] args) {
			
			LambdaTest2 t = new LambdaTest2();
	//		        
	//		Action1 a1 = ()->System.out.println("hello");
			
			t.test1(()->System.out.println("hello"));
			
			//Action2 a2 = (f)->"     :"+f;
			//       ,               
			Action2 a2 = f->"     :"+f;
			t.test2(a2);
		}
		public void test1(Action1 a){
			a.run();
		}
		public void test2(Action2 a){
			System.out.println(a.run(3));
		}
		
	}
	//         ,            
	@FunctionalInterface
	interface Action1{
		public void run();
	}
	
	//         ,            
	@FunctionalInterface
	interface Action2{
		public T run(F f);
	}
	

	  :lambda              

	2.3          
	Java 8       ::         (          )
	  :
	public class LambdaTest3 {
		public static void main(String[] args) {
			
			LambdaTest3 t = new LambdaTest3();
			//  Lambda        
			//   Integer       toBinaryString    :
			//Action3                       
			// Integer       toBinaryString     、        
			Action3 a3 = Integer::toBinaryString;
			System.out.println(a3.run(4));
			
			//  Lambda          
			//     t       test              
			Action3 aa3 = t::test;
			System.out.println(aa3.run(4));
		}
		
		public String test(int i){
			return "i="+i;
		}
	}

	@FunctionalInterface
	interface Action3{
		public String run(int Integer);
	}


	                  :         ::              
	public class LambdaTest6 {
	
		public static void main(String[] args) {
			
			Model m = new Model();
			
			//       ，       ,           
			Action a1 = (s)->System.out.println("hello");
			a1.run(m);
			
			//  :          Model        Model    
			//    Model             :       
			//  run       Model    m        
			Action a2 = Model::test3;
			a2.run(m);
			
			//    m  test2  
			//  test2           Action         
			Action a3 = m::test2;
			a3.run(m);
		}
		
	}

	interface Action{
		public void run(T t);
	}

	class Model{
		
		public void test1(){
			System.out.println("test1");
		}
		public void test2(Model a){
			System.out.println("test2");
		}
		public int test3(){
			System.out.println("test3");
			return 1;
		}
	}
	

	Java 8       ::           
	public class LambdaTest4 {
		
		public static void main(String[] args) {
			
			//Lambda         
			//                     
			Action4Creater creater = Action4::new;
			Action4 a4 = creater.create("zhangsan");
			a4.say();
			
			
		}
		
	}

	class Action4{
		private String name;
		public Action4() {
			
		}
		public Action4(String name) {
			this.name = name;
		}
		public void say(){
			System.out.println("name = "+name);
		}
	}

	interface Action4Creater{
		public Action4 create(String name);
	}

	2.4 lambda         
	public class LambdaTest5 {
		private static int j;
		private int k;
		public static void main(String[] args) {
			LambdaTest5 t = new LambdaTest5();
			t.test();
		}
		
		public void test(){
			int num = 10;
			j = 20;
			k = 30;
			
			//lambda                     
			Action5 a5 = (i)->System.out.println("   :i="+(i+num+j+k));
			a5.run(1);
			
			//              final                 
			//num = 60;
			j = 50;
			k = 70;
		}
		
	}

	interface Action5{
		public void run(int i);
	}
	
	
	2.5 Predicate   lambda   
	java.util.function.Predicate       java            ,       lamb             API           。 
	public class LambdaTest6 {
		public static void main(String[] args) {
			List languages = Arrays.asList("Java", "html5","JavaScript", "C++", "hibernate", "PHP");
			
			//   J   
			filter(languages,(name)->name.startsWith("J"));
			//5   
			filter(languages,(name)->name.endsWith("5"));
			//     
			filter(languages,(name)->true);
			//      
			filter(languages,(name)->false);
			//        4
			filter(languages,(name)->name.length()>4);
			System.out.println("-----------------------");
			//   J        4 
			Predicate c1 = (name)->name.startsWith("J");
			Predicate c2 = (name)->name.length()>4;
			filter(languages,c1.and(c2));
			
			//     J  
			Predicate c3 = (name)->name.startsWith("J");
			filter(languages,c3.negate());
			
			//   J        4 
			Predicate c4 = (name)->name.startsWith("J");
			Predicate c5 = (name)->name.length()<4;
			filter(languages,c4.or(c5));
			
			//   Java 
			filter(languages,Predicate.isEqual("Java"));
			
			//           
			boolean test = Predicate.isEqual("hello").test("world");
			System.out.println(test);
		}
		public static void filter(List languages, Predicate condition) {  
			for(String name: languages) {  
				if(condition.test(name)) {  
					System.out.println(name + " ");  
				}  
			}  
		}  
		
	}
	
	2.6 Function   
		 Function             ，                    
		 compose             
		 andThen             
		   ：compose andThen                 ，         
		 default  Function andThen(Function super R,? extends V> after)              apply     after    apply       。

		default  Function compose(Function super V,? extends T> before)       before    apply           apply       。

		static  Function identity()        apply()                 。
	public interface Function {

		R apply(T t);

		default  Function compose(Function super V, ? extends T> before) {
			Objects.requireNonNull(before);
			return (V v) -> apply(before.apply(v));
		}

		default  Function andThen(Function super R, ? extends V> after) {
			Objects.requireNonNull(after);
			return (T t) -> after.apply(apply(t));
		}
		
		//  : t->t (t)->t   
		//t->t     identity     ,   Function    
		//        :Function f = t->t;
		//  f.apply("test")      "test"
		//         
		static  Function identity() {
			return t -> t;
		}
	}

	  :
	public class LambdaTest7 {
		//     
		private static class Student{
			private String name;
			public Student(String name){
				this.name = name;
			}
			public String getName() {
				return name;
			}
			
		}
		public static void main(String[] args) {
			/*          tom*/
			String name = "tom";
			
			/*                */
			Function f1 =(s)->new Student(s);
			//              ，        
			//Function f1 =Student::new;
			Student stu1 = f1.apply(name);
			System.out.println(stu1.getName());
			
			/*    ,  name  Student       name     */
			Function before = (s)->"briup_"+s;
			//  f1       before     , before           f1       
			Student stu2 = f1.compose(before).apply(name);
			System.out.println(stu2.getName());
			
			/*               */
			Function after = (stu)->stu.getName().length();
			//before     ,        f1     ,         after,           
			int len = f1.compose(before).andThen(after).apply(name);
			System.out.println(len);
			
		}
		
	}        



	2.7 Supplier  
	Supplier            ， Function               
	public interface Supplier {
		T get();
	}
	  :
	public class LambdaTest8 {
		public static void main(String[] args) {
			//            
			Supplier f = ()->{
				String base = "abcdefghijklmnopqrstuvwxyz0123456789";     
				Random random = new Random();     
				StringBuffer sb = new StringBuffer();     
				for (int i = 0; i < 8; i++) {  
					//  [0,base.length)      
					int number = random.nextInt(base.length());     
					sb.append(base.charAt(number));     
				}     
				return sb.toString();   
			};
			System.out.println(f.get());
		}
		
	}


	2.8 Consumer  
	Consumer            ， Function              
	public interface Consumer {

		void accept(T t);

		default Consumer andThen(Consumer super T> after) {
			Objects.requireNonNull(after);
			return (T t) -> { accept(t); after.accept(t); };
		}
	}
	  :
	public class LambdaTest9 {
		//     
		private static class Student{
			private String name;

			public String getName() {
				return name;
			}

			public void setName(String name) {
				this.name = name;
			}
		}
		
		public static void main(String[] args) {
			Student s = new Student();
			s.setName("tom");
			
			Consumer c = 
			stu->System.out.println("hello!"+stu.getName());
			c.accept(s);
			
		}
		
	}

	  :
		Function       R apply(T t);              
		Supplier            T get();		         
		Consumer         void accept(T t);        

		         :                  
		BinaryOperator      T apply(T t, T t)     T    ，    T    
		BiFunction    R apply(T t, U u)     T   U  ，    R    
		BinaryOperator     BiFunction  
		public interface BinaryOperator extends BiFunction

		BiConsumer    void accept(T t, U u)        ，     

		

	2.9 Optional 
	Optional          ，       NullPointerException       
	Optional            ，     null    null。
	 Java8                          null，  Java 8 ，      null    Optional。
	       null     。
	      isPresent()     true，  get()        。
	public class Optotion {
	
	public static void main(String[] args) {
		
		/*of     null      Optional*/
		//of          Optional 。
		//      ，             null。
		//       null，   NullPointerException 。
		Optional op1 = Optional.of("hello");
		
		/*ofNullable            Optional，       null，       Optional。*/
		//ofNullable of    ，             null   
		Optional op2 = Optional.ofNullable(null);
		
		/*isPresent          true，    false。*/
		/*get     Optional       ，    NoSuchElementException。*/
		if(op1.isPresent()){
			System.out.println(op1.get());
		}
		if(op2.isPresent()){
			System.out.println(op2.get());
		}
		
		/*ifPresent     Optional         consumer，      */
		//consumer               
		op1.ifPresent(str->System.out.println(str));
		op2.ifPresent(str->System.out.println(str));//        op2     null
		
		
		/*orElse            ，          。*/
		System.out.println(op1.orElse("  op1    null      ,       "));
		System.out.println(op2.orElse("  op2    null      ,       "));
		
		
		/*orElseGet   orElseGet orElse    ，          。orElse              ，orElseGet      Supplier            。*/
		//Supplier                
		System.out.println(op1.orElseGet(()->"        "));
		System.out.println(op2.orElseGet(()->"        "));
		
		
		/*orElseThrow            ，    supplier       。*/
		// orElseThrow         lambda      ，           。
		//orElseThrow                Throwable    
		//public  T orElseThrow(Supplier extends X> exceptionSupplier) throws X
		try {
			System.out.println(op1.orElseThrow(Exception::new));;
			//System.out.println(op2.orElseThrow(Exception::new));;       
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
		/*map       ，       mapper       。*/
		//       Optional    ,             
		//public Optional map(Function super T, ? extends U> mapper)
		Optional map1 = op1.map(str->1);
		System.out.println(map1.get());
		Optional map2 = op2.map(str->1.2);
		System.out.println(map2.orElse(0.0));
		
		
		/*flatMap       ，    mapper    Optional     ，     Optional。*/
		//flatMap map    ，    flatMap  mapper      Optional。     ，flatMap      Optional  。
		//             Optional
		//public Optional flatMap(Function super T, Optional> mapper) 
		System.out.println(op1.flatMap(str->Optional.of(str+"_briup")).get());
		//op1.flatMap(str->"");    
		
		
		/*filter                      Optional，     Optional。*/
		//public Optional filter(Predicate super T> predicate) 
		op1 = op1.filter(str->str.length()<10);
		System.out.println(op1.orElse("  null"));
		op1 = op1.filter(str->str.length()>10);
		System.out.println(op1.orElse("  null"));
	}

	2.10 Stream   
	java.util.Stream                     。
	Stream                 ，                ，
	       Stream  ，                (    )。
	Stream             ，   java.util.Collection   ，List  Set， Map   。
	Stream               。
	Stream    Java 8      ，   java.io     InputStream   OutputStream         。
	Java 8    Stream     （Collection）       ，                 、
	       （aggregate operation），          (bulk data operation)。
	Stream API          Lambda   ，               。
	                    

	2.10.1 Stream     :
	// 1.     
	Stream stream = Stream.of("a", "b", "c");
	// 2.       
	String[] strArray = new String[] {"a", "b", "c"};
	Stream stream = Stream.of(strArray);
	Stream stream = Arrays.stream(strArray);
	// 3.       (   Map  )
	List list = Arrays.asList(strArray);
	stream = list.stream();

	       ，             Stream：IntStream、LongStream、DoubleStream。
	         Stream、Stream 、Stream，             ，                    Stream。
	Java 8                Stream

	2.10.2   Stream   :
	IntStream stream1 = IntStream.of(new int[]{1, 2, 3});
	//[1,3)
	IntStream stream2 = IntStream.range(1, 3);
	//[1,3]
	IntStream stream3 = IntStream.rangeClosed(1, 3);

	2.10.3 Stream       :
	Stream stream = Stream.of("hello","world","tom");
	// 1.    Array
	String[] strArray  = stream.toArray(String[]::new);
	// 2.    Collection
	List list1 = stream.collect(Collectors.toList());
	List list2 = stream.collect(Collectors.toCollection(ArrayList::new));
	Set set3 = stream.collect(Collectors.toSet());
	Set set4 = stream.collect(Collectors.toCollection(HashSet::new));
	// 3.    String
	String str = stream.collect(Collectors.joining()).toString();

	     :    Stream        ，                 。
	              :
	java.lang.IllegalStateException: stream has already been operated upon or closed


	2.10.4 Stream  
	           Stream ，                 。           。

	Intermediate：    
	map (mapToInt, flatMap  )、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

	Terminal：     
	forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

	Short-circuiting：     
	anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit


	map/flatMap     Stream        ，         。
	  :
	    
	Stream wordList = Stream.of("hello","world","tom");
	List output = wordList.
			 		map(String::toUpperCase).
				  	collect(Collectors.toList());
  	//       forEach    
	wordList.map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);

	  :
	     
	List nums = Arrays.asList(1, 2, 3, 4);
	List squareNums = 
				nums.stream().
				map(n -> n * n).
				collect(Collectors.toList());
	map     1:1  ，      ，               。      ，         ，     flatMap。
	map flatMap          
	 Stream      map(Function super T, ? extends R> mapper);
	 Stream flatMap(Function super T, ? extends Stream extends R>> mapper);

	  :
	//stream1          List    
	Stream> stream1 = Stream.of(
					 Arrays.asList(1),
					 Arrays.asList(2, 3),
					 Arrays.asList(4, 5, 6)
				 );
				Stream stream2 = stream1.
				flatMap((e) -> e.stream());
				
	stream2.forEach(e->System.out.println(e));//  1 2 3 4 5 6
	flatMap   stream1          ，               ，     stream2        List  ，       。

	  :
	Stream stream1 = Stream.of("tom.Li","lucy.Liu");
	//flatMap   stream1          [.]         
	//         4     stream2
	Stream stream2 = stream1.flatMap(s->Stream.of(s.split("[.]")));
	stream2.forEach(System.out::println);
	    :
		tom
		Li
		lucy
		Liu



	forEach         Lambda    ，    Stream              。
	forEach   terminal   ，   stream      
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	list.stream().forEach(System.out::println);


	filter        Stream       ，                 Stream。
	    predicate                ，         ，                  Stream  （  forEach）。forEach                  。forEach       ，       forEach       Stream  
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	list.stream().filter(s->s.length()>4).forEach(System.out::println);
	  :System.out::println    lambda            


	peek                  Stream
	  :  peek  ,          
	peek   intermediate   
	  :
	List list = Arrays.asList("one", "two", "three", "four");
	List list2 = list.stream()
				 .filter(e -> e.length() > 3)
				 .peek(e -> System.out.println("          : " + e))
				 .filter(e->e.length()>4)
				 .peek(e -> System.out.println("          : " + e))
				 .collect(Collectors.toList());
	System.out.println(list2.size());//      1
	  list2            


	findFirst      Stream       ，   ，     ：Optional。
	         ,  list.stream().findFirst()    Optional  ,
		          null。
	  :
	List list = Arrays.asList("test","hello","world");
	Optional first = list.stream().findFirst();
	System.out.println(first.orElse("  null"));


	sort   
	         ，         Stream。            Comparator        。
	  Stream       sorted   ，                    Stream      map、filter、limit、skip    distinct         ，   ，              。
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	list.stream().sorted().filter(s->s.startsWith("j")).forEach(System.out::println);
	//          
	list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
	      ，             Stream，           ，       list       ：


	Map   
	    map         Function               ，
		                    。
		      map           ，
		map   Stream      map              。
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	list.stream().map(s->s.toUpperCase()).forEach(System.out::println);


	Match   
	Stream         ，       Predicate      Stream。
	             ，     boolean    。
	//           true     false
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	boolean allMatch = list.stream().allMatch((s)->s.startsWith("j"));
	System.out.println(allMatch);

	//           true     false
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	boolean anyMatch = list.stream().anyMatch((s)->s.startsWith("j"));
	System.out.println(anyMatch);

	//          true     false
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	boolean noneMatch = list.stream().noneMatch((s)->s.startsWith("j"));
	System.out.println(noneMatch);


	Count   
	         ，  Stream      ，      long。
	  :
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	long count = list.stream().filter(s->s.startsWith("j")).count();
	System.out.println(count);


	Reduce   /  
	        ，           stream               .
	        （  ），        （BinaryOperator），
		    Stream     、   、  n      。Stream.reduce，
		      average, sum, min, max, and count，        ，
		  reduce                 .
		       ，     、    sum、min、max       reduce。
		   Stream   sum     
	IntStream integers = IntStream.range(1, 10);
	Integer sum = integers.reduce(0, (a, b) -> a+b);  
	Integer sum = integers.reduce(0, Integer::sum);
	          ，     Stream            ，     Optional。
	OptionalInt min = integers.reduce((a, b) -> a opStr = Stream.of("A", "B", "C", "D").reduce(String::concat); 

	  :
	List list = Arrays.asList("test","javap","hello","world","java","tom","C","javascript");
	Optional reduce = list.stream().sorted((s1,s2)->s2.length()-s1.length()).filter(s->s.startsWith("j")).map(s->s+"_briup").reduce((s1,s2)->s1+"|"+s2);
	System.out.println(reduce.orElse("   "));//     : javascript_briup|javap_briup|java_briup
	       ，      :
	Optional reduce    =  list.stream()
					  .sorted((s1,s2)->s2.length()-s1.length())
					  .filter(s->s.startsWith("j"))
					  .map(s->s+"_briup")
					  .reduce((s1,s2)->s1+"|"+s2);
		1.   stream  
		2.   ，            ，        
		3.   ，         'j'   
		4.     ，           "_briup"
		5.   reduce      ,  "|"     
		6.    Optional    ，                  				  



	limit/skip 
	limit    Stream     n    ；skip       n           
	  :
	List list = Arrays.asList("test","javap","hello","world","java","tom","C","javascript");
	list.stream().limit(5).forEach(System.out::println);
	list.stream().skip(5).forEach(System.out::println);




	min/max/distinct
	  :
	                
	BufferedReader br = new BufferedReader(new FileReader("src/com/briup/test/a.txt"));
	int maxLen = br.lines().
		   	mapToInt(String::length).
		   	max().
		   	getAsInt();

	System.out.println(maxLen);	 
	  :lines                   Stream    ,       String    ,  String::length            (       ),            ,max()          OptionalInt    ,       getAsInt            int 

	  :
	       ，   ，     ,         
	BufferedReader br = new BufferedReader(new FileReader("src/com/briup/test4/day17.txt"));
	br.lines().
	   flatMap(s->Stream.of(s.split(" "))).
	   filter(s->s.length()>0).
	   map(s->s.toLowerCase()).
	   distinct().
	   sorted().
	   forEach(System.out::println);
	


	Stream.generate
	  Supplier  ，       Stream   。           、    Stream，                    Stream。  Supplier       Stream.generate()     Stream，       ，    ，    limit       Stream  。                 
	public static Stream generate(Supplier s);
	  :
	  100          Stream  
	Stream.generate(()->(int)(Math.random()*100)).limit(100).forEach(System.out::println);
		


	Stream.iterate
	iterate   reduce     ，       ，    UnaryOperator（    f）。
		        Stream       ，f(seed)     ，f(f(seed))    ，
		f(f(f(seed)))    ,    。
	       :
	public static Stream iterate(final T seed, final UnaryOperator f)

	UnaryOperator     Function  :
	public interface UnaryOperator extends Function
	  :
	        
	Stream.iterate(0, n -> n + 3).
				limit(10). 
				forEach(x -> System.out.print(x + " "));
	    :
	0 3 6 9 12 15 18 21 24 27 




	Collectors 
	java.util.stream.Collectors                    。
	   Stream      Collection，    Stream       。
	  :
	 Stream             List  
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	List result = list.stream().filter(s->s.length()>4).collect(Collectors.toList());

	//  :          
	List list = Arrays.asList("test","hello","world","java","tom","C","javascript");
	//            List     Map value,        Map Key
	Map> collect = list.stream().collect(Collectors.groupingBy(String::length));
	//          s->s.length()   Eclipse           ，        =     
	//           
	Map> collect = list.stream().collect(Collectors.groupingBy(s->s.length()));
		
	//  :         java      partitioning       
	Map> collect = 
			list.stream().collect(Collectors.partitioningBy(s->s.indexOf("java")!=-1));
	for(Boolean b:collect.keySet()){
		System.out.println(b+" : "+collect.get(b).size());
	}


	2.11   Streams
	Stream        ，  Stream               ，   Stream            。
	  :
	public class LambdaTest12 {
	
		public static void main(String[] args) {
			
			//  100             
			int max = 1000000;
			List values = new ArrayList(max);
			for (int i = 0; i < max; i++) {
			    UUID uuid = UUID.randomUUID();
			    values.add(uuid.toString());
			}


			//1  *10^9=1  
			long t0 = System.nanoTime();
			//  stream 
			long count = values.stream().sorted().count();
			//  stream
			//long count = values.parallelStream().sorted().count();
			long t1 = System.nanoTime();

			long time = t1 - t0;
			System.out.println(count);
			System.out.println(time);
		}
		
	}

	  : 100              ，                  



	2.12 Map  
	Map     stream，  Map                     。
	Java8 Map     ：

	Object compute(Object key, BiFunction remappingFunction):     remappingFunction   key-value       value。    value  null，     value   value；    value null，    key-value ；

	Object computeIfAbsent(Object key, Function mappingFunction):     key   Map    value null，      mappingFunction   key、value        ，          value；     key   Map    value null，          ；   Map      key，          key-value 。

	Object computeIfPresent(Object key, BiFunction remappingFunction):        key   Map    value  null，      remappingFunction   key、value       ，         null，           value；       null，    key-value 。

	void forEach(BiConsumer action):    Java8 Map       key-value    。

	Object getOrDefault(Object key, V defaultValue):     key   value。   key   ，   defaultValue。

	Object merge(Object key, Object value, BiFunction remappingFunction):       key     Map    value。     value null，        value   value（      ，       key-value）；     value  null，   remappingFunction     value、 value        ，            value。

	Object putIfAbsent(Object key, Object value):           key   value   null，   key   value null，       value     null。   key   value  null，           。

	Object replace(Object key, Object value): Map   key   value    value           。  key Map    ，       key-value ，    null。

	Boolean replace(K key, V oldValue, V newValue): Map    key-value   value    value。   Map      key-value ，        true，    false。

	replaceAll(BiFunction function):     function  key-value     ，        key-value  value
プロセス間通信binderメカニズム-独自のシステムサービスを追加
ABAP、JavaとJavaScriptのシーケンス化、逆シーケンス化