jdk8-day2-作业

考点：方法引用

1.举例说明

静态方法引用

实例方法引用

使用对象引用方法

构造方法引用

package Java_02homework;

/**
 * @author Hlmove
 * @date 创建日期 2023/8/31 17:28
 * @Description Java_02homework
 * @Note
 */
public class P1_1 {
    //静态方法引用
    Action a = Integer::parseInt;
    //
    //实例方法引用
    Action b = String::length;
    //
    //使用对象引用方法
    String s =  "1";
    Action c = s::indexOf;
    //
    //构造方法引用
    Action1 d = int[]::new;
    interface Action{
        int action(String s);
    }
    interface Action1{
        int[] action(int s);
    }
}

考点：stream中方法的使用

1.现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用Stream流依次进行以 下若干操作步骤： (类和集合内容自己提供)

1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
5. 将两个队伍合并为一个队伍；存储到一个新集合中。

此处需要创建person对象

6. 根据姓名创建 Person 对象；存储到一个新集合中。

7. 打印整个队伍的Person对象信息。

   package Java_02homework;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.List;
   import java.util.stream.Collectors;
   import java.util.stream.Stream;
   
   /**
    * @author Hlmove
    * @date 创建日期 2023/8/31 18:01
    * @Description Java_02homework
    * @Note 现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用Stream流依次进行以 下若干操作步骤： (类和集合内容自己提供)
    * 1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
    * 2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
    * 3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
    * 4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
    * 5. 将两个队伍合并为一个队伍；存储到一个新集合中。
    * 此处需要创建person对象
    * 6. 根据姓名创建 Person 对象；存储到一个新集合中。
    * 7. 打印整个队伍的Person对象信息。
    */
   public class P2_1 {
       public static void main(String[] args) {
           //提供两个 ArrayList 集合存储队伍当中的多个成员姓名
           List<String> list1 = Arrays.asList("jack", "lucy", "tom","json","apple","ada");
           List<String> list2 = Arrays.asList("jack", "lucy", "武张","张三","张","adc");
           // 用stream流获取这两个list集合
           Stream<String> s1 = list1.stream();
           Stream<String> s2 = list2.stream();
           //1.第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
   //        ArrayList<String> collect1 = s1.filter(s -> s.length() == 3).collect(Collectors.toCollection(ArrayList::new));
   //        System.out.println("collect1 = "+collect1);
           //2.第一个队列筛选之后只要前3个人；存储到一个新集合中。
   //        Collection<String> collect2 = s1.limit(3).collect(Collectors.toCollection(ArrayList::new));
   //        System.out.println("collect2 = " + collect2);
           //3.第二个队只要姓张的成员姓名；存储到一个新集合中。
   //        ArrayList<String> collect3 = s2.filter(s -> "张".equals(s.substring(0, 1))).collect(Collectors.toCollection(ArrayList::new));
   //        System.out.println("collect3 = " + collect3);
           //4.第二个队伍筛选之后不要前2个人；存储到一个新集合中。
   //        ArrayList<String> collect4 = s2.skip(2).collect(Collectors.toCollection(ArrayList::new));
   //        System.out.println("collect4 = " + collect4);
           //5.将两个队伍合并为一个队伍；存储到一个新集合中。
           ArrayList<String> collect5 = Stream.concat(s1, s2).collect(Collectors.toCollection(ArrayList::new));
           System.out.println("collect5 = " + collect5);
           //6.根据姓名创建 Person 对象；存储到一个新集合中。
           List<Person>  list = new ArrayList<>();
           collect5.forEach(s -> list.add(new Person(s)));
           //7.将两个队伍合并为一个队伍；存储到一个新集合中。
           System.out.println(list);
       }
   
   }
   class Person{
       public  String name;
   
       public Person(String name) {
           this.name = name;
       }
   
       @Override
       public String toString() {
           return "Person{" +
                   "name='" + name + '\'' +
                   '}';
       }
   }
   

2.假设集合容器中有

("水煮鱼"),("酸菜鱼"),("麻辣鱼"),("麻婆豆腐"),("回锅肉"),("鱼香肉丝") ,("水煮肉片"),("宫保鸡丁"),("剁椒 鱼头"),("夫妻肺片")等这些菜名字符串。

运用Predicate函数式接口和Lambda表达式过滤菜名中只有三个 字符长度的菜品和统计菜品中包含“鱼”字符的菜品

package Java_02homework;

import java.util.Arrays;
import java.util.List;

/**
 * @author Hlmove
 * @date 创建日期 2023/8/31 18:25
 * @Description Java_02homework
 * @Note 运用Predicate函数式接口和Lambda表达式过滤菜名中只有三个 字符长度的菜品和统计菜品中包含“鱼”字符的菜品
 */
public class P3_1 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("水煮鱼", "酸菜鱼", "麻辣鱼",
                "麻婆豆腐", "回锅肉", "鱼香肉丝", "水煮肉片", "宫保鸡丁", "剁椒 鱼头", "夫妻肺片");
//        Predicate<String>  predicate = s -> s.contains("鱼");
        list.stream().filter(s -> s.length() == 3).forEach(s -> {
            if (s.contains("鱼")){
                System.out.println(s);
            }
        });
    }
}

3.根据提示使用stream完成以下题目

Trader raoul = new Trader("Raoul", "Cambridge");

Trader mario = new Trader("Mario","Milan");

Trader alan = new Trader("Alan","Cambridge");

Trader brian = new Trader("Brian","Cambridge");

List transactions = Arrays.asList(

new Transaction(brian, 2011, 300),

new Transaction(raoul, 2012, 1000),

new Transaction(raoul, 2011, 400),

new Transaction(mario, 2012, 710),

new Transaction(mario, 2012, 700),

new Transaction(alan, 2012, 950)

);1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。

(2) 交易员都在哪些不同的城市工作过？

(3) 查找所有来自于剑桥的交易员，并按姓名排序。

(4) 返回所有交易员的姓名字符串，按字母顺序排序。

(5) 有没有交易员是在米兰工作的？

(6) 打印生活在剑桥的交易员的所有交易额。

(7) 所有交易中，最高的交易额是多少？

(8) 找到交易额最小的交易。

package Java_02homework;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author Hlmove
 * @date 创建日期 2023/8/31 18:48
 * @Description Java_02homework
 * @Note 1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
 * (2) 交易员都在哪些不同的城市工作过？
 * (3) 查找所有来自于剑桥的交易员，并按姓名排序。
 * (4) 返回所有交易员的姓名字符串，按字母顺序排序。
 * (5) 有没有交易员是在米兰工作的？
 * (6) 打印生活在剑桥的交易员的所有交易额。
 * (7) 所有交易中，最高的交易额是多少？
 * (8) 找到交易额最小的交易。
 */
public class P4_1 {
    public static void main(String[] args) {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");
        List<Transaction> transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );
        Stream<Transaction> s = transactions.stream();
        List<String> list = new ArrayList<>();
//1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。

//        ArrayList<Transaction> collect = s.filter(e -> e.year == 2011).sorted((o1, o2) -> o1.amount-o2.amount).collect(Collectors.toCollection(ArrayList::new));
//        System.out.println("collect = " + collect);

// * (2) 交易员都在哪些不同的城市工作过？


//        s.forEach(m-> {
//            if (!list.contains(m.trader.city)){
//                list.add(m.trader.city);
//                System.out.println("s = "+m.trader.city);
//            }
//        });

// * (3) 查找所有来自于剑桥的交易员，并按姓名排序。

//        s.filter(transaction -> "Cambridge".equals(transaction.trader.city))
//                .sorted((o1, o2) -> o1.trader.name.compareTo(o2.trader.name))
//                .forEach(System.out::println);

// * (4) 返回所有交易员的姓名字符串，按字母顺序排序。

//        s.sorted(Comparator.comparing(o -> o.trader.name))
//                .forEach(transaction -> {
//                    if (!list.contains(transaction.trader.name)) {
//                        list.add(transaction.trader.name);
//                        System.out.println(transaction.trader.name);
//                    }
//                });

// * (5) 有没有交易员是在米兰工作的？

//        s.filter(e-> "Milan".equals(e.trader.city)).forEach(transaction -> {
//            if (!list.contains(transaction.trader.name)){
//                list.add(transaction.trader.name);
//                System.out.println(transaction.trader.name);
//            }
//        });

// * (6) 打印生活在剑桥的交易员的所有交易额。

//        s.filter(transaction -> "Cambridge".equals(transaction.trader.city))
//                .forEach(transaction -> System.out.println(transaction.amount));
//
// * (7) 所有交易中，最高的交易额是多少？
//
//        s.max(Comparator.comparingInt(o -> o.amount)).ifPresent(transaction -> System.out.println(transaction.amount));
//
// * (8) 找到交易额最小的交易。
        s.min(Comparator.comparingInt(o -> o.amount)).ifPresent(transaction -> System.out.println(transaction.amount));
    }

    static class Trader {
        public String name;
        public String city;

        public Trader(String name, String city) {
            this.name = name;
            this.city = city;
        }

        @Override
        public String toString() {
            return "Trader{" +
                    "name='" + name + '\'' +
                    ", city='" + city + '\'' +
                    '}';
        }
    }

    static class Transaction {
        public Trader trader;
        public int year;
        public int amount;

        public Transaction(Trader trader, int year, int amount) {
            this.trader = trader;
            this.year = year;
            this.amount = amount;
        }

        @Override
        public String toString() {
            return "Transaction{" +
                    "trader=" + trader +
                    ", year=" + year +
                    ", amount=" + amount +
                    '}';
        }
    }
}

本栏目推荐文章
• RDD的五大特性
• nginx启用HTTP2特性
• 面向对象的三大特性及派生和组合
• java jdk @Resource注入
• jdk 1.8 stream
• linux安装jdk 并配置环境变量
• jdk jre 关键字 字面量 特殊字符 变量 进制
• JDK版本升级到17后，GeoServer的图层无法图层预览
• h5和css3有什么新特性
• html5和css3有什么新特性

特性 JDK8 JDK语法jdk特性jdk8 特性jdk8 jdk jdk jdk8-jdk特性jdk8 特性jdk8 jdk 17 jdk特性jdk8 17 一览jdk jdk8-jdk特性 jdk特性 版本jdk8 特性jdk8 jdk 18 特性jdk8 jdk amp jdk8