[Java]数据分析--数据可视化

时间序列

• 需求：将一组字符顺序添加到时间序列中
• 实现：定义时间序列类TimeSeries，包含静态类Entry表示序列类中的各项，以及add，get，iterator，entry方法

TimeSeries.java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;

public class TimeSeries<T> implements Iterable<TimeSeries.Entry> {
    private final Map<Long,T> map = new TreeMap();
    
    public void add(long time, T event) {
        map.put(time, event);
        try {
            TimeUnit.MICROSECONDS.sleep(1);  // 0.000001 sec delay
        } catch(InterruptedException e) {
            System.err.println(e);
        }
    }
    
    public T get(long time) {
        return map.get(time);
    }

    ArrayList getList() {
        ArrayList<Entry> list = new ArrayList();
        for (Entry entry : this) {
            list.add(entry);
        }
        return list;
    }
    
    public int size() {
        return map.size();
    }
    
    @Override
    public Iterator iterator() {
        return new Iterator() { // anonymous inner class
            private final Iterator it = map.keySet().iterator();

            @Override
            public boolean hasNext() {
                return it.hasNext();
            }

            @Override
            public Entry<T> next() {
                long time = (Long)it.next();
                T event = map.get(time);
                return new Entry(time, event);
            }
        };
    }
    
    public static class Entry<T> {
        private final Long time;
        private final T event;

        public Entry(long time, T event) {
            this.time = time;
            this.event = event;
        }

        public long getTime() {
            return time;
        }

        public T getEvent() {
            return event;
        }

        @Override
        public String toString() {
            return String.format("(%d, %s)", time, event);
        }
    }
}

TimeSeriesTester.java

import java.util.ArrayList;

public class TimeSeriesTester {
    final static String[] EVENTS = {"It", "was", "the", "best", "of", "times"};

    public static void main(String[] args) {
        TimeSeries<String> series = new TimeSeries();
        load(series);

        for (TimeSeries.Entry<String> entry : series) {
            long time = entry.getTime();
            String event = entry.getEvent();
            System.out.printf("%16d: %s%n", time, event);
        }

        ArrayList list = series.getList();
        System.out.printf("list.get(3) = %s%n", list.get(3));
    }
    
    static void load(TimeSeries<String> series) {
        for (String event : EVENTS) {
            series.add(System.currentTimeMillis(), event);
        }
    }
}

移动平均

• 需求：实现一个序列，其值是原始序列连续片段的平均值
• 实现：定义移动平均类MovingAverage，继承TimeSeries，同时实现根据原始序列和片段长度生成新序列的构造方法，tmp每次计算保存一个片段，sum计算片段元素之和，最后把平均值添加到序列中
• 注意
  • 如原始序列有8个元素，片段长度为3，则新序列长度为 8-8%3=6
  • 对于a=b=c，先执行b=c，再执行a=b
  • tmp不是每次全部更新，替换一个元素即可，求和后i自增

MovingAverage.java

import java.util.Iterator;

public class MovingAverage extends TimeSeries<Double> {
    private final TimeSeries parent;
    private final int length;

    public MovingAverage(TimeSeries parent, int length) {
        this.parent = parent;
        this.length = length;
        if (length > parent.size()) {
            throw new IllegalArgumentException("That's too long.");
        }
        
        double[] tmp = new double[length];  // temp array to compute averages
        double sum = 0;
        int i=0;
        Iterator it = parent.iterator();
        for (int j = 0; j < length; j++) {
            sum += tmp[i++] = nextValue(it);
        }
        this.add(System.currentTimeMillis(), sum/length);

        while (it.hasNext()) {
            sum -= tmp[i%length];
            sum += tmp[i++%length] = nextValue(it);
            this.add(System.currentTimeMillis(), sum/length);
        }
    }
    
    /*  Returns the double value in the Entry currently located by it. 
    */
    private static double nextValue(Iterator it) {
        TimeSeries.Entry<Double> entry = (TimeSeries.Entry)it.next();
        return entry.getEvent();
    }
}

MovingAverageTester.java

public class MovingAverageTester {
    static final double[] DATA = {20, 25, 21, 26, 28, 27, 29, 31};
    
    public static void main(String[] args) {
        TimeSeries<Double> series = new TimeSeries();
        for (double x : DATA) {
            series.add(System.currentTimeMillis(), x);
        }
        System.out.println(series.getList());

        TimeSeries<Double> ma3 = new MovingAverage(series, 3);
        System.out.println(ma3.getList());

        TimeSeries<Double> ma5 = new MovingAverage(series, 5);
        System.out.println(ma5.getList());
    }
}

指数分布

• 需求：模拟输出客服接电话的时间，两次电话之间的时间为指数分布，已知平均8小时接到120个电话
• 实现：平均等待时间为4分钟，密度参数为0.25，生成随机数后代入指数分布公式，即得到时间

import java.util.Random;

public class ArrivalTimesTester {
    static final Random random = new Random();
    static final double LAMBDA = 0.25;
    
    static double time() {
        double p = random.nextDouble();
        return -Math.log(1 - p)/LAMBDA;
    }
    
    public static void main(String[] args) {
        double sum=0;
        for (int i = 0; i < 8; i++) {
            System.out.println(time());
            sum += time();
        }
        System.out.println("
");
        System.out.println(sum/8);
    }
}