问题总结

/**
 * 给定任意一个两个字符串：他是一个二进制的数字
 *
 * array[0] = "1101";
 * array[1] = "1100";
 *
 * 角标为偶数不反转，角标为奇数就将字符串反转。二进制相加得到一个字符串
 *
 */
 public class Result1 {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("1101","1100");
        String s = Result1.calculateBinaryNumbers(list);
        System.out.println(s);

    }

    public static String calculateBinaryNumbers(List<String> array) {

        List<String> list = new ArrayList<>();
        for (int i = 0; i < array.size(); i++) {
            if(i % 2 == 0){
                list.add(array.get(i));
            }else {
                String str = array.get(i);
                String restr = new StringBuilder(str).reverse().toString();
                list.add(restr);
            }
        }
        long sum = list.stream().mapToLong(s -> Long.parseLong(s, 2)).sum();
        return Long.toBinaryString(sum);
    }
}

/**
 * Shanghai->Beijing->Tianjin->Changchun
 * Hangzhou->Shanghai->Suzhou->Wuxi->Nanjing
 * Dalian->Qingdao->Suzhou
 * Kunshan->Shanghai->Hangzhou->Lingbo
 *
 * 找出出现次数最多的城市：
 * 1、stream流中map和flatmap的使用。
 * 2、Collectors中的groupingBy()方法的使用
 * 3、比较器的使用：Comparator
 * 4、Map中的迭代器的使用
 */
public class Result2 {

    public static void main(String[] args) {

        List<String> cities = Arrays.asList("Shanghai->Beijing->Tianjin->Hangzhou",
                "Hangzhou->Shanghai->Suzhou->Wuxi->Nanjing",
                "Dalian->Qingdao->Suzhou",
                "Kunshan->Shanghai->Hangzhou->Lingbo");



        System.out.println(Result2.getFavoriteCities(cities));
        System.out.println("-------------------------------");
        System.out.println(Result2.getFaviorateCities(cities));
    }



    public static String getFavoriteCities(List<String> userCities) {

        Map<String, Long> map = userCities.stream().flatMap(city -> Arrays.stream(city.split("->"))).collect
                (Collectors.groupingBy(p -> p, Collectors.counting()));


        Collection<Long> values = map.values();

        long max = values.stream().max(Comparator.comparingInt(Long::intValue)).get();

        StringBuilder sb = new StringBuilder();

        Iterator<Map.Entry<String, Long>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()){

            Map.Entry<String, Long> next = iterator.next();

            if (next.getValue() == max){
                sb.append(next.getKey()).append(",");
            }
        }
            return sb.substring(0,sb.length()-1)+" "+max;

    }

    public static String getFaviorateCities(List<String> visitedCities) {
        final Map<String, Integer> citiesVisited = new HashMap<>();
        visitedCities.stream().flatMap(item -> Arrays.stream(item.split("->"))).forEach(city -> {
            if (citiesVisited.containsKey(city)) {
                citiesVisited.put(city, citiesVisited.get(city).intValue() + 1);
            } else {
                citiesVisited.put(city, 1);
            }
        });
        StringBuilder sb = new StringBuilder();
        AtomicInteger max = new AtomicInteger();

        citiesVisited.keySet().stream().forEach(city -> {

            if (max.intValue() == citiesVisited.get(city)) {
                sb.append("," + city);
                return;
            }
            if (max.intValue() > citiesVisited.get(city)) {
                return;
            }
            max.set(citiesVisited.get(city));
            sb.setLength(0);
            sb.append(city);
        });
        sb.append(", "+max.intValue());
        return sb.toString();
    }

}