1.Properties类

Properties

  1. package com.qfedu.test1Properties;
  3. import java.util.Properties;
  5. public class Demo2test {
  6.     public static void main(String[] args) {
  7.         Properties p = new Properties();
  8.         //类似map集合 存数据
  9.         p.put("01", "朱1");
  10.         p.put("02", "朱2");    
  11.         //通过键取值
  12.         System.out.println(p.get("01"));
  13.         System.out.println(p.get("02"));
  14.     }
  15. }

Properties可以从流中加载，欸有去读取这个文件，使用Properties讲数据加载出来，以后开发中后缀是 .properties的文件

Person1

  1. package com.qfedu.test1Properties;
  3. public class Person1 {
  4.     public void test1() {
  5.         System.out.println("test1");
  6.     }
  7. }

Person2

  1. package com.qfedu.test1Properties;
  3. public class Person2 {
  4.     public void test2(){
  5.         System.out.println("test2");
  6.     }
  8. }

Domo1

  1. package com.qfedu.test1Properties;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.Method;
  9. import java.util.Properties;
  11. public class Demo1 {
  12.     public static void main(String[] args) throws Exception {
  13.         File file = new File("D:\\eclipse-workspace\\day414\\src\\haha.txt");
  14.         Properties properties = new Properties();
  15.         //从输入字节流读取属性列表(键和元素对)键值对
  16.         properties.load(new FileInputStream(file));
  17.         String className = (String) properties.get("Class");
  18.         String methodName = (String) properties.get("Method");
  20.         Class<?> aClass1 = Class.forName(className);
  21.         Method method = aClass1.getMethod(methodName, null);
  23.         Constructor<?> constructor = aClass1.getConstructor(null);
  24.         Object object = aClass1.newInstance();
  25.         method.invoke(object, null);
  26.     }
  27. }

一、lambda表达式【难】

有一个接口，方法参数是一个接口（且下面只有一个方法），可以使用lambda表达式

语法格式

  1. () -> sout();

1.入门案例

  1. package com.qfedu.test2lambda;
  3. //lambda 入门案例
  4. public class Demo1 {
  5.     public static void main(String[] args) {
  6.         //新建一个线程  runnable是一个接口  作为Thread类的一个参数
  7.         new Thread(new Runnable() {
  9.             @Override
  10.             public void run() {
  11.                 System.out.println("匿名内部类的线程一种写法");
  12.             }
  13.         }).start();
  15.         //lambda表达式的写法
  16.         Runnable run = ()->System.out.println("这个是另外一种写法");
  17.         new Thread(run).start();;
  19.     }
  21. }

总结

方法的参数是一个接口，，接口只有一个需要重写的方法。这个接口对象可以不用new了，直接用lambda表达式。

语法格式：

  1. 接口 接口名字 = (参数)->重写的内容；
  2. 接口 接口名字 = (参数)->{重写的内容;}；
  3.     ()：接口下面的方法 可以是有参数的。
  4.     重写的方法：代码体，输出语句等。

2.1无参无返回值

  1. package com.qfedu.test2lambda;
  3. interface A {
  4.     public void eat();//无参无返回值
  5. }
  7. public class Demo2 {
  8.     public static void main(String[] args) {
  10.         test(() -> System.out.println("吃饭"));
  12.     }
  14.     public static void test(A a) {
  15.         a.eat();
  16.     }
  18. }

2.2有参无返回值

  1. package com.qfedu.test2lambda;
  3. //有参无返回值的写法
  4. interface B{
  5.     public void sleep(String name);//有参无返回值
  6. }
  7. public class Demo3 {
  8.     public static void main(String[] args) {
  9. //        B b = new B() {
  10. //            
  11. //            @Override
  12. //            public void sleep(String name) {
  13. //                System.out.println(name);
  14. //                
  15. //            }
  16. //        };
  17. //        
  19.         B b = (String name)->System.out.println(name);
  20.         test(b, "睡觉");
  21.     }
  22.     public static void test(B b,String name) {
  23.         b.sleep(name);
  24.     }
  26. }

2.3无参有返回值

注意 有返回值的 -> 后面的表达式需要{}括起来

  1. package com.qfedu.test2lambda;
  3. //无参有返回值
  4. interface C{
  5.     public int add();
  6. }
  7. public class Demo4 {
  8.     public static void main(String[] args) {
  9. //        C c = new C() {
  10. //            
  11. //            @Override
  12. //            public int add() {
  13. //                // TODO Auto-generated method stub
  14. //                return 4;
  15. //            }
  16. //        };
  18.         C c = () -> {return 4;};
  19.         test(c);
  21.     }
  22.     public static void test(C c) {
  23.         int a = c.add();
  24.         System.out.println(a);
  25.     }
  27. }

2.4有参数有返回值

  1. package com.qfedu.test2lambda;
  3. //有参数有返回值
  4. interface D{
  5.     public int add(int a, int b);
  6. }
  7. public class Demo5 {
  8.     public static void main(String[] args) {
  9. //        D d = new D() {
  10. //            
  11. //            @Override
  12. //            public int add(int a, int b) {
  13. //                int sum1 = a + b;
  14. //                return sum1;
  15. //            }
  16. //        };
  18.         D d = (int a, int b) ->{int sum1 = a+b;return sum1;};
  20.         test(d, 3, 4);
  23.         test((int a, int b) ->{int sum1 = a+b;return sum1;},3,5);
  25.     }
  26.     public static void test(D d,int a, int b) {
  27.         int sum = a + b;
  28.         System.out.println(sum);
  29.     }
  31. }

注意事项

使用lambda表达式，接口下面不允许有多个方法，这是个局限性

真是开发，如果接口只有一个参数，可以不用new，直接使用lambda

2.5 lambda遍历

写法 集合.forEach(System.out::println)

  1. package com.qfedu.test2lambda;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. //lambda表达式遍历
  7. public class Demo6 {
  8.     public static void main(String[] args) {
  9.         List<String> list = new ArrayList<String>();
  10.         list.add("啊");
  11.         list.add("吧");
  12.         list.add("从");
  13.         //增强foreach循环遍历
  14. //        for (String s1 : list) {
  15. //            System.out.println(s1);
  16. //        }
  18.         //lambda遍历
  19.         list.forEach(System.out::println);
  21.     }
  22. }

二、Stream流【难点】

需求，list集合中过滤出姓张的存到新集合中，在从姓张的集合中过滤出三个字的

  1. package com.qfedu.test3Stream;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.jar.Attributes.Name;
  7. //需求，list集合中过滤出姓张的存到新集合中，在从姓张的集合中过滤出三个字的
  8. public class Demo1 {
  9.     public static void main(String[] args) {
  10.         List<String> list = new ArrayList<String>();
  11.         list.add("张一");
  12.         list.add("张二三");
  13.         list.add("朱四五");
  14.         list.add("张六七");
  15.         list.add("张八九");
  16.         //用来存姓张的集合
  17.         List<String> list1 = new ArrayList<String>();
  18.         for (String s1 : list) {
  19.             //取出首字是张的  startWith 
  20.             if (s1.startsWith("张")) {
  21.                 list1.add(s1);
  22.             }
  23.         }
  24.         System.out.println(list1);
  25.         //用来存姓张的且是三个字的集合
  26.         List<String> list2 = new ArrayList<String>();
  27.         for (String s2 : list1) {
  28.             //字符串长度为三的
  29.             if (s2.length() == 3) {
  30.                 list2.add(s2);
  31.             }
  32.         }
  33.         System.out.println(list2);
  34.     }
  36. }

使用Stream流进行操作，获取流对象，过滤操作，输出打印

  1. package com.qfedu.test3Stream;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. //需求，list集合中过滤出姓张的存到新集合中，在从姓张的集合中过滤出三个字的
  7. //用Stream流进行操作需求  stream流中的filter过滤方法
  8. public class Demo2 {
  9.     public static void main(String[] args) {
  10.         List<String> list = new ArrayList<String>();
  11.         list.add("张一");
  12.         list.add("张二三");
  13.         list.add("朱四五");
  14.         list.add("张六七");
  15.         list.add("张八九");
  16.         //链式操作
  17.         list.stream()
  18.         .filter((String name)->name.startsWith("张"))
  19.         .filter((String name)->name.length() == 3)
  20.         .forEach((String name)->System.out.println("过滤出来的姓名为：" + name));
  21. //        .forEach(System.out::println);;
  23.     }
  24. }

分析代码

  1. list.stream()  将集合数据存到stream流中
  2. .filter((String name)->name.startsWith("张"))  过滤姓张的值
  3. .filter((String name)->name.length() == 3)    过滤姓张长度为3的
  4. .forEach((String name)->System.out.println("过滤出来的姓名为：" + name)); 过滤完之后进行遍历打印

2.1获取流

只有集合和数组才能变成流对象，单个数据元素没法变成流对象

根据集合获取流，因为集合中有数据

Collection获取流：

  1. default    Stream streadm()    不是抽象方法

返回一个顺序Stream与此集合作为其来源。就是数据源[1,2,3]把这个集合变成流对象了

1.根据list获取流对象

  1.         List<String> list = new ArrayList<String>();
  2.         list.add("张一");
  3.         list.add("张二三");
  4.         list.add("朱四五");
  5.         list.add("张六七");
  6.         list.add("张八九");
  8.         //获取流对象
  9.         Stream<String> stream = list.stream();
  10.         System.out.println(stream);

2.根据set集合获取流对象

  1.         Set<String> set = new HashSet<String>();
  2.         set.add("艾斯");
  3.         set.add("萨博");
  4.         set.add("路飞");
  5.         Stream<String> stream2 = set.stream();
  6.         System.out.println(stream2);

3.根据map集合获取流对象

  1.         Map<Integer, String> map = new HashMap<Integer, String>();
  2.         map.put(1, "王路飞");
  3.         map.put(2, "刘索隆");
  4.         map.put(3, "马山治");
  5.         //根据map集合中的键获取流对象
  6.         Set<Integer> set3 = map.keySet();
  7.         Stream<Integer> stream3 = set3.stream();
  8.         //根据map集合中的值获取流对象
  9.         Collection<String> collection = map.values();
  10.         Stream<String> stream4 = collection.stream();
  11.         //根据map集合的键值对实体对象获取流对象
  12.         Set<Map.Entry<Integer, String>> map2 = map.entrySet();
  13.         Stream<Map.Entry<Integer,String>> stream5 = map2.stream();

4.根据数组获取流对象

  1.         String[] arr = {"朱志伟","朱航","杨博"};
  2.         Stream<String> stream6 = Stream.of(arr);

2.2流下面的方法

流就是集合中的数据，对集合中的数据进行操作

方法名称 方法的作用 方法的种类 是否支持链式操作
count 统计个数 终结方法 否
forEach 逐个处理数据 终结方法 否
filter 过滤数据 函数拼接 是
limit 取前几个 函数拼接 是
skip 跳过前几个 函数拼接 是
map 映射 函数拼接 是
concat 拼接组个 函数拼接 是

方法种类：

  1. 终结方法：对流操作的时候，这个方法在链式操作里一定是写在最后的
  3. 函数拼接：这个函数后面还可以继续写函数

2.2.1count和forEach方法

count：统计流中元素的个数，返回值long。

forEach：遍历数据的

这两个都是终结方法，后面不能在跟方法了

  1. package com.qfedu.test3StreamMethod;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. //count和forEach方法
  7. public class Demo1 {
  8.     public static void main(String[] args) {
  9.         List<String> list = new ArrayList<String>();
  10.         list.add("张一");
  11.         list.add("张二三");
  12.         list.add("朱四五");
  13.         list.add("张六七");
  14.         list.add("张八九");
  15.         //count 统计
  16.         long count = list.stream().count();
  17.         System.out.println(count);//5
  18.         //forEach 遍历  name是遍历数据是的一个临时数据
  19.         list.stream().forEach((String name)->{System.out.println(name);});
  20.     }
  21. }

2.2.2filter方法

Stream filter(Predicate<? super T> predicate)

Predicate是一个接口，下面只有一个test(T t)返回值为boolean

因此可使用lambda表达式简写

  1. package com.qfedu.test3StreamMethod;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.Predicate;
  6. import java.util.jar.Attributes.Name;
  7. //filter
  8. public class Demo2 {
  9.     public static void main(String[] args) {
  10.         List<String> list = new ArrayList<String>();
  11.         list.add("张一");
  12.         list.add("张二三");
  13.         list.add("朱四五");
  14.         list.add("张六七");
  15.         list.add("张八九");
  16. //        Predicate<String> predicate = new Predicate<String>() {
  17. //            @Override
  18. //            public boolean test(String t) {
  19. //                // TODO Auto-generated method stub
  20. //                return false;
  21. //            }
  22. //        };
  24.         //filter 意思是 看数据流返回是一个true，就把它留在流里，false就清除掉
  25.         list.stream()
  26.         .filter((String Name) -> {return Name.startsWith("朱");})
  27.         .forEach((String name)->{System.out.println(name);});;
  28.     }
  30. }

2.2.3limit方法

限制，给一个参数，取前几个值。

参数类型 long

  1. package com.qfedu.test3StreamMethod;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. //limit方法
  6. public class Demo3limit {
  7.     public static void main(String[] args) {
  8.         List<String> list = new ArrayList<String>();
  9.         list.add("张一");
  10.         list.add("张二三");
  11.         list.add("朱四五");
  12.         list.add("张六七");
  13.         list.add("张八九");
  14.         list.stream().limit(3).forEach((String name)->{System.out.println(name);;});
  15.         //取前三个中姓张的
  16.         list.stream()
  17.         .limit(3)
  18.         .filter((String name)->{return name.startsWith("张");})
  19.         .forEach((String name)->{System.out.println(name);;});
  20.     }
  22. }
  23. 张一
  24. 张二三
  25. 朱四五
  27. 张一
  28. 张二三

2.2.4map方法

用来映射数据的

  1. package com.qfedu.test3StreamMethod;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.Function;
  6. //map方法 映射数据   valueOf    parseInt  都可以将字符串转换为int数据
  7. public class Demo4map {
  8.     public static void main(String[] args) {
  9.         List<String> list = new ArrayList<String>();
  10.         list.add("11");
  11.         list.add("12");
  12.         list.add("13");
  13.         //将上面字符串数据转换成int类型数据
  14. //        Function<String, Integer> function = new Function<String, Integer>() {
  15. //            @Override
  16. //            public Integer apply(String t) {
  17. //                
  18. //                return Integer.parseInt(t);
  19. //            }
  20. //        };
  21. //        list.stream().map(function).forEach((Integer a)->{System.out.println(a);;});
  23.         list.stream()
  24.         .map((String t)->{return Integer.valueOf(t);})
  25.         .forEach((Integer a)->{System.out.println(a);});
  26.     }
  28. }

2.2.5skip方法

跳过前几个去执行

  1. package com.qfedu.test3StreamMethod;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.jar.Attributes.Name;
  7. //跳过前几个值，去取之后的
  8. public class Demo5skip {
  9.     public static void main(String[] args) {
  10.         List<String> list = new ArrayList<String>();
  11.         list.add("张一");
  12.         list.add("张二三");
  13.         list.add("朱四五");
  14.         list.add("张六七");
  15.         list.add("张八九");
  17.         list.stream()
  18.         .skip(3)
  19.         .forEach((String Name)->{System.out.println(Name);});
  20.     }
  22. }
  23. 张六七
  24. 张八九

2.2.6concat方法

拼接，合并两个流

  1. package com.qfedu.test3StreamMethod;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.stream.Stream;
  7. public class Demo6concat {
  8.     public static void main(String[] args) {
  9.         List<String> list = new ArrayList<String>();
  10.         list.add("张一");
  11.         list.add("张二三");
  12.         list.add("朱四五");
  13.         list.add("张六七");
  14.         list.add("张八九");
  15.         List<String> list1 = new ArrayList<String>();
  16.         list1.add("11");
  17.         list1.add("12");
  18.         list1.add("13");
  19.         //集合合并方法
  20.         list.addAll(list1);
  21.         //流合并的方法  concat是stream流的一个静态方法
  22.         Stream<String> stream = Stream.concat(list.stream(), list1.stream());
  23.         stream.forEach((String a)->{System.out.println(a);});
  24.     }
  26. }

2.3收集Stream流

toList();将流转换为list集合

toset();将流转换为set集合

  1. package com.qfedu.test4liu_jihe;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Set;
  6. import java.util.stream.Collectors;
  7. import java.util.stream.Stream;
  9. public class Demo1 {
  10.     public static void main(String[] args) {
  11.         List<String> list = new ArrayList<String>();
  12.         list.add("张一");
  13.         list.add("张二三");
  14.         list.add("朱四五");
  15.         list.add("张六七");
  16.         list.add("张八");
  17.         //过滤出姓张的，且长度为3的
  18.         Stream<String> stream = list.stream()
  19.                 .filter((String name)->{return name.startsWith("张");})
  20.                 .filter((String name)->{return name.length()==3;});
  22.         List<String> list2 = stream.collect(Collectors.toList());
  23.         System.out.println(list2);
  25.         //因为list使用流之后就关闭了
  26. //        Set<String> set = stream.collect(Collectors.toSet());
  27. //        System.out.println(set);
  29.         }
  30. }