Lambda简介

Lambda作为函数式编程中的基础部分,在其他编程语言(例如:Scala)中早就广为使用,但在Java领域中发展较慢,直到java8,才开始支持Lambda。

抛开数学定义不看,直接来认识Lambda。Lambda表达式本质上是匿名方法,其底层还是通过invokedynamic指令来生成匿名类来实现。它提供了更为简单的语法和写作方式,允许你通过表达式来代替函数式接口。在一些人看来,Lambda就是可以让你的代码变得更简洁,完全可以不使用——这种看法当然没问题,但重要的是lambda为Java带来了闭包。得益于Lamdba对集合的支持,通过Lambda在多核处理器条件下对集合遍历时的性能提高极大,另外我们可以以数据流的方式处理集合——这是非常有吸引力的。

Lambda语法

Lambda的语法极为简单,类似如下结构:

  1. (parameters) -> expression

或者

  1. (parameters) -> { statements; }

Lambda表达式由三部分组成:

  1. paramaters:类似方法中的形参列表,这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
  2. ->:可理解为“被用于”的意思
  3. 方法体:可以是表达式也可以代码块,是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回,这里的代码块块等同于方法的方法体。如果是表达式,也可以返回一个值或者什么都不反回。

我们通过以下几个示例来做说明:

  1. //示例1:不需要接受参数,直接返回10
  2. ()->10
  3.  
  4. //示例2:接受两个int类型的参数,并返回这两个参数相加的和
  5. (int x,int y)->x+y;
  6.  
  7. //示例2:接受x,y两个参数,该参数的类型由JVM根据上下文推断出来,并返回两个参数的和
  8. (x,y)->x+y;
  9.  
  10. //示例3:接受一个字符串,并将该字符串打印到控制到,不反回结果
  11. (String name)->System.out.println(name);
  12.  
  13. //示例4:接受一个推断类型的参数name,并将该字符串打印到控制台
  14. name->System.out.println(name);
  15.  
  16. //示例5:接受两个String类型参数,并分别输出,不反回
  17. (String name,String sex)->{System.out.println(name);System.out.println(sex)}
  18.  
  19. //示例6:接受一个参数x,并返回该该参数的两倍
  20. x->2*x

Lambda用在哪里

在[函数式接口][1]中我们知道Lambda表达式的目标类型是函数性接口——每一个Lambda都能通过一个特定的函数式接口与一个给定的类型进行匹配。因此一个Lambda表达式能被应用在与其目标类型匹配的任何地方,lambda表达式必须和函数式接口的抽象函数描述一样的参数类型,它的返回类型也必须和抽象函数的返回类型兼容,并且他能抛出的异常也仅限于在函数的描述范围中。

接下来,我们看一个自定义的函数式接口示例:

  1. @FunctionalInterface
  2. interface Converter<F, T>{
  3.  
  4. T convert(F from);
  5.  
  6. }

首先用传统的方式来使用该接口:

  1. Converter<String ,Integer> converter=new Converter<String, Integer>() {
  2. @Override
  3. public Integer convert(String from) {
  4. return Integer.valueOf(from);
  5. }
  6. };
  7.  
  8. Integer result = converter.convert("200");
  9. System.out.println(result);

很显然这没任何问题,那么接下里就是Lambda上场的时刻,用Lambda实现Converter接口:

  1. Converter<String ,Integer> converter=(param) -> Integer.valueOf(param);
  2. Integer result = converter.convert("101");
  3. System.out.println(result);

通过上例,我想你已经对Lambda的使用有了个简单的认识,下面,我们在用一个常用的Runnable做演示:

在以前我们可能会写下这种代码:

  1. new Thread(new Runnable() {
  2. @Override
  3. public void run() {
  4. System.out.println("hello lambda");
  5. }
  6. }).start();

在某些情况下,大量的匿名类会让代码显得杂乱无章。现在可以用Lambda来使它变得简洁:

  1. new Thread(() -> System.out.println("hello lambda")).start();

方法引用

方法引用是Lambda表达式的一个简化写法。所引用的方法其实是Lambda表达式的方法体的实现,其语法结构为:

  1. ObjectRef::methodName

左边可以是类名或者实例名,中间是方法引用符号”::”,右边是相应的方法名。方法引用被分为三类:

1. 静态方法引用

在某些情况下,我们可能写出这样的代码:

  1. public class ReferenceTest {
  2. public static void main(String[] args) {
  3. Converter<String ,Integer> converter=new Converter<String, Integer>() {
  4. @Override
  5. public Integer convert(String from) {
  6. return ReferenceTest.String2Int(from);
  7. }
  8. };
  9. converter.convert("120");
  10.  
  11. }
  12.  
  13. @FunctionalInterface
  14. interface Converter<F,T>{
  15. T convert(F from);
  16. }
  17.  
  18. static int String2Int(String from) {
  19. return Integer.valueOf(from);
  20. }
  21. }

这时候如果用静态引用会使的代码更加简洁:

  1. Converter<String, Integer> converter = ReferenceTest::String2Int;
  2. converter.convert("120");

2. 实例方法引用

我们也可能会写下这样的代码:

  1. public class ReferenceTest {
  2. public static void main(String[] args) {
  3.  
  4. Converter<String, Integer> converter = new Converter<String, Integer>() {
  5. @Override
  6. public Integer convert(String from) {
  7. return new Helper().String2Int(from);
  8. }
  9. };
  10. converter.convert("120");
  11. }
  12.  
  13. @FunctionalInterface
  14. interface Converter<F, T> {
  15. T convert(F from);
  16. }
  17.  
  18. static class Helper {
  19. public int String2Int(String from) {
  20. return Integer.valueOf(from);
  21. }
  22. }
  23. }

同样用实例方法引用会显得更加简洁:

  1. Helper helper = new Helper();
  2. Converter<String, Integer> converter = helper::String2Int;
  3. converter.convert("120");

3. 构造方法引用

现在我们来演示构造方法的引用。首先我们定义一个父类Animal:

  1. class Animal{
  2. private String name;
  3. private int age;
  4.  
  5. public Animal(String name, int age) {
  6. this.name = name;
  7. this.age = age;
  8. }
  9.  
  10. public void behavior(){
  11.  
  12. }
  13. }

接下来,我们在定义两个Animal的子类:Dog、Bird

  1. public class Bird extends Animal {
  2.  
  3. public Bird(String name, int age) {
  4. super(name, age);
  5. }
  6.  
  7. @Override
  8. public void behavior() {
  9. System.out.println("fly");
  10. }
  11. }
  12.  
  13. class Dog extends Animal {
  14.  
  15. public Dog(String name, int age) {
  16. super(name, age);
  17. }
  18.  
  19. @Override
  20. public void behavior() {
  21. System.out.println("run");
  22. }
  23. }

随后我们定义工厂接口:

  1. interface Factory<T extends Animal> {
  2. T create(String name, int age);
  3. }

接下来我们还是用传统的方法来创建Dog类和Bird类的对象:

  1. Factory factory=new Factory() {
  2. @Override
  3. public Animal create(String name, int age) {
  4. return new Dog(name,age);
  5. }
  6. };
  7. factory.create("alias", 3);
  8. factory=new Factory() {
  9. @Override
  10. public Animal create(String name, int age) {
  11. return new Bird(name,age);
  12. }
  13. };
  14. factory.create("smook", 2);

仅仅为了创建两个对象就写了十多号代码,现在我们用构造函数引用试试:

  1. Factory<Animal> dogFactory =Dog::new;
  2. Animal dog = dogFactory.create("alias", 4);
  3.  
  4. Factory<Bird> birdFactory = Bird::new;
  5. Bird bird = birdFactory.create("smook", 3);

这样代码就显得干净利落了。通过Dog::new这种方式来穿件对象时,Factory.create函数的签名选择相应的造函数。

Lambda的域以及访问限制

域即作用域,Lambda表达式中的参数列表中的参数在该Lambda表达式范围内(域)有效。在作用Lambda表达式内,可以访问外部的变量:局部变量、类变量和静态变量,但操作受限程度不一。

访问局部变量

在Lambda表达式外部的局部变量会被JVM隐式的编译成final类型,因此只能访问外而不能修改。

  1. public class ReferenceTest {
  2. public static void main(String[] args) {
  3.  
  4. int n = 3;
  5. Calculate calculate = param -> {
  6. //n=10; 编译错误
  7. return n + param;
  8. };
  9. calculate.calculate(10);
  10. }
  11.  
  12. @FunctionalInterface
  13. interface Calculate {
  14. int calculate(int value);
  15. }
  16.  
  17. }

访问静态变量和成员变量

在Lambda表达式内部,对静态变量和成员变量可读可写。

  1. public class ReferenceTest {
  2. public int count = 1;
  3. public static int num = 2;
  4.  
  5. public void test() {
  6. Calculate calculate = param -> {
  7. num = 10;//修改静态变量
  8. count = 3;//修改成员变量
  9. return n + param;
  10. };
  11. calculate.calculate(10);
  12. }
  13.  
  14. public static void main(String[] args) {
  15.  
  16. }
  17.  
  18. @FunctionalInterface
  19. interface Calculate {
  20. int calculate(int value);
  21. }
  22.  
  23. }

Lambda不能访问函数接口的默认方法

java8增强了接口,其中包括接口可添加default关键词定义的默认方法,这里我们需要注意,Lambda表达式内部不支持访问默认方法。

Lambda实践

在[函数式接口][2]一节中,我们提到java.util.function包中内置许多函数式接口,现在将对常用的函数式接口做说明。

Predicate接口

输入一个参数,并返回一个Boolean值,其中内置许多用于逻辑判断的默认方法:

  1. @Test
  2. public void predicateTest() {
  3. Predicate<String> predicate = (s) -> s.length() > 0;
  4. boolean test = predicate.test("test");
  5. System.out.println("字符串长度大于0:" + test);
  6.  
  7. test = predicate.test("");
  8. System.out.println("字符串长度大于0:" + test);
  9.  
  10. test = predicate.negate().test("");
  11. System.out.println("字符串长度小于0:" + test);
  12.  
  13. Predicate<Object> pre = Objects::nonNull;
  14. Object ob = null;
  15. test = pre.test(ob);
  16. System.out.println("对象不为空:" + test);
  17. ob = new Object();
  18. test = pre.test(ob);
  19. System.out.println("对象不为空:" + test);
  20. }

Function接口

接收一个参数,返回单一的结果,默认的方法(andThen)可将多个函数串在一起,形成复合Funtion(有输入,有输出)结果,

  1. @Test
  2. public void functionTest() {
  3. Function<String, Integer> toInteger = Integer::valueOf;
  4. //toInteger的执行结果作为第二个backToString的输入
  5. Function<String, String> backToString = toInteger.andThen(String::valueOf);
  6. String result = backToString.apply("1234");
  7. System.out.println(result);
  8.  
  9. Function<Integer, Integer> add = (i) -> {
  10. System.out.println("frist input:" + i);
  11. return i * 2;
  12. };
  13. Function<Integer, Integer> zero = add.andThen((i) -> {
  14. System.out.println("second input:" + i);
  15. return i * 0;
  16. });
  17.  
  18. Integer res = zero.apply(8);
  19. System.out.println(res);
  20. }

Supplier接口

返回一个给定类型的结果,与Function不同的是,Supplier不需要接受参数(供应者,有输出无输入)

  1. @Test
  2. public void supplierTest() {
  3. Supplier<String> supplier = () -> "special type value";
  4. String s = supplier.get();
  5. System.out.println(s);
  6. }

Consumer接口

代表了在单一的输入参数上需要进行的操作。和Function不同的是,Consumer没有返回值(消费者,有输入,无输出)

  1. @Test
  2. public void consumerTest() {
  3. Consumer<Integer> add5 = (p) -> {
  4. System.out.println("old value:" + p);
  5. p = p + 5;
  6. System.out.println("new value:" + p);
  7. };
  8. add5.accept(10);
  9. }

以上四个接口的用法代表了java.util.function包中四种类型,理解这四个函数式接口之后,其他的接口也就容易理解了,现在我们来做一下简单的总结:

Predicate用来逻辑判断,Function用在有输入有输出的地方,Supplier用在无输入,有输出的地方,而Consumer用在有输入,无输出的地方。你大可通过其名称的含义来获知其使用场景。

Stream

Lambda为java8带了闭包,这一特性在集合操作中尤为重要:java8中支持对集合对象的stream进行函数式操作,此外,stream api也被集成进了collection api,允许对集合对象进行批量操作。

下面我们来认识Stream。

Stream表示数据流,它没有数据结构,本身也不存储元素,其操作也不会改变源Stream,而是生成新Stream.作为一种操作数据的接口,它提供了过滤、排序、映射、规约等多种操作方法,这些方法按照返回类型被分为两类:凡是返回Stream类型的方法,称之为中间方法(中间操作),其余的都是完结方法(完结操作)。完结方法返回一个某种类型的值,而中间方法则返回新的Stream。中间方法的调用通常是链式的,该过程会形成一个管道,当完结方法被调用时会导致立即从管道中消费值,这里我们要记住:Stream的操作尽可能以“延迟”的方式运行,也就是我们常说的“懒操作”,这样有助于减少资源占用,提高性能。对于所有的中间操作(除sorted外)都是运行在延迟模式下。

Stream不但提供了强大的数据操作能力,更重要的是Stream既支持串行也支持并行,并行使得Stream在多核处理器上有着更好的性能。

Stream的使用过程有着固定的模式:

  1. 创建Stream
  2. 通过中间操作,对原始Stream进行“变化”并生成新的Stream
  3. 使用完结操作,生成最终结果
    也就是
  1. 创建——>变化——>完结

Stream的创建

对于集合来说,可以通过调用集合的stream()或者parallelStream()来创建,另外这两个方法也在Collection接口中实现了。对于数组来说,可以通过Stream的静态方法of(T … values)来创建,另外,Arrays也提供了有关stream的支持。

除了以上基于集合或者数组来创建Stream,也可以通过Steam.empty()创建空的Stream,或者利用Stream的generate()来创建无穷的Stream。

下面我们以串行Stream为例,分别说明Stream几种常用的中间方法和完结方法。首先创建一个List集合:

  1. List<String> lists=new ArrayList<String >();
  2. lists.add("a1");
  3. lists.add("a2");
  4. lists.add("b1");
  5. lists.add("b2");
  6. lists.add("b3");
  7. lists.add("o1");

中间方法

过滤器(Filter)

结合Predicate接口,Filter对流对象中的所有元素进行过滤,该操作是一个中间操作,这意味着你可以在操作返回结果的基础上进行其他操作。

  1. public static void streamFilterTest() {
  2. lists.stream().filter((s -> s.startsWith("a"))).forEach(System.out::println);
  3.  
  4. //等价于以上操作
  5. Predicate<String> predicate = (s) -> s.startsWith("a");
  6. lists.stream().filter(predicate).forEach(System.out::println);
  7.  
  8. //连续过滤
  9. Predicate<String> predicate1 = (s -> s.endsWith("1"));
  10. lists.stream().filter(predicate).filter(predicate1).forEach(System.out::println);
  11. }

排序(Sorted)

结合Comparator接口,该操作返回一个排序过后的流的视图,原始流的顺序不会改变。通过Comparator来指定排序规则,默认是按照自然顺序排序。

  1. public static void streamSortedTest() {
  2. System.out.println("默认Comparator");
  3. lists.stream().sorted().filter((s -> s.startsWith("a"))).forEach(System.out::println);
  4.  
  5. System.out.println("自定义Comparator");
  6. lists.stream().sorted((p1, p2) -> p2.compareTo(p1)).filter((s -> s.startsWith("a"))).forEach(System.out::println);
  7.  
  8. }

映射(Map)

结合Function接口,该操作能将流对象中的每个元素映射为另一种元素,实现元素类型的转换。

  1. public static void streamMapTest() {
  2. lists.stream().map(String::toUpperCase).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
  3.  
  4. System.out.println("自定义映射规则");
  5. Function<String, String> function = (p) -> {
  6. return p + ".txt";
  7. };
  8. lists.stream().map(String::toUpperCase).map(function).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
  9.  
  10. }

在上面简单介绍了三种常用的操作,这三种操作极大简化了集合的处理。接下来,介绍几种完结方法:

完结方法

“变换”过程之后,需要获取结果,即完成操作。下面我们来看相关的操作:

匹配(Match)

用来判断某个predicate是否和流对象相匹配,最终返回Boolean类型结果,例如:

  1. public static void streamMatchTest() {
  2. //流对象中只要有一个元素匹配就返回true
  3. boolean anyStartWithA = lists.stream().anyMatch((s -> s.startsWith("a")));
  4. System.out.println(anyStartWithA);
  5. //流对象中每个元素都匹配就返回true
  6. boolean allStartWithA
  7. = lists.stream().allMatch((s -> s.startsWith("a")));
  8. System.out.println(allStartWithA);
  9. }

收集(Collect)

在对经过变换之后,我们将变换的Stream的元素收集,比如将这些元素存至集合中,此时便可以使用Stream提供的collect方法,例如:

  1. public static void streamCollectTest() {
  2. List<String> list = lists.stream().filter((p) -> p.startsWith("a")).sorted().collect(Collectors.toList());
  3. System.out.println(list);
  4.  
  5. }

计数(Count)

类似sql的count,用来统计流中元素的总数,例如:

  1. public static void streamCountTest() {
  2. long count = lists.stream().filter((s -> s.startsWith("a"))).count();
  3. System.out.println(count);
  4. }

规约(Reduce)

reduce方法允许我们用自己的方式去计算元素或者将一个Stream中的元素以某种规律关联,例如:

  1. public static void streamReduceTest() {
  2. Optional<String> optional = lists.stream().sorted().reduce((s1, s2) -> {
  3. System.out.println(s1 + "|" + s2);
  4. return s1 + "|" + s2;
  5. });
  6. }

执行结果如下:

  1. a1|a2
  2. a1|a2|b1
  3. a1|a2|b1|b2
  4. a1|a2|b1|b2|b3
  5. a1|a2|b1|b2|b3|o1

并行Stream VS 串行Stream

到目前我们已经将常用的中间操作和完结操作介绍完了。当然所有的的示例都是基于串行Stream。接下来介绍重点戏——并行Stream(parallel Stream)。并行Stream基于Fork-join并行分解框架实现,将大数据集合切分为多个小数据结合交给不同的线程去处理,这样在多核处理情况下,性能会得到很大的提高。这和MapReduce的设计理念一致:大任务化小,小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器。

通过parallelStream()创建并行Stream。为了验证并行Stream是否真的能提高性能,我们执行以下测试代码:

首先创建一个较大的集合:

  1. List<String> bigLists = new ArrayList<>();
  2. for (int i = 0; i < 10000000; i++) {
  3. UUID uuid = UUID.randomUUID();
  4. bigLists.add(uuid.toString());
  5. }

测试串行流下排序所用的时间:

  1. private static void notParallelStreamSortedTest(List<String> bigLists) {
  2. long startTime = System.nanoTime();
  3. long count = bigLists.stream().sorted().count();
  4. long endTime = System.nanoTime();
  5. long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
  6. System.out.println(System.out.printf("串行排序: %d ms", millis));
  7.  
  8. }

测试并行流下排序所用的时间:

  1. private static void parallelStreamSortedTest(List<String> bigLists) {
  2. long startTime = System.nanoTime();
  3. long count = bigLists.parallelStream().sorted().count();
  4. long endTime = System.nanoTime();
  5. long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
  6. System.out.println(System.out.printf("并行排序: %d ms", millis));
  7.  
  8. }

结果如下:

  1. 串行排序: 13336 ms
  2. 并行排序: 6755 ms

看到这里,我们确实发现性能提高了约么50%,你也可能会想以后都用parallel Stream不久行了么?实则不然,如果你现在还是单核处理器,而数据量又不算很大的情况下,串行流仍然是这种不错的选择。你也会发现在某些情况,串行流的性能反而更好,至于具体的使用,需要你根据实际场景先测试后再决定。

懒操作

上面我们谈到Stream尽可能以延迟的方式运行,这里通过创建一个无穷大的Stream来说明:

首先通过Stream的generate方法来一个自然数序列,然后通过map变换Stream:

  1. //递增序列
  2. class NatureSeq implements Supplier<Long> {
  3. long value = 0;
  4.  
  5. @Override
  6. public Long get() {
  7. value++;
  8. return value;
  9. }
  10. }
  11.  
  12. public void streamCreateTest() {
  13. Stream<Long> stream = Stream.generate(new NatureSeq());
  14. System.out.println("元素个数:"+stream.map((param) -> {
  15. return param;
  16. }).limit(1000).count());
  17.  
  18. }

执行结果为:

  1. 元素个数:1000

我们发现开始时对这个无穷大的Stream做任何中间操作(如:filter,map等,但sorted不行)都是可以的,也就是对Stream进行中间操作并生存一个新的Stream的过程并非立刻生效的(不然此例中的map操作会永远的运行下去,被阻塞住),当遇到完结方法时stream才开始计算。通过limit()方法,把这个无穷的Stream转为有穷的Stream。

30 分钟 Java Lambda 入门教程的更多相关文章

  1. [30分钟]MSSQL快速入门教程

    1.什么是SQL语句 sql语言:结构化的查询语言.(Structured Query Language),是关系数据库管理系统的标准语言. 它是一种解释语言:写一句执行一句,不需要整体编译执行.语法 ...

  2. 【视频】谷歌大佬30分钟让你入门机器学习(2019谷歌I/O资源分享)

    如果你是个谷粉,就一定会知道: 谷歌向来都很大胆.当所有的科技公司都在讲产品.讲利润的时候,2019年的谷歌开发者大会的主题却是:人文关怀.要知道,这是政府操心的事,而不是一家公司的任务. 谷歌敢这样 ...

  3. 30分钟groovy快速入门并掌握(ubuntu 14.04+IntelliJ 13)

    本文适合于不熟悉 Groovy,但想快速轻松地了解其基础知识的 Java开发人员.了解 Groovy 对 Java 语法的简化变形,学习 Groovy 的核心功能,例如本地集合.内置正则表达式和闭包. ...

  4. Java Lambda简明教程(一)

    Lambda表达式背景 许多热门的编程语言如今都有一个叫做lambda或者闭包的语言特性,包括比较经典的函数式编程语言Lisp,Scheme,也有稍微年轻的语言比如JavaScript,Python, ...

  5. Java Lambda表达式教程与示例

    Lambda表达式是Java 8中引入的一个新特性.一个lambda表达式是一个匿名函数,而且这个函数没有名称且不属于任何类.lambda表达式的概念最初是在LISP编程语言中引入的. Java La ...

  6. Java api 入门教程 之 JAVA的IO处理

    IO是输入和输出的简称,在实际的使用时,输入和输出是有方向的.就像现实中两个人之间借钱一样,例如A借钱给B,相对于A来说是借出,而相对于B来说则是借入.所以在程序中提到输入和输出时,也需要区分清楚是相 ...

  7. Java api 入门教程 之 JAVA的Date类与Calendar类

    在JDK1.0中,Date类是唯一的一个代表时间的类,但是由于Date类不便于实现国际化,所以从JDK1.1版本开始,推荐使用Calendar类进行时间和日期处理. 一.这里简单介绍一下Date类的使 ...

  8. 30分钟Git命令入门到放弃

    git 现在的火爆程度非同一般,它被广泛地用在大型开源项目,团队开发,以及独立开发者,甚至学生之中. 初学者非常容易被各种命令,参数吓哭.但实际上刚上手你并不需要了解所有命令的用途.你可以从掌握一些简 ...

  9. Java api 入门教程 之 JAVA的Random类

    在实际的项目开发过程中,经常需要产生一些随机数值,例如网站登录中的校验数字等,或者需要以一定的几率实现某种效果,例如游戏程序中的物品掉落等. 在Java API中,在java.util包中专门提供了一 ...

随机推荐

  1. web rest api tools

    https://chrome.google.com/webstore/search/postman-REST%20Client

  2. IOS数据类型

    id – 动态对象类型.动态类型和静态类型对象的否定词汇为 nil. Class – 动态类的类型.它的否定词汇为 Nil.SEL – 选择器的数据类型(typedef):这种数据类型代表运行时的一种 ...

  3. mac下装Ruby

    https://ruby-china.org/wiki/install_ruby_guide

  4. ListView(1)几个重要属性,关闭滚动到顶部,底部的动画,item之间的分割线,背景等

    见表: android:stackFromBottom="true" 设置该属性之后你做好的列表就会显示你列表的最下面,值为true和false android:transcrip ...

  5. Android相对布局(RelativeLayout)

    Android相对布局(RelativeLayout) 备注:这里的视图和元素是等同的概念. RelativeLayout是一个允许子视图相对于其他兄弟视图或是父视图显示的视图组(通过ID指定).每个 ...

  6. poj 1151 Atlantis (离散化 + 扫描线 + 线段树 矩形面积并)

    题目链接题意:给定n个矩形,求面积并,分别给矩形左上角的坐标和右上角的坐标. 分析: 映射到y轴,并且记录下每个的y坐标,并对y坐标进行离散. 然后按照x从左向右扫描. #include <io ...

  7. FileZilla无法确定拖放操作的目标,由于shell未正确安装

    天有不测风云,突然间,用filezilla下载ftp上的文件到桌面的时候,提示"无法确定拖放操作目标.由于shell未正确安装" 解决办法很简单,执行如下几步就OK了 1.在CMD ...

  8. php yii框架使用MongoDb

    1.安装 运行 php composer.phar require --prefer-dist yiisoft/yii2-mongodb or add "yiisoft/yii2-mongo ...

  9. 01day1

    最大音量 动态规划 题意:给出一个初始值和一个变化序列 c,在第 i 步可以加上或减去 c[i],求 n 步之后能达到的最大值.有一个限定值 maxlevel,在变化过程中值不能超过 maxlevel ...

  10. 【C#学习笔记】类型转换

    using System; namespace ConsoleApplication { class Program { static void Main(string[] args) { " ...