Java 面向对象（十五）

Lambda表达式

1. 函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法， 强调做什么，而不是以什么形式做。

面向对象的思想：

做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。

函数式编程思想：

只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。

2. 冗余的代码

【例1】传统写法

当需要启动一个线程去完成任务时，通常会通过 java.lang.Runnable 接口来定义任务内容，并使用 java.lang.Thread 类来启动该线程。代码如下：

public class DemoRunnable {

	public static void main(String[] args) {

    	// 匿名内部类

		Runnable task = new Runnable() {

			@Override

			public void run() { // 覆盖重写抽象方法

				System.out.println("多线程任务执行！");

			}

		};

		new Thread(task).start(); // 启动线程

	}

}

本着“一切皆对象”的思想，这种做法是无可厚非的：首先创建一个Runnable接口的匿名内部类对象来指定任务内容，再将其交给一个线程来启动。

【例1】代码分析

对于 Runnable 的匿名内部类用法，可以分析出几点内容：

Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，似乎只有方法体才是关键所在。

【例2】传统写法

当需要自定义排序的TreeSet集合时，通常会通过 jjava.util.Comparator 接口来定义排序方法，并使用 TreeSet(Comparator<? super E> comparator) 这个构造器来调用。代码如下：

public class DemoComparator {

	public static void main(String[] args) {

		// 匿名内部类

		Comparator<Integer> comparator = new Comparator<Integer>() {

			@Override

			public int compare(Integer o1, Integer o2) { // 覆盖重写抽象方法

				return Integer.compare(o1, o2);

			}

		};

		TreeSet<Integer> set = new TreeSet<>(comparator);

	}

}

【例2】代码分析

对于 comparator 的匿名内部类用法，可以分析出几点内容：

TreeSet 构造器需要 comparator 接口作为参数，其中的抽象 compare 方法是用来指定排序的核心；
为了指定 compare 的方法体，不得不需要 comparator 接口的实现类；
为了省去定义一个 comparatorImpl 实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象 compare 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，只有参数和方法体才是关键所在。

3. 编程思想转换

做什么，而不是怎么做

我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。

传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

生活举例

当我们需要从北京到上海时，可以选择高铁、汽车、骑行或是徒步。我们的真正目的是到达上海，而如何才能到达上海的形式并不重要，所以我们一直在探索有没有比高铁更好的方式——搭乘飞机。

而现在这种飞机（甚至是飞船）已经诞生：2014年3月Oracle所发布的Java 8（JDK 1.8）中，加入了Lambda表达式的重量级新特性，为我们打开了新世界的大门。

4. 体验Lambda的更优写法

借助Java 8的全新语法，上述例子的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

public class DemoLambdaRunnable {

	public static void main(String[] args) {

		new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程

	}

}

public class DemoLambdaComparator {

	public static void main(String[] args) {

		TreeSet<Integer> set = new TreeSet<>((x, y) -> Integer.compare(x, y));

	}

}

这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。

不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！

5. 回顾匿名内部类

Lambda是怎样击败面向对象的？在上例中，核心代码其实只是如下所示的内容：

() -> System.out.println("多线程任务执行！");

(x, y) -> Integer.compare(x, y);

为了理解Lambda的语义，我们需要从传统的代码起步。

使用实现类

要启动一个线程，需要创建一个Thread类的对象并调用start方法。而为了指定线程执行的内容，需要调用Thread类的构造方法：

public Thread(Runnable target)

为了获取Runnable接口的实现对象，可以为该接口定义一个实现类RunnableImpl：

public class RunnableImpl implements Runnable {

	@Override

	public void run() {

		System.out.println("多线程任务执行！");

	}

}

然后创建该实现类的对象作为Thread类的构造参数：

public class Demo03ThreadInitParam {

	public static void main(String[] args) {

		Runnable task = new RunnableImpl();

		new Thread(task).start();

	}

}

【例2】TreeSet的排序也是同理，这里不再阐述。

使用匿名内部类

这个 RunnableImpl 类只是为了实现 Runnable 接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义，即匿名内部类：

public class Demo04ThreadNameless {

	public static void main(String[] args) {

		new Thread(new Runnable() {

			@Override

			public void run() {

				System.out.println("多线程任务执行！");

			}

		}).start();

	}

}

匿名内部类的好处与弊端

一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

语义分析

仔细分析该代码中的语义，Runnable 接口只有一个 run 方法的定义：

public abstract void run();

即制定了一种做事情的方案（其实就是一个函数）：

无参数：不需要任何条件即可执行该方案。
无返回值：该方案不产生任何结果。
代码块（方法体）：该方案的具体执行步骤。

同样的语义体现在 Lambda 语法中，要更加简单：

() -> System.out.println("多线程任务执行！")

前面的一对小括号即run方法的参数（无），代表不需要任何条件；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码。

6. Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

一些参数
一个箭头
一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明：

小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
-> 是新引入的语法格式，代表指向动作。
大括号内的语法与传统方法体要求基本一致。

7. Lambda省略格式

可推导即可省略

Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参数，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

8. Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

（1）使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的 Runnable、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用 Lambda。

（2）使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

9. 练习

（1）无参无返回

题目

给定一个厨子 Cook 接口，内含唯一的抽象方法 makeFood，且无参数、无返回值。如下：

public interface Cook {

    void makeFood();

}

在下面的代码中，请使用Lambda的标准格式调用 invokeCook 方法，打印输出“吃饭啦！”字样：

public class DemoInvokeCook {

    public static void main(String[] args) {

        // 请在此使用Lambda【标准格式】调用invokeCook方法

    }

    private static void invokeCook(Cook cook) {

        cook.makeFood();

    }

}

解答

public static void main(String[] args) {

    invokeCook(() -> {

      	System.out.println("吃饭啦！");

    });

}

备注：小括号代表 Cook 接口 makeFood 抽象方法的参数为空，大括号代表makeFood 的方法体。

（2）有参有返回

题目

给定一个计算器Calculator接口，内含抽象方法 calc 可以将两个int数字相加得到和值：

public interface Calculator {

    int calc(int a, int b);

}

在下面的代码中，请使用Lambda的标准格式调用 invokeCalc 方法，完成120和130的相加计算：

public class Demo08InvokeCalc {

    public static void main(String[] args) {

        // 请在此使用Lambda【标准格式】调用invokeCalc方法来计算120+130的结果

    }

    private static void invokeCalc(int a, int b, Calculator calculator) {

        int result = calculator.calc(a, b);

        System.out.println("结果是：" + result);

    }

}

解答

public static void main(String[] args) {

    invokeCalc(120, 130, (int a, int b) -> {

      	return a + b;

    });

}

备注：小括号代表 Calculator 接口 calc 抽象方法的参数，大括号代表 calc 的方法体。

函数式接口

1. 概念

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖” 是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的 for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

2. 格式

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {

    public abstract 返回值类型 方法名称(可选参数信息);

    // 其他非抽象方法内容

}

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface {

    void myMethod();

}

3. @FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

@FunctionalInterface

public interface MyFunctionalInterface {

	void myMethod();

}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

4. 自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface {

    // 使用自定义的函数式接口作为方法参数

    private static void doSomething(MyFunctionalInterface inter) {

    	inter.myMethod(); // 调用自定义的函数式接口方法

    }

    public static void main(String[] args) {

    // 调用使用函数式接口的方法

    	doSomething(() -> System.out.println("Lambda执行啦！"));

    }

}

函数式编程

在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。下面我们做一个初探。

1. Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

性能浪费的日志案例

注: 日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。

一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

public class DemoLogger {

	private static void log(int level, String msg) {

		if (level == 1) {

			System.out.println(msg);

		}

	}

	public static void main(String[] args) {

		String msgA = "Hello";

		String msgB = "World";

		String msgC = "Java";

		log(1, msgA + msgB + msgC);

	}

}

这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

备注：SLF4J 是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug("变量{}的取值为{}。", "os", "macOS") ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

体验Lambda的更优写法

使用 Lambda 必然需要一个函数式接口：

@FunctionalInterface

public interface MessageBuilder {

	String buildMessage();

}

然后对 log 方法进行改造：

public class DemoLoggerLambda {

	private static void log(int level, MessageBuilder builder) {

		if (level == 1) {

			System.out.println(builder.buildMessage());

		}

	}

	public static void main(String[] args) {

		String msgA = "Hello";

		String msgB = "World";

		String msgC = "Java";

		log(1, () -> msgA + msgB + msgC);

	}

}

这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接；否则三个字符串将不会进行拼接。

证明Lambda的延迟

下面的代码可以通过结果进行验证：

public class DemoLoggerDelay {

	private static void log(int level, MessageBuilder builder) {

		if (level == 1) {

			System.out.println(builder.buildMessage());

		}

	}

	public static void main(String[] args) {

		String msgA = "Hello";

		String msgB = "World";

		String msgC = "Java";

		log(2, () -> {

			System.out.println("Lambda执行！");

			return msgA + msgB + msgC;

		});

	}

}

结果什么也没输出，从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。

扩展：实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法来完成。而是否调用其所在方法是在条件判断之后才执行的。

2. 使用Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。

例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。

public class Demo04Runnable {

	private static void startThread(Runnable task) {

		new Thread(task).start();

	}

	public static void main(String[] args) {

		startThread(() -> System.out.println("线程任务执行！"));

	}

}

类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时，就可以调该方法获取。

import java.util.Arrays;

import java.util.Comparator;

public class DemoComparator {

	private static Comparator<String> newComparator() {

		return (a, b) -> b.length() - a.length();

	}

	public static void main(String[] args) {

		String[] array = { "abc", "ab", "abcd" };

		System.out.println(Arrays.toString(array));

		Arrays.sort(array, newComparator());

		System.out.println(Arrays.toString(array));

	}

}

其中直接return一个Lambda表达式即可。

3. 常用函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。

下面是最简单的几个接口及使用示例。

（1）Supplier接口

java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。

用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

import java.util.function.Supplier;

public class DemoSupplier {

	private static String getString(Supplier<String> function) {

		return function.get();

	}

	public static void main(String[] args) {

		String msgA = "Hello";

		String msgB = "World";

		System.out.println(getString(() -> msgA + msgB));

	}

}

练习：求数组元素最大值

题目

使用 Supplier 接口作为方法参数类型，通过Lambda表达式求出 int 数组中的最大值。提示：接口的泛型请使用 java.lang.Integer 类。

解答

public class Test {

	// 定一个方法,方法的参数传递Supplier,泛型使用Integer

	public static int getMax(Supplier<Integer> sup) {

		return sup.get();

	}

	public static void main(String[] args) {

		int arr[] = { 2, 3, 4, 52, 333, 23 };

		// 调用getMax方法,参数传递Lambda

		int maxNum = getMax(() -> {

			// 计算数组的最大值

			int max = arr[0];

			for (int i : arr) {

				if (i > max) {

					max = i;

				}

			}

			return max;

		});

		System.out.println(maxNum);

	}

}

（2）Consumer接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如下：

import java.util.function.Consumer;

public class Test {

	private static void consumeString(Consumer<String> function) {

		function.accept("Hello");

	}

	public static void main(String[] args) {

		consumeString(s -> System.out.println(s));

	}

}

默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：

default Consumer<T> andThen(Consumer<? super T> after) {

    Objects.requireNonNull(after);

    return (T t) -> { accept(t); after.accept(t); };

}

备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出 NullPointerException 异常。这省去了重复编写 if 语句和抛出空指针异常的麻烦。

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况：

private static void consumeString(Consumer<String> one, Consumer<String> two) {

    one.andThen(two).accept("Hello");

}

public static void main(String[] args) {

    consumeString(s -> System.out.println(s.toUpperCase()), s -> System.out.println(s.toLowerCase()));

}

练习：格式化打印信息

题目

下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。

public static void main(String[] args) {

    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };

}

解答

import java.util.function.Consumer;

public class Test {

	public static void main(String[] args) {

		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };

		printInfo(s -> System.out.print("姓名：" + s.split(",")[0]),

				s -> System.out.println("。性别：" + s.split(",")[1] + "。"), array);

	}

	private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {

		for (String info : array) {

			one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。

		}

	}

}

（3）Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：

import java.util.function.Predicate;

public class Test {

	private static void method(Predicate<String> predicate) {

		boolean veryLong = predicate.test("HelloWorld");

		System.out.println("字符串很长吗：" + veryLong);

	}

	public static void main(String[] args) {

		method(s -> s.length() > 5);

	}

}

条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

默认方法：and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为：

default Predicate<T> and(Predicate<? super T> other) {

    Objects.requireNonNull(other);

    return (t) -> test(t) && other.test(t);

}

如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：

import java.util.function.Predicate;

public class Test {

	private static void method(Predicate<String> one, Predicate<String> two) {

		boolean isValid = one.and(two).test("Helloworld");

		System.out.println("字符串符合要求吗：" + isValid);

	}

	public static void main(String[] args) {

		method(s -> s.contains("H"), s -> s.contains("W"));

	}

}

默认方法：or

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。JDK源码为：

default Predicate<T> or(Predicate<? super T> other) {

    Objects.requireNonNull(other);

    return (t) -> test(t) || other.test(t);

}

如果希望实现逻辑“字符串包含大写H 或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不变。

boolean isValid = one.or(two).test("Helloworld");

默认方法：negate

“与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法 negate 的JDK源代码为:

default Predicate<T> negate() {

    return (t) -> !test(t);

}

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样：

import java.util.function.Predicate;

public class Test {

	private static void method(Predicate<String> predicate) {

		boolean veryLong = predicate.negate().test("HelloWorld");

		System.out.println("字符串很长吗：" + veryLong);

	}

	public static void main(String[] args) {

		method(s -> s.length() < 5);

	}

}

练习：集合信息筛选

题目

数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合 ArrayList 中，需要同时满足两个条件：

必须为女生；
姓名为4个字。

public class DemoPredicate {

    public static void main(String[] args) {

        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };

    }

}

解答

import java.util.ArrayList;

import java.util.List;

import java.util.function.Predicate;

public class Test {

	public static void main(String[] args) {

		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };

		List<String> list = filter(array, s -> "女".equals(s.split(",")[1]), s -> s.split(",")[0].length() == 4);

		System.out.println(list);

	}

	private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) {

		List<String> list = new ArrayList<>();

		for (String info : array) {

			if (one.and(two).test(info)) {

				list.add(info);

			}

		}

		return list;

	}

}

（4）Function接口

java.util.function.Function 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

抽象方法：apply

Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。

使用的场景例如：将 String 类型转换为 Integer 类型。

import java.util.function.Function;

public class Test {

	private static void method(Function<String, Integer> function) {

		int num = function.apply("10");

		System.out.println(num + 20);

	}

	public static void main(String[] args) {

		method(s -> Integer.parseInt(s));

	}

}