LeetCode 1169. 查询无效交易

题目链接：https://leetcode-cn.com/problems/invalid-transactions/

如果出现下述两种情况，交易 可能无效：

交易金额超过 ¥1000
或者，它和另一个城市中同名的另一笔交易相隔不超过 60 分钟（包含 60 分钟整）
每个交易字符串 transactions[i] 由一些用逗号分隔的值组成，这些值分别表示交易的名称，时间（以分钟计），金额以及城市。

给你一份交易清单 transactions，返回可能无效的交易列表。你可以按任何顺序返回答案。

提示：

transactions.length <= 1000
每笔交易 transactions[i] 按 "{name},{time},{amount},{city}" 的格式进行记录
每个交易名称 {name} 和城市 {city} 都由小写英文字母组成，长度在 1 到 10 之间
每个交易时间 {time} 由一些数字组成，表示一个 0 到 1000 之间的整数
每笔交易金额 {amount} 由一些数字组成，表示一个 0 到 2000 之间的整数

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/invalid-transactions
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解：

用一个内部类来描述一个交易的信息，将所有交易记录加入到数组中，遍历数组判断记录是否有效，时间复杂度：O(n^2)

    private class Trade {
        private String s;
        private String name;
        private int time;
        private int money;
        private String city;
        private boolean valid;

        public Trade(String s, String name, int time, int money, String city) {
            super();
            this.s = s;
            this.name = name;
            this.time = time;
            this.money = money;
            this.city = city;
            this.valid = this.money > 1000 ? false : true;
        }

        @Override
        public String toString() {
            return s;
        }

        private boolean invalid(Trade o) {
            return this.name.equals(o.name) && !this.city.equals(o.city)
                    && Math.abs(this.time - o.time) <= 60;
        }
    }

    public List<String> invalidTransactions(String[] transactions) {
        List<String> result = new ArrayList<String>();
        List<Trade> trades = new ArrayList<Trade>();
//        1.使用Pattern和Matcher(比split慢)

//        Pattern p = Pattern.compile("([a-z]{1,10}),(\\d{1,4}),(\\d{1,4}),([a-z]{1,10})");
        for (String s : transactions) {
//            Matcher m = p.matcher(s);
//            if (m.find()) {
//                Trade t = new Trade(s, m.group(1), Integer.valueOf(m.group(2)),
//                        Integer.valueOf(m.group(3)), m.group(4));
//                trades.add(t);
//            }

//            valueOf会调用parseInt得到int值封装成Integer对象，而parseInt则是返回int值

//            2.使用String的split方法
            String[] split = s.split(",");
            Trade t = new Trade(s, split[0], Integer.parseInt(split[1]), Integer.parseInt(split[2]),
                    split[3]);
            trades.add(t);
        }
        for (int i = 0; i < trades.size(); i++) {
            Trade iTrade = trades.get(i);
            if (!iTrade.valid) {
                continue;
            }
            for (int j = 0; j < trades.size(); j++) {
                if (i == j) {
                    continue;
                }
                Trade jTrade = trades.get(j);
                if (iTrade.invalid(jTrade)) {
                    // 外部类能访问内部类的私有属性
                    iTrade.valid = false;
                    jTrade.valid = false;
                }
            }
        }
        for (Trade t : trades) {
            if (!t.valid) {
                result.add(t.toString());
            }
        }
        return result;
    }

　　

通过这题，我尝试了使用Pattern和Matcher，知道了valueOf和parseInt的区别，发现外部类可以访问内部类的私有属性，以前从来没研究过。