常用的后端工具集

偏执的太偏执、 2023-02-18 08:01 51阅读 0赞

## 一、LinkedBlockingQueue的增强版 ##

import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.concurrent.LinkedBlockingQueue;
    
    
    /** * LinkedBlockingQueue的增强版（队伍内未消费的元素保证是不重复的） */
    public class BlockingUniqueQueue<E> extends LinkedBlockingQueue<E> { 
    
        private static final long serialVersionUID = 8351632564634804122L;
    
        private Set<E> datas = new HashSet<>();
    
        @Override
        public boolean contains(Object o) { 
            return datas.contains(o);
        }
    
        @Override
        public boolean containsAll(Collection<?> c) { 
            return datas.containsAll(c);
        }
    
        @Override
        public E take() { 
            //该方法千万不要用 synchronized 修饰，不然一旦take()方法被阻塞了，另外一条线程就永远不能add了
            E head = null;
            try{ 
                head = super.take();
            }catch(Exception e){ 
    
            }
            datas.remove(head);
            return head;
    
        }
    
        @Override
        public synchronized boolean add(E e) { 
            if (contains(e)) { 
                return false;
            }
            datas.add(e);
            return super.add(e);
        }
    
        @Override
        public synchronized boolean addAll(Collection<? extends E> c) { 
            boolean modified = false;
            for (E e : c) { 
                if (add(e)) { 
                    modified = true;
                }
            }
            return modified;
        }
    
        @Override
        public synchronized boolean remove(Object o) { 
            datas.remove(o);
            return super.remove(o);
        }
    
        @Override
        public synchronized boolean removeAll(Collection<?> c) { 
            for (Object e:c) { 
                datas.remove(e);
            }
            return super.removeAll(c);
        }
    
        @Override
        public Iterator<E> iterator() { 
            return new Itr(super.iterator());
        }
    
        private class Itr implements Iterator<E> { 
    
            private Iterator<E> it;
    
            private E curr;
    
            Itr(Iterator<E> it) { 
                this.it = it;
            }
    
            @Override
            public boolean hasNext() { 
                return this.it.hasNext();
            }
    
            @Override
            public E next() { 
                this.curr = this.it.next();
                return this.curr;
            }
    
            @Override
            public void remove() { 
                synchronized(BlockingUniqueQueue.this) { 
                    this.it.remove();
                    BlockingUniqueQueue.this.datas.remove(this.curr);
                }
            }
        }
    
    }

## 二、Jvm工具类 ##

import java.io.OutputStream;
    import java.lang.management.*;
    import java.nio.charset.StandardCharsets;
    
    /** * JvmUtils */
    public class JvmUtils { 
    
        /** * The java stack * * @param stream {@link OutputStream} * @throws Exception exception */
        public static void jStack(OutputStream stream) throws Exception { 
            ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
            for (ThreadInfo threadInfo : threadMxBean.dumpAllThreads(true, true)) { 
                stream.write(getThreadDumpString(threadInfo).getBytes(StandardCharsets.UTF_8));
            }
        }
    
        private static String getThreadDumpString(ThreadInfo threadInfo) { 
            StringBuilder sb = new StringBuilder("\"" + threadInfo.getThreadName() + "\""
                    + " Id=" + threadInfo.getThreadId() + " " + threadInfo.getThreadState());
            if (threadInfo.getLockName() != null) { 
                sb.append(" on ").append(threadInfo.getLockName());
            }
            if (threadInfo.getLockOwnerName() != null) { 
                sb.append(" owned by \"").append(threadInfo.getLockOwnerName())
                        .append("\" Id=").append(threadInfo.getLockOwnerId());
            }
            if (threadInfo.isSuspended()) { 
                sb.append(" (suspended)");
            }
            if (threadInfo.isInNative()) { 
                sb.append(" (in native)");
            }
            sb.append('\n');
            int i = 0;
    
            StackTraceElement[] stackTrace = threadInfo.getStackTrace();
            MonitorInfo[] lockedMonitors = threadInfo.getLockedMonitors();
            for (; i < stackTrace.length && i < 32; i++) { 
                StackTraceElement ste = stackTrace[i];
                sb.append("\tat ").append(ste.toString());
                sb.append('\n');
                if (i == 0 && threadInfo.getLockInfo() != null) { 
                    Thread.State ts = threadInfo.getThreadState();
                    switch (ts) { 
                        case BLOCKED:
                            sb.append("\t- blocked on ").append(threadInfo.getLockInfo());
                            sb.append('\n');
                            break;
                        case WAITING:
                            sb.append("\t- waiting on ").append(threadInfo.getLockInfo());
                            sb.append('\n');
                            break;
                        case TIMED_WAITING:
                            sb.append("\t- waiting on ").append(threadInfo.getLockInfo());
                            sb.append('\n');
                            break;
                        default:
                    }
                }
    
                for (MonitorInfo mi : lockedMonitors) { 
                    if (mi.getLockedStackDepth() == i) { 
                        sb.append("\t- locked ").append(mi);
                        sb.append('\n');
                    }
                }
            }
            if (i < stackTrace.length) { 
                sb.append("\t...");
                sb.append('\n');
            }
    
            LockInfo[] locks = threadInfo.getLockedSynchronizers();
            if (locks.length > 0) { 
                sb.append("\n\tNumber of locked synchronizers = ").append(locks.length);
                sb.append('\n');
                for (LockInfo li : locks) { 
                    sb.append("\t- ").append(li);
                    sb.append('\n');
                }
            }
            sb.append('\n');
    
            return sb.toString();
        }
    
    }

## 三、基于LinkedHashMap实现的一个有限队列缓存 有时间及大小的限制 ##

/** * 基于LinkedHashMap实现的一个有限队列缓存 有时间及大小的限制 * aliveTime参数为true时为模拟lru规则 */
    public class LimitedCacheMap<K, V> { 
    
        private LinkedHashMap<K, Element<V>> data;
    
        /** * 缓存最大容量，添加新元素时，若当前长度超过容量，则会删除队首元素 */
        private int capacity;
    
        /** 生存时长（毫秒数） */
        private long aliveTime;
    
        /** * 是否使用lru规则，为true时表示当元素被查找命中时被重放到队尾 * {@link LinkedHashMap#accessOrder}} */
        private boolean useLru;
    
        /** 读写锁 */
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
        private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
    
        public LimitedCacheMap(int capacity, long aliveTime) { 
            this(capacity, aliveTime, Boolean.FALSE);
        }
    
        public LimitedCacheMap(int capacity, long aliveTime, boolean useLru) { 
            this.capacity = capacity;
            this.aliveTime = aliveTime;
            this.useLru = useLru;
            this.data = new LinkedHashMap<K, Element<V>>(capacity, 1.0f, useLru) { 
                private static final long serialVersionUID = 1L;
    
                @Override
                protected boolean removeEldestEntry(Map.Entry<K, Element<V>> eldest) { 
                    if (size() > capacity) { 
                        return true;
                    }
                    long eleAliveTime = System.currentTimeMillis() - eldest.getValue().bornTime;
                    return (eleAliveTime > aliveTime);
                }
            };
        }
    
        public V put(K key, V value) { 
            V preValue = null;
            Element<V> newValue = new Element<V>(value);
    
            readLock.lock();
            try { 
                if (data.containsKey(key)) { 
                    preValue = data.get(key).value;
                }
                data.put(key, newValue);
                return preValue;
            } finally { 
                readLock.unlock();
            }
        }
    
        public V get(K key) { 
            // 当使用lru，元素重放回队尾涉及到写操作，所以用写锁
            Lock lock = this.useLru ? this.writeLock : this.readLock;
            lock.lock();
            Element<V> target = null;
            try { 
                target = this.data.get(key);
                if (target == null) { 
                    return null;
                }
            } finally { 
                lock.unlock();
            }
            long eleAlive = System.currentTimeMillis() - target.bornTime;
            if (eleAlive < aliveTime) { 
                return target.value;
            }
            remove(key);
            return null;
        }
    
        public int size() { 
            this.readLock.lock();
            try { 
                return this.data.size();
            } finally { 
                this.readLock.unlock();
            }
        }
    
        public void remove(K key) { 
            this.writeLock.lock();
            try { 
                this.data.remove(key);
            } finally { 
                this.writeLock.unlock();
            }
        }
    
        public void clear() { 
            this.writeLock.lock();
            try { 
                this.data.clear();
            } finally { 
                this.writeLock.unlock();
            }
        }
    
        @Override
        public String toString() { 
            return "LinkedCacheMap{data=" + data + ", capacity=" + capacity + ", aliveTime=" + aliveTime + ", useLru="
                    + useLru + "}";
        }
    
        @SuppressWarnings("hiding")
        class Element<V> { 
            V value;
            /** 元素添加时的时间戳 */
            long bornTime;
    
            Element(V v) { 
                this.value = v;
                this.bornTime = System.currentTimeMillis();
            }
    
            @Override
            public String toString() { 
                return "Element{" +
                        "value=" + value +
                        ", bornTime=" + bornTime +
                        '}';
            }
        }
    
    }

## 四、基于Lru算法的HashMap ##

import java.util.LinkedHashMap;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    
    /** * LruHashMap is an extension of Java's HashMap, which has a bounded size(); * When it reaches that size, each time a new element is added, the least recently used (LRU) entry is removed. * Java makes it very easy to implement LruHashMap - all its functionality is already available from LinkedHashMap, * and we just need to configure that properly. * Note that LruHashMap is thread safe */
    public class LruHashMap<K, V> extends LinkedHashMap<K, V> { 
    
        private static final long serialVersionUID = -5167631809472116969L;
    
        private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
        private static final int DEFAULT_MAX_CAPACITY = 1000;
        private final Lock lock = new ReentrantLock();
        private volatile int maxCapacity;
    
        public LruHashMap() { 
            this(DEFAULT_MAX_CAPACITY);
        }
    
        public LruHashMap(int maxCapacity) { 
            super(16, DEFAULT_LOAD_FACTOR, true);
            this.maxCapacity = maxCapacity;
        }
    
        @Override
        protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) { 
            return size() > maxCapacity;
        }
    
        @Override
        public boolean containsKey(Object key) { 
            try { 
                lock.lock();
                return super.containsKey(key);
            } finally { 
                lock.unlock();
            }
        }
    
        @Override
        public V get(Object key) { 
            try { 
                lock.lock();
                return super.get(key);
            } finally { 
                lock.unlock();
            }
        }
    
        @Override
        public V put(K key, V value) { 
            try { 
                lock.lock();
                return super.put(key, value);
            } finally { 
                lock.unlock();
            }
        }
    
        @Override
        public V remove(Object key) { 
            try { 
                lock.lock();
                return super.remove(key);
            } finally { 
                lock.unlock();
            }
        }
    
        @Override
        public int size() { 
            try { 
                lock.lock();
                return super.size();
            } finally { 
                lock.unlock();
            }
        }
    
        @Override
        public void clear() { 
            try { 
                lock.lock();
                super.clear();
            } finally { 
                lock.unlock();
            }
        }
    
        public int getMaxCapacity() { 
            return maxCapacity;
        }
    
        public void setMaxCapacity(int maxCapacity) { 
            this.maxCapacity = maxCapacity;
        }
    
    }

package com.xxxx.faceadd.jetcache;
    
    import com.google.common.collect.Lists;
    
    import java.util.ArrayDeque;
    import java.util.Deque;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LRUCache<K, V> { 
    
        private final int limit;
        private final Map<K, V> cache;
        private final Deque<K> deque;
        private final ReentrantLock reentrantLock = new ReentrantLock();
        private static final int DEFAULT_CAPACITY = 16;
        private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
        public LRUCache(int limit) { 
            this.limit = limit;
            deque = new ArrayDeque<>(limit);
            cache = new ConcurrentHashMap<>(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR);
        }
        public LRUCache(int limit, int capacity, float loadFactor) { 
            this.limit = limit;
            deque = new ArrayDeque<>(limit);
            cache = new ConcurrentHashMap<>(capacity, loadFactor);
        }
        public void put(K key, V value) { 
            V v = cache.get(key);
            reentrantLock.lock();
            try { 
                if(v == null){ 
                    cache.put(key, value);
                    deque.removeFirstOccurrence(key);
                    deque.addFirst(key);
                } else { 
                    deque.removeFirstOccurrence(key);
                    deque.addFirst(key);
                }
                if(size() > limit){ 
                    K keys = deque.removeLast();
                    if(keys != null){ 
                        cache.remove(keys);
                    }
                }
            }finally { 
                reentrantLock.unlock();
            }
        }
        public V get(K key) { 
            V v = cache.get(key);
            if(v != null){ 
                reentrantLock.lock();
                try { 
                    deque.removeFirstOccurrence(key);
                    deque.addFirst(key);
                } finally { 
                    reentrantLock.unlock();
                }
            }
            return v;
        }
    
        public int size() { 
            return cache.size();
        }
    
        
        @Override
        public String toString() { 
            List<String> values = Lists.newArrayListWithExpectedSize(limit);
            reentrantLock.lock();
            try { 
                for (K k : this.deque) { 
                     V v = cache.get(k);
                     values.add(k.toString() + " -> " + v.toString());
                }
            } finally { 
                reentrantLock.unlock();
            }
            return values.toString();
        }
    }

## 五、网络相关工具类 ##

import lombok.extern.slf4j.Slf4j;
    
    import java.io.IOException;
    import java.lang.management.ManagementFactory;
    import java.net.*;
    import java.util.Enumeration;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.Random;
    import java.util.regex.Pattern;
    
    /** * NetUtils */
    @Slf4j
    public class NetUtils { 
    
        public static final String LOCALHOST = "127.0.0.1";
        public static final String ANY_HOST = "0.0.0.0";
        private static final int RND_PORT_START = 30000;
        private static final int RND_PORT_RANGE = 10000;
    
        private static final Random RANDOM = new Random(System.currentTimeMillis());
        private static final int MIN_PORT = 0;
        private static final int MAX_PORT = 65535;
        private static final Pattern ADDRESS_PATTERN = Pattern.compile("^\\d{1,3}(\\.\\d{1,3}){3}\\:\\d{1,5}$");
        private static final Pattern LOCAL_IP_PATTERN = Pattern.compile("127(\\.\\d{1,3}){3}$");
        private static final Pattern IP_PATTERN = Pattern.compile("\\d{1,3}(\\.\\d{1,3}){3,5}$");
        private static final Map<String, String> HOST_NAME_CACHE = new LinkedHashMap<>();
        private static volatile InetAddress LOCAL_ADDRESS = null;
        private static volatile String PROCESS_ID = null;
    
        public static int getAvailablePort() { 
            try (ServerSocket ss = new ServerSocket()) { 
                ss.bind(null);
                return ss.getLocalPort();
            } catch (IOException e) { 
                return RND_PORT_START + RANDOM.nextInt(RND_PORT_RANGE);
            }
        }
    
        public static int getAvailablePort(int port) { 
            if (port <= 0) { 
                return getAvailablePort();
            }
            for (int i = port; i < MAX_PORT; i++) { 
                try (ServerSocket ss = new ServerSocket(i)) { 
                    return i;
                } catch (IOException e) { 
                    // continue
                }
            }
            return port;
        }
    
        public static boolean isInvalidPort(int port) { 
            return port <= MIN_PORT || port > MAX_PORT;
        }
    
        public static boolean isValidAddress(String address) { 
            return ADDRESS_PATTERN.matcher(address).matches();
        }
    
        public static boolean isLocalHost(String host) { 
            return host != null
                    && (LOCAL_IP_PATTERN.matcher(host).matches()
                    || "localhost".equalsIgnoreCase(host));
        }
    
        public static boolean isAnyHost(String host) { 
            return "0.0.0.0".equals(host);
        }
    
        public static boolean isInvalidLocalHost(String host) { 
            return host == null
                    || host.length() == 0
                    || "localhost".equalsIgnoreCase(host)
                    || "0.0.0.0".equals(host)
                    || (LOCAL_IP_PATTERN.matcher(host).matches());
        }
    
        public static boolean isValidLocalHost(String host) { 
            return !isInvalidLocalHost(host);
        }
    
        public static InetSocketAddress getLocalSocketAddress(String host, int port) { 
            return isInvalidLocalHost(host) ?
                    new InetSocketAddress(port) : new InetSocketAddress(host, port);
        }
    
        private static boolean isValidAddress(InetAddress address) { 
            if (address == null || address.isLoopbackAddress()) { 
                return false;
            }
            String name = address.getHostAddress();
            return (name != null
                    && !ANY_HOST.equals(name)
                    && !LOCALHOST.equals(name)
                    && IP_PATTERN.matcher(name).matches());
        }
    
        public static String getLocalHost() { 
            InetAddress address = getLocalAddress();
            return address == null ? LOCALHOST : address.getHostAddress();
        }
    
        /** * Find first valid IP from local network card * * @return first valid local IP */
        public static InetAddress getLocalAddress() { 
            if (LOCAL_ADDRESS != null) { 
                return LOCAL_ADDRESS;
            }
            InetAddress localAddress = getLocalAddress0();
            LOCAL_ADDRESS = localAddress;
            return localAddress;
        }
    
        private static InetAddress getLocalAddress0() { 
            InetAddress localAddress = null;
            try { 
                localAddress = InetAddress.getLocalHost();
                if (isValidAddress(localAddress)) { 
                    return localAddress;
                }
            } catch (Throwable e) { 
                log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
            }
    
            try { 
                Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
                if (interfaces != null) { 
                    while (interfaces.hasMoreElements()) { 
                        try { 
                            NetworkInterface network = interfaces.nextElement();
                            Enumeration<InetAddress> addresses = network.getInetAddresses();
                            while (addresses.hasMoreElements()) { 
                                try { 
                                    InetAddress address = addresses.nextElement();
                                    if (isValidAddress(address)) { 
                                        return address;
                                    }
                                } catch (Throwable e) { 
                                    log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
                                }
                            }
                        } catch (Throwable e) { 
                            log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
                        }
                    }
                }
            } catch (Throwable e) { 
                log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
            }
    
            log.error("Could not get local host ip address, will use 127.0.0.1 instead.");
            return localAddress;
        }
    
        public static String getHostName(String address) { 
            try { 
                int i = address.indexOf(':');
                if (i > -1) { 
                    address = address.substring(0, i);
                }
                String hostname = HOST_NAME_CACHE.get(address);
                if (hostname != null && hostname.length() > 0) { 
                    return hostname;
                }
                InetAddress inetAddress = InetAddress.getByName(address);
                if (inetAddress != null) { 
                    hostname = inetAddress.getHostName();
                    HOST_NAME_CACHE.put(address, hostname);
                    return hostname;
                }
            } catch (Throwable e) { 
                // ignore
            }
    
            return address;
        }
    
        public static String getIpByHost(String hostName) { 
            try { 
                return InetAddress.getByName(hostName).getHostAddress();
            } catch (UnknownHostException e) { 
                return hostName;
            }
        }
    
        public static String toAddressString(InetSocketAddress address) { 
            return address.getAddress().getHostAddress() + ":" + address.getPort();
        }
    
        public static InetSocketAddress toAddress(String address) { 
            int i = address.indexOf(':');
            String host;
            int port;
            if (i > -1) { 
                host = address.substring(0, i);
                port = Integer.parseInt(address.substring(i + 1));
            } else { 
                host = address;
                port = 0;
            }
    
            return new InetSocketAddress(host, port);
        }
    
        public static String getProcessId() { 
            if (PROCESS_ID != null) { 
                return PROCESS_ID;
            }
    
            return PROCESS_ID = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
        }
    
    }

## 六、防sql注入参数校验 ##

import lombok.extern.slf4j.Slf4j;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /** * 防sql注入参数校验 * */
    @Slf4j
    public class ParamCheck { 
    
        static String reg = "(?:')|(?:--)|(/\\*(?:.|[\\n\\r])*?\\*/)|"
    
                + "(\\b(select|update|and|or|delete|insert|trancate|char|into|substr|ascii|declare|exec|count|master|into|drop|execute)\\b)";
    
    
        /** * 表示忽略大小写 */
        static Pattern sqlPattern = Pattern.compile(reg, Pattern.CASE_INSENSITIVE);
    
    
    
        /*************************************************************************** * 参数校验 * @param str ep: "or 1=1" */
        public static boolean isSqlValid(String str) { 
            Matcher matcher = sqlPattern.matcher(str);
            if (matcher.find()) { 
                //获取非法字符：or
                log.info("参数存在非法字符，请确认："+matcher.group());
                return false;
            }
            return true;
        }
    
    }

## 七、对象池 ##

import java.util.concurrent.LinkedBlockingQueue;
    
    
    public class SimplyObjectPool<E extends MemoryObject> { 
    
        private int capacity;
    
        private LinkedBlockingQueue<E> queue = new LinkedBlockingQueue<>();
    
        public SimplyObjectPool(int capacity) { 
            this.capacity = capacity;
        }
    
        @SuppressWarnings("unchecked")
        public E borrowObject(Class<? extends MemoryObject> prototype) throws InstantiationException, IllegalAccessException { 
            E object = queue.poll();
            if (object != null) { 
                return object;
            }
            return (E) prototype.newInstance();
        }
    
        public void returnObject(E object) { 
            if (this.queue.size() < capacity) { 
                object.release();
                this.queue.offer(object);
            }
        }
    
    
    }
    
    
    public interface MemoryObject { 
    
    	/** * 释放相关引用 */
    	void release();
    }

## 八、流处理工具类 ##

import com.google.common.base.Charsets;
    import com.google.common.io.CharStreams;
    import lombok.extern.slf4j.Slf4j;
    
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    /** * Stream Utils */
    @Slf4j
    public class StreamUtils { 
    
        public static String loadScript(String name) { 
            try { 
                return CharStreams.toString(new InputStreamReader(
                        StreamUtils.class.getResourceAsStream(name), Charsets.UTF_8));
            } catch (IOException e) { 
                log.error(e.getMessage(), e);
                return null;
            }
        }
    
    }

## 九、list集合转String ##

import com.google.common.base.Joiner;
    import java.util.List;
    
    public class StringUtils { 
    
        /** * list 转 String * @param list * @return */
        public static String listToJoiner(List<String> list) { 
            return Joiner.on(",").join(list);
        }
    
        /** * list 转 String * @param list * @return */
        public static String listToString(List<String> list) { 
            return String.join(",", list);
        }
    
    
    }

## 十、利用ScheduledExecutorService实现高并发场景下System.currentTimeMillis()的性能问题的优化 ##

import java.sql.Timestamp;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.ScheduledThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicLong;
    
    /** * ClockUtils * <p> * 利用ScheduledExecutorService实现高并发场景下System.currentTimeMillis()的性能问题的优化. */
    public class SystemClock { 
    
        private static AtomicLong nowTime;
        private static volatile boolean started = false;
    
        /** * The get string current time * * @return string time */
        public static String currentTimeMillisStr() { 
            return new Timestamp(currentTimeMillis()).toString();
        }
    
        /** * The get current time milliseconds * * @return long time */
        public static long currentTimeMillis() { 
            if (!started) { 
                synchronized (SystemClock.class) { 
                    if (!started) { 
                        nowTime = new AtomicLong(System.currentTimeMillis());
                        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(
                                1, r -> { 
                            Thread thread = new Thread(r, "system-clock");
                            thread.setDaemon(true);
                            return thread;
                        });
                        executorService.scheduleAtFixedRate(() ->
                                nowTime.set(System.currentTimeMillis()), 1, 1, TimeUnit.MILLISECONDS);
                        Runtime.getRuntime().addShutdownHook(new Thread(executorService::shutdown));
                        started = true;
                    }
                }
            }
            return nowTime.get();
        }
    }

## 十一、获取系统内存与版本等工具类 ##

import com.sun.management.OperatingSystemMXBean;
    import lombok.Data;
    import lombok.ToString;
    import lombok.extern.slf4j.Slf4j;
    
    import javax.management.MBeanServer;
    import javax.management.ObjectName;
    import java.io.File;
    import java.io.Serializable;
    import java.lang.management.GarbageCollectorMXBean;
    import java.lang.management.ManagementFactory;
    import java.math.BigDecimal;
    import java.net.NetworkInterface;
    import java.util.ArrayList;
    import java.util.Enumeration;
    import java.util.List;
    
    /** * SystemUtils * <p> * 1.EnvironmentInfo * 2.MemoryInfo * 3.CpuLoadInfo * 4.DiskInfo * 5.GarbageCollectorInfo */
    @Slf4j
    public class SystemUtils { 
    
        /** * The collect * * @return {@link MetricCollect} */
        public static MetricCollect collect() { 
            MetricCollect metricCollect = new MetricCollect();
            metricCollect.setMemoryInfo(SystemUtils.getMemory());
            metricCollect.setCpuLoadInfo(SystemUtils.getCpuLoadInfo());
            metricCollect.setDiskInfo(SystemUtils.getDiskInfo());
            metricCollect.setGarbageCollectorInfos(SystemUtils.getGarbageCollectorInfo());
            return metricCollect;
        }
    
        @Data
        public static class MetricCollect implements Serializable { 
            private static final long serialVersionUID = 3465584618686630943L;
            private SystemUtils.MemoryInfo memoryInfo;
            private SystemUtils.CpuLoadInfo cpuLoadInfo;
            private List<DiskInfo> diskInfo;
            private List<GarbageCollectorInfo> garbageCollectorInfos;
        }
    
        /** * The get environment info * * @return {@link EnvironmentInfo} */
        public static EnvironmentInfo getEnvironment() { 
            EnvironmentInfo info = new EnvironmentInfo();
            info.setOsName(System.getProperty("os.name"));
            info.setOsVersion(System.getProperty("os.version"));
            info.setOsArch(System.getProperty("os.arch"));
            info.setJvmName(System.getProperty("java.vm.name"));
            info.setJvmVersion(System.getProperty("java.runtime.version"));
            info.setCpuCore(Runtime.getRuntime().availableProcessors());
    
            try { 
                Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
                if (interfaces != null) { 
                    while (interfaces.hasMoreElements()) { 
                        try { 
                            NetworkInterface network = interfaces.nextElement();
                            if (network != null) { 
                                info.setNetworkName(network.getName());
                                info.setNetworkDisplayName(network.getDisplayName());
                            }
                        } catch (Throwable e) { 
                            log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
                        }
                    }
                }
            } catch (Throwable e) { 
                log.warn("Failed to retrieving ip address, " + e.getMessage(), e);
            }
    
            return info;
        }
    
    
        /** * The get memory info * * @return {@link MemoryInfo} */
        public static MemoryInfo getMemory() { 
            int mb = 1024 * 1024;
            Runtime runtime = Runtime.getRuntime();
            MemoryInfo memoryInfo = new MemoryInfo();
    
            // JVM
            double freeMemory = (double) runtime.freeMemory() / mb;
            double maxMemory = (double) runtime.maxMemory() / mb;
            double totalMemory = (double) runtime.totalMemory() / mb;
            double usedMemory = totalMemory - freeMemory;
            double percentUsed = (usedMemory / maxMemory) * 100.0;
            usedMemory = new BigDecimal(usedMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            maxMemory = new BigDecimal(maxMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            percentUsed = new BigDecimal(percentUsed).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            memoryInfo.setUsedMemory(usedMemory);
            memoryInfo.setMaxMemory(maxMemory);
            memoryInfo.setPercentUsed(percentUsed);
    
            // System
            OperatingSystemMXBean osBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
            double totalPhysicalMemory = (double) osBean.getTotalPhysicalMemorySize() / mb;
            double freePhysicalMemory = (double) osBean.getFreePhysicalMemorySize() / mb;
            double committedVirtualMemory = (double) osBean.getCommittedVirtualMemorySize() / mb;
            totalPhysicalMemory = new BigDecimal(totalPhysicalMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            freePhysicalMemory = new BigDecimal(freePhysicalMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            committedVirtualMemory = new BigDecimal(committedVirtualMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            memoryInfo.setTotalPhysicalMemory(totalPhysicalMemory);
            memoryInfo.setFreePhysicalMemory(freePhysicalMemory);
            memoryInfo.setCommittedVirtualMemory(committedVirtualMemory);
    
            return memoryInfo;
        }
    
        /** * The get cpu load info * * @return {@link CpuLoadInfo} */
        public static CpuLoadInfo getCpuLoadInfo() { 
            try { 
                MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
                ObjectName objectName = ObjectName.getInstance("java.lang:type=OperatingSystem");
    
                // read process cpu load
                Double processCpuLoad = getAttributeValue(beanServer, objectName, "ProcessCpuLoad");
                // read system cpu load
                Double systemCpuLoad = getAttributeValue(beanServer, objectName, "SystemCpuLoad");
                if (processCpuLoad != null || systemCpuLoad != null) { 
                    CpuLoadInfo cpuLoadInfo = new CpuLoadInfo();
                    cpuLoadInfo.setProcessCpuLoad(processCpuLoad);
                    cpuLoadInfo.setSystemCpuLoad(systemCpuLoad);
                    return cpuLoadInfo;
                }
            } catch (Exception e) { 
                log.error(e.getMessage(), e);
            }
    
            return null;
        }
    
        /** * The get disk info * * @return {@link DiskInfo} */
        public static List<DiskInfo> getDiskInfo() { 
            double mb = 1024 * 1024;
    
            List<DiskInfo> diskInfoList = new ArrayList<>();
            File[] disks = File.listRoots();
            for (File file : disks) { 
                DiskInfo diskInfo = new DiskInfo();
                diskInfo.setPath(file.getPath());
                // 空闲空间
                diskInfo.setFreeSpace(new BigDecimal(
                        file.getFreeSpace() / mb).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                // 可用空间
                diskInfo.setUsableSpace(new BigDecimal(
                        file.getUsableSpace() / mb).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                // 总空间
                diskInfo.setTotalSpace(new BigDecimal(
                        file.getTotalSpace() / mb).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                diskInfoList.add(diskInfo);
            }
    
            return diskInfoList;
        }
    
        /** * The get garbage collector info * * @return {@link GarbageCollectorInfo} */
        public static List<GarbageCollectorInfo> getGarbageCollectorInfo() { 
            List<GarbageCollectorInfo> garbageCollectorInfoList = new ArrayList<>();
            List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
            for (GarbageCollectorMXBean gcBean : gcBeans) { 
                GarbageCollectorInfo garbageCollectorInfo = new GarbageCollectorInfo();
                garbageCollectorInfo.setName(gcBean.getName());
                garbageCollectorInfo.setCollectionTime(gcBean.getCollectionTime());
                garbageCollectorInfo.setCollectionCount(gcBean.getCollectionCount());
                garbageCollectorInfoList.add(garbageCollectorInfo);
            }
    
            return garbageCollectorInfoList;
        }
    
        private static Double getAttributeValue(MBeanServer beanServer, ObjectName objectName, String attribute) throws Exception { 
            Object cpuLoadObject = beanServer.getAttribute(objectName, attribute);
            if (cpuLoadObject == null) { 
                return null;
            }
    
            double cpuLoadValue = (double) cpuLoadObject;
            if (cpuLoadValue < 0) { 
                // usually takes a couple of seconds before we get real values
                return 0.00;
            }
    
            // returns a percentage value with 1 decimal point precision
            return new BigDecimal(cpuLoadValue * 100).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /** * EnvironmentInfo */
        @Data
        @ToString
        public static class EnvironmentInfo implements Serializable { 
    
            private static final long serialVersionUID = -9055644935967288508L;
    
            private String osName;
            private String osVersion;
            private String osArch;
            private String jvmName;
            private String jvmVersion;
            private Integer cpuCore;
            private String networkName;
            private String networkDisplayName;
        }
    
        /** * MemoryInfo */
        @Data
        @ToString
        public static class MemoryInfo implements Serializable { 
    
            private static final long serialVersionUID = -6078242692181489693L;
    
            // === JVM
            /** * Used memory(MB) */
            private double usedMemory;
            /** * Max memory(MB) */
            private double maxMemory;
            /** * Percent used(%) */
            private double percentUsed;
    
            // === System
    
            private double totalPhysicalMemory;
            private double freePhysicalMemory;
            private double committedVirtualMemory;
    
        }
    
        /** * CpuLoadInfo */
        @Data
        @ToString
        public static class CpuLoadInfo implements Serializable { 
    
            private static final long serialVersionUID = -7983527685877649306L;
    
            /** * Process CPU load */
            private Double processCpuLoad;
            /** * System CPU load */
            private Double systemCpuLoad;
    
        }
    
        /** * DiskInfo */
        @Data
        @ToString
        public static class DiskInfo implements Serializable { 
    
            private static final long serialVersionUID = 1486150261930978720L;
    
            private String path;
            private Double freeSpace;
            private Double usableSpace;
            private Double totalSpace;
        }
    
        /** * GarbageCollectorInfo */
        @Data
        @ToString
        public static class GarbageCollectorInfo implements Serializable { 
    
            private static final long serialVersionUID = -6536126923166050353L;
    
            private String name;
            private Long collectionTime;
            private Long collectionCount;
        }
    
    }

## 十二、三元结构体 ##

/** * 三元结构体 * * @param <F> * @param <S> * @param <T> */
    public class Triple<F, S, T> { 
    
    	private F first;
    	
    	private S second;
    	
    	private T third;
    	
    	public Triple(F first, S second, T third) { 
    		this.first = first;
    		this.second = second;
    		this.third = third;
    	}
    
    	public F getFirst() { 
    		return first;
    	}
    
    	public void setFirst(F first) { 
    		this.first = first;
    	}
    
    	public S getSecond() { 
    		return second;
    	}
    
    	public void setSecond(S second) { 
    		this.second = second;
    	}
    
    	public T getThird() { 
    		return third;
    	}
    
    	public void setThird(T third) { 
    		this.third = third;
    	}
    
    	@Override
    	public String toString() { 
    		return "Triple{" +
    				"first=" + first +
    				", second=" + second +
    				", third=" + third +
    				'}';
    	}
    }

## 十三、二元体结构 ##

/** * 二元体结构 */
    public class Pair<F, S> { 
    
        private final  F first;
    
        private final S second;
    
        public Pair(F first, S second) { 
            this.first = first;
            this.second = second;
        }
    
        public F getFirst() { 
            return first;
        }
    
        public S getSecond() { 
            return second;
        }
    
        @Override
        public String toString() { 
            return "Pair{" +
                    "first=" + first +
                    ", second=" + second +
                    '}';
        }
    }

## 十四、使用PriorityQueue作为任务工作队列 实现Timer工具 ##

import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.Date;
    import java.util.PriorityQueue;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /** * jdk Timer工具的另一个实现 * 区别： * 内部直接使用PriorityQueue作为任务工作队列 * 运行过程中，若有一个task发生异常，整个Timer定时器不会关闭（jdk自带的timer会关闭） * 任务单元直接使用Runnable接口 */
    public class Timer { 
    
        final static Logger logger = LoggerFactory.getLogger(Timer.class);
    
        private PriorityQueue<TimerTask> queue;
    
        private final TimerThread thread;
    
        private static final AtomicInteger nextSerialNumber = new AtomicInteger(0);
    
        private static int serialNumber() { 
            return nextSerialNumber.getAndIncrement();
        }
    
        public Timer() { 
            this("Timer-" + serialNumber());
        }
    
        public Timer(boolean daemon) { 
            this("Timer-" + serialNumber(), daemon);
        }
    
        public Timer(String threadName) { 
            this.queue = new PriorityQueue<>();
            this.thread = new TimerThread(this.queue);
            this.thread.setName(threadName);
            this.thread.start();
        }
    
        public Timer(String threadName, boolean daemon) { 
            this.queue = new PriorityQueue();
            this.thread = new TimerThread(this.queue);
            this.thread.setName(threadName);
            this.thread.setDaemon(daemon);
            this.thread.start();
        }
    
        public void schedule(Runnable task, long delay) { 
            if (delay < 0L) { 
                throw new IllegalArgumentException("Negative delay.");
            } else { 
                this.schedule(task, System.currentTimeMillis() + delay, 0L);
            }
        }
    
        public void schedule(Runnable task, Date start) { 
            this.schedule(task, start.getTime(), 0L);
        }
    
        public void scheduleAtFixedRate(Runnable task, long delay, long period) { 
            if (delay < 0L) { 
                throw new IllegalArgumentException("Negative delay.");
            } else if (period <= 0L) { 
                throw new IllegalArgumentException("Non-positive period.");
            } else { 
                this.schedule(task, System.currentTimeMillis() + delay, period);
            }
        }
    
        public void scheduleAtFixedRate(Runnable task, Date start, long period) { 
            if (period <= 0L) { 
                throw new IllegalArgumentException("Non-positive period.");
            } else { 
                this.schedule(task, start.getTime(), period);
            }
        }
    
        private void schedule(Runnable task, long time, long period) { 
            if (time < 0L) { 
                throw new IllegalArgumentException("Illegal execution time.");
            } else { 
                if (Math.abs(period) > 4611686018427387903L) { 
                    period >>= 1;
                }
    
                TimerTask timerTask = new TimerTask(task);
                synchronized(this.queue) { 
                    if (!this.thread.run) { 
                        throw new IllegalStateException("Timer already cancelled.");
                    } else { 
                        synchronized(timerTask.lock) { 
                            if (timerTask.state != 0) { 
                                throw new IllegalStateException("Task already scheduled or cancelled");
                            }
    
                            timerTask.nextExecutionTime = time;
                            timerTask.period = period;
                            timerTask.state = TimerTask.SCHEDULED;
                        }
    
                        this.queue.add(timerTask);
                        if (this.queue.peek() == timerTask) { 
                            this.queue.notify();
                        }
                    }
                }
            }
        }
    
        public void cancel() { 
            PriorityQueue<TimerTask> vars = this.queue;
            synchronized(this.queue) { 
                this.thread.run = false;
                this.queue.clear();
                this.queue.notify();
            }
        }
    
    }
    
    class TimerThread extends Thread { 
    
        boolean run = true;
        private PriorityQueue<TimerTask> queue;
    
        public TimerThread(PriorityQueue<TimerTask> queue) { 
            this.queue = queue;
        }
    
        @Override
        public void run() { 
            try { 
                mainLoop();
            } finally { 
                // Someone killed this Thread, behave as if Timer cancelled
                synchronized(queue) { 
                    run = false;
                    // Eliminate obsolete references
                    queue.clear();
                }
            }
        }
    
        /** * The main timer loop. (See class comment.) */
        private void mainLoop() { 
            while (true) { 
                try { 
                    TimerTask task;
                    boolean taskFired;
                    synchronized(queue) { 
                        // Wait for queue to become non-empty
                        while (queue.isEmpty() && run) { 
                            queue.wait();
                        }
                        if (queue.isEmpty()) { 
                            break; // Queue is empty and will forever remain; die
                        }
                        // Queue nonempty; look at first evt and do the right thing
                        long currentTime, executionTime;
                        task = queue.peek();
                        synchronized(task.lock) { 
                            if (task.state == TimerTask.CANCELLED) { 
                                queue.poll();
                                continue;  // No action required, poll queue again
                            }
                            currentTime = System.currentTimeMillis();
                            executionTime = task.nextExecutionTime;
                            if (taskFired = (executionTime<=currentTime)) { 
                                task = queue.poll();
                                // Non-repeating, remove
                                if (task.period == 0) { 
                                    task.state = TimerTask.EXECUTED;
                                } else {  // Repeating task, reschedule
                                    long nextExecTime = task.period < 0 ?
                                            currentTime - task.period
                                            : executionTime + task.period;
                                    task.nextExecutionTime = nextExecTime;
                                    queue.add(task);
                                }
                            }
                        }
                        // Task hasn't yet fired; wait
                        if (!taskFired) { 
                            queue.wait(executionTime - currentTime);
                        }
                    }
                    // Task fired; run it, holding no locks
                    if (taskFired) { 
                        try { 
                            task.run();
                        }catch (Exception e) { 
                            Timer.logger.error("timer任务执行异常", e);
                        }
                    }
                } catch(InterruptedException e) { 
                    // ignore it
                }
            }
        }
    
    }
    
    class TimerTask implements Runnable, Comparable<TimerTask> { 
    
        private Runnable task;
    
        final Object lock = new Object();
    
        int state = VIRGIN;
    
        static final int VIRGIN = 0;
    
        static final int SCHEDULED   = 1;
    
        static final int EXECUTED    = 2;
    
        static final int CANCELLED   = 3;
    
        long nextExecutionTime;
    
        long period = 0;
    
        TimerTask(Runnable task) { 
            this.task = task;
        }
    
        @Override
        public int compareTo(TimerTask timerTask) { 
           if (timerTask.nextExecutionTime > this.nextExecutionTime) { 
               return -1;
           }
            if (timerTask.nextExecutionTime < this.nextExecutionTime) { 
                return 1;
            }
            return 0;
        }
    
        @Override
        public void run() { 
            task.run();
        }
    }

## 十五、线程设置名称 ##

import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.beam.repackaged.beam_sdks_java_core.org.apache.commons.lang3.concurrent.BasicThreadFactory;
    import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
    
    import java.util.concurrent.*;
    
    /** * 给线程取名称 * @author nick */
    @Slf4j
    public class ThreadTools { 
    
    
        /** * Spring 框架提供的 CustomizableThreadFactory * 本质 ： * final Thread thread = new Thread(); * thread.setName(name); */
        private void test1(){ 
            ThreadFactory springThreadFactory = new CustomizableThreadFactory("springThread-pool-");
            ExecutorService exec = new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(10),springThreadFactory);
            exec.submit(() -> log.info("-----"));
        }
    
        /** * Google guava 工具类 提供的 ThreadFactoryBuilder ,使用链式方法创建。 * 本质 ： * final Thread thread = new Thread(); * thread.setName(name); */
        private void test2(){ 
            ThreadFactory guavaThreadFactory = new ThreadFactoryBuilder().setNameFormat("retryClient-pool-").build();
            ExecutorService exec = new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(10),guavaThreadFactory);
            exec.submit(() -> log.info("-----"));
        }
    
    
        /** * Apache commons-lang3 提供的 BasicThreadFactory * 本质 ： * final Thread thread = new Thread(); * thread.setName(name); */
        private void test3(){ 
            ThreadFactory basicThreadFactory = new BasicThreadFactory.Builder()
                    .namingPattern("basicThreadFactory-").build();
            ExecutorService exec = new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(10),basicThreadFactory);
            exec.submit(() -> log.info("-----"));
        }
    }

## 十六、Gzip ##

import ch.qos.logback.classic.pattern.TargetLengthBasedClassNameAbbreviator;
    import com.alibaba.fastjson.JSON;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.util.List;
    import java.util.StringTokenizer;
    import java.util.concurrent.*;
    import java.util.zip.GZIPOutputStream;
    
    public class gzipOutputStreamUtils { 
    
        public static ObjectMapper mapper = new ObjectMapper();
    
        static { 
            // 转换为格式化的json
            mapper.enable(SerializationFeature.INDENT_OUTPUT);
            // 如果json中有新增的字段并且是实体类类中不存在的，不报错
            mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        }
    
        /** * 压缩请求日志 * @param logger * @return */
        private byte[] buildRequestBody1(List<String> logger) { 
            try { 
    
                try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                     GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) { 
                     gzipOutputStream.write(JSON.toJSONBytes(logger));
                     gzipOutputStream.finish();
                     gzipOutputStream.close();
                    return byteArrayOutputStream.toByteArray();
                }
            }
            catch (IOException e) { 
                throw new RuntimeException(e);
            }
        }
    
        /** * 压缩请求日志 * @param logger * @return */
        private byte[] buildRequestBody2(List<String> logger) { 
            try { 
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) { 
                    gzipOutputStream.write(mapper.writeValueAsBytes(logger));
                }
                return byteArrayOutputStream.toByteArray();
            }
            catch (IOException e) { 
                throw new RuntimeException(e);
            }
        }
    
        /** * 缩短包名 * @param NameType * @param size * @return */
        private String getNameCurtali(String NameType, int size){ 
            TargetLengthBasedClassNameAbbreviator className = new TargetLengthBasedClassNameAbbreviator(size);
            return className.abbreviate(NameType);
        }
    
    
    
        private static final ExecutorService executorService = Executors.newSingleThreadExecutor();
    
        public FutureTask<String> getFutureTask() { 
            return new FutureTask<>(() -> { 
                System.out.println("hello");
                return "ok";
            });
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            gzipOutputStreamUtils futureTaskDemo = new gzipOutputStreamUtils();
            FutureTask<String> futureTask = futureTaskDemo.getFutureTask();
            executorService.execute(futureTask);
    
            Thread.sleep(100);
            if (futureTask.isDone()) { 
                System.out.println(futureTask.get());
            }
            executorService.shutdown();
        }
    
    
        /** * ExtClassLoader类中获取路径的代码 * @return */
        private static File[] getExtDirs() { 
            //加载<JAVA_HOME>/lib/ext目录中的类库
            String string = System.getProperty("java.ext.dirs");
            File[] dirs;
            if (string != null) { 
                StringTokenizer st = new StringTokenizer(string, File.pathSeparator);
                int count = st.countTokens();
                dirs = new File[count];
                for (int i = 0; i < count; i++) { 
                    dirs[i] = new File(st.nextToken());
                }
            } else { 
                dirs = new File[0];
            }
            return dirs;
        }
        
    }