lyloou

public class Main {
    public static void main(String[] args) {
        final int[] data1 = {1, 2, 3};
        final int[] data2 = {1, 2, 1};

        System.out.println(getOnlyOnceStatus1(data1));
        System.out.println(getOnlyOnceStatus1(data2));
    }

    /**
     * 通过set来存储，比较数量
     *
     * @param data 数组
     * @return 结果
     */
    private static String getOnlyOnceStatus1(int[] data) {

        Set<Integer> result = new HashSet<>(data.length);
        for (int datum : data) {
            if (!result.add(datum)) {
                return "NO";
            }
        }

        if (result.size() == data.length) {
            return "YES";
        }
        return "NO";
    }
}
/*
YES
NO
*/

public class Main {
    public static void main(String[] args) {
        final int[] data1 = {1, 2, 3, 3, 2, 1, 4, 6, 4};
        final int[] data2 = {1, 2, 1};

        System.out.println(xorIntArray(data1));
        System.out.println(xorIntArray(data2));
    }

    /**
     * 异或操作
     *
     * @param data 数组
     * @return 结果
     */
    private static Integer xorIntArray(int[] data) {

        if (data == null || data.length == 0) {
            return null;
        }
        if (data.length == 1) {
            return data[0];
        }
        int result = data[0];
        for (int i = 1; i < data.length; i++) {
            result ^= data[i];
        }

        return result;
    }
}
/*
6
2
*/

/**
 * 判断链表是否有环
 *
 * @author lilou
 * @since 2021/6/2
 */
public class Ring {
    public static class Node {
        private final Integer id;
        private final String name;
        private Node next;

        public Node(Integer id, String name) {
            this.id = id;
            this.name = name;
        }

        public Integer getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }

    public static void main(String[] args) {
        final Node n1 = new Node(1, "赵云");
        final Node n2 = new Node(2, "关羽");
        final Node n3 = new Node(3, "张飞");
        final Node n4 = new Node(4, "刘备");
        final Node n5 = new Node(5, "曹操");
        n1.setNext(n2);
        n2.setNext(n3);
        n3.setNext(n4);
        n4.setNext(n5);
        n5.setNext(n1);

        boolean isRing = isRing2(n1);
        System.out.println(isRing);
    }

    /**
     * 方法1：快慢指针
     *
     * @param n1 节点
     * @return 是否有环
     */
    private static boolean isRing(Node n1) {
        if (n1 == null) {
            return false;
        }

        // 慢指针
        Node slow = n1;
        // 快指针，从下一个开始
        Node fast = n1.getNext();
        while (fast != null && fast.getNext() != null) {
            if (fast == slow) {
                return true;
            }
            slow = slow.getNext();
            fast = fast.getNext().getNext();
        }

        return false;
    }

    /**
     * 方法2：
     * 1个指针原地不动，
     * 1个指针一步一步向前搜索
     *
     * @param n1 节点
     * @return 是否有环
     */
       private static boolean isRing2(Node n1) {
        if (n1 == null) {
            return false;
        }
        // 原地不动
        Node notMovePointer = n1;
        // 步长为1，向前搜索
        Node forwardPointer = n1.getNext();
        while (forwardPointer != null) {
            if (notMovePointer == forwardPointer) {
                return true;
            }
            forwardPointer = forwardPointer.getNext();
        }

        return false;
    }
}

package com.lyloou.tool.tree;

import java.util.ArrayList;
import java.util.List;


/*
 *
 * **** 示例1 ****
         1
    2          3
  4   5      6   7

 输出如下：
 1 2 4
 1 2 5
 1 3 6
 1 3 7


 * **** 示例2 ****
       1
  2        3
     5
  a = TreeNode(1)
  b = TreeNode(2)
  c = TreeNode(3)
  d = TreeNode(5)
  a.left = b
  a.right =  c
  b.right = d

 输出如下：
 ['1->2->5', '1->3']
 */
public class Solution2 {
    public static void main(String[] args) {
        test1();
        test2();
    }

    private static void test1() {
        TreeNode a = new TreeNode(1);
        TreeNode b = new TreeNode(2);
        TreeNode c = new TreeNode(3);
        TreeNode d = new TreeNode(5);
        a.left = b;
        a.right = c;
        b.right = d;
        System.out.println(binaryTreePaths(a));
    }

    private static void test2() {
        TreeNode a1 = new TreeNode(1);
        TreeNode a2 = new TreeNode(2);
        TreeNode a3 = new TreeNode(3);
        TreeNode a4 = new TreeNode(4);
        TreeNode a5 = new TreeNode(5);
        TreeNode a6 = new TreeNode(6);
        TreeNode a7 = new TreeNode(7);
        a1.left = a2;
        a1.right = a3;
        a2.left = a4;
        a2.right = a5;
        a3.left = a6;
        a3.right = a7;
        System.out.println(binaryTreePaths(a1));
    }

    /**
     * @param root the root of the binary tree
     * @return all root-to-leaf paths
     */
    private static List<String> binaryTreePaths(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        // 有几个叶子节点，就有几条路径
        if (isLeaf(root)) {
            List<String> list = new ArrayList<>();
            list.add(root.val + "");
            return list;
        }

        // 获取左子树的列表，循环向元素前面追加当前值
        final List<String> leftList = binaryTreePaths(root.left);
        for (int i = 0; i < leftList.size(); i++) {
            leftList.set(i, root.val + "->" + leftList.get(i));
        }

        // 获取右子树的列表，循环向元素前面追加当前值
        final List<String> rightList = binaryTreePaths(root.right);
        for (int i = 0; i < rightList.size(); i++) {
            rightList.set(i, root.val + "->" + rightList.get(i));
        }

        // 拼接成一个列表返回
        List<String> result = new ArrayList<>(leftList.size() + rightList.size());
        result.addAll(leftList);
        result.addAll(rightList);
        return result;
    }


    /**
     * 判断node是否为叶子节点
     *
     * @param node 节点
     * @return true 为叶子节点，
     */
    private static boolean isLeaf(TreeNode node) {
        return node.left == null && node.right == null;
    }

    static class TreeNode {
        public int val;
        public TreeNode left, right;

        public TreeNode(int val) {
            this.val = val;
            this.left = this.right = null;
        }
    }
}

import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

/**
 * 如何以并发方式在同一个流上执行多种操作
 * 参考：java8_in_action 附录C
 *
 * @author lilou
 * @since 2021/5/7
 */
public class StreamForker<T> {
    private final Stream<T> stream;
    private final Map<Object, Function<Stream<T>, ?>> forks = new HashMap<>();

    public StreamForker(Stream<T> stream) {
        this.stream = stream;
    }

    public StreamForker<T> fork(Object key, Function<Stream<T>, ?> f) {
        forks.put(key, f);
        return this;
    }

    public Results getResults() {
        ForkingStreamConsumer<T> consumer = build();
        try {
            stream.sequential().forEach(consumer);
        } finally {
            consumer.finish();
        }
        return consumer;
    }

    private ForkingStreamConsumer<T> build() {
        List<BlockingQueue<T>> queues = new ArrayList<>();
        Map<Object, Future<?>> actions = forks.entrySet()
                .stream()
                .reduce(
                        new HashMap<Object, Future<?>>(),
                        (map, e) -> {
                            map.put(e.getKey(), getOperationResult(queues, e.getValue()));
                            return map;
                        },
                        (m1, m2) -> {
                            m1.putAll(m2);
                            return m1;
                        }
                );
        return new ForkingStreamConsumer<>(queues, actions);
    }

    private Future<?> getOperationResult(List<BlockingQueue<T>> queues, Function<Stream<T>, ?> f) {
        BlockingQueue<T> queue = new LinkedBlockingQueue<>();
        queues.add(queue);
        final Spliterator<T> spliterator = new BlockingQueueSpliterator<>(queue);
        final Stream<T> source = StreamSupport.stream(spliterator, false);
        return CompletableFuture.supplyAsync(() -> f.apply(source));
    }

    public static interface Results {

        public <R> R get(Object key);
    }

    static class ForkingStreamConsumer<T> implements Consumer<T>, Results {
        static final Object END_OF_STREAM = new Object();
        private final List<BlockingQueue<T>> queues;
        private final Map<Object, Future<?>> actions;

        public ForkingStreamConsumer(List<BlockingQueue<T>> queues, Map<Object, Future<?>> actions) {
            this.queues = queues;
            this.actions = actions;
        }

        @SuppressWarnings({"unchecked", "SSBasedInspection"})
        @Override
        public <R> R get(Object key) {
            try {
                return ((Future<R>) actions.get(key)).get();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public void accept(T t) {
            queues.forEach(q -> q.add(t));
        }

        public void finish() {
            //noinspection unchecked
            accept((T) END_OF_STREAM);
        }
    }

    static class BlockingQueueSpliterator<T> implements Spliterator<T> {
        private final BlockingQueue<T> q;

        public BlockingQueueSpliterator(BlockingQueue<T> q) {
            this.q = q;
        }

        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            T t;
            while (true) {
                //noinspection SSBasedInspection
                try {
                    t = q.take();
                    break;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (t != ForkingStreamConsumer.END_OF_STREAM) {
                action.accept(t);
                return true;
            }
            return false;
        }

        @Override
        public Spliterator<T> trySplit() {
            return null;
        }

        @Override
        public long estimateSize() {
            return 0;
        }

        @Override
        public int characteristics() {
            return 0;
        }
    }
}

import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author lilou
 * @since 2021/5/7
 */
public class StreamForkerTest {
    public static void main(String[] args) {
        int[] a = new int[100];
        Arrays.fill(a, 1);
        Arrays.parallelPrefix(a, Integer::sum);

        final Stream<Integer> integerStream = Arrays.stream(a).boxed();
        final StreamForker.Results results = new StreamForker<>(integerStream)
                .fork("平均值", StreamForkerTest::average)
                .fork("求和", StreamForkerTest::sum)
                .fork("拼接", StreamForkerTest::concat)
                .getResults();

        String average = results.get("平均值");
        String sum = results.get("求和");
        String concat = results.get("拼接");

        System.out.println("平均值:" + average);
        System.out.println("求和:" + sum);
        System.out.println("拼接:" + concat);

    }

    private static String concat(Stream<Integer> stream) {
        return stream.map(String::valueOf).collect(Collectors.joining(","));
    }

    private static String sum(Stream<Integer> stream) {
        return stream.reduce(Integer::sum).map(String::valueOf).orElse("");
    }

    private static String average(Stream<Integer> stream) {
        return stream.mapToInt(Integer::intValue).summaryStatistics().getAverage() + "";
    }
}