Java 汇总统计，用户希望获取数值流中元素的数量、总和、最小值、最大值以及平均值。使用 IntStream、DoubleStream 或 LongStream 接口定义的 summaryStatistics 方法。基本类型流 IntStream、DoubleStream 与 LongStream 为 Stream 接口引入了用于处理基本数据类型的方法，summaryStatistics 就是其中一种方法。
 
Java 汇总统计 问题描述
 
用户希望获取数值流中元素的数量、总和、最小值、最大值以及平均值。
 
Java 汇总统计 解决方案
 
使用 IntStream、DoubleStream 或 LongStream 接口定义的 summaryStatistics 方法。
 
Java 汇总统计 具体实例
 
基本类型流 IntStream、DoubleStream 与 LongStream 为 Stream 接口引入了用于处理基本数据类型的方法，summaryStatistics 就是其中一种方法，如例 3-42 所示。
 
例 3-42　summaryStatistics 方法
 
➊ 使用 toString 方法打印
 
从 Java 7 开始，可以在数字字面量中使用下划线，如 1_000_000。
 
执行上述程序，输出结果类似于：
 
DoubleSummaryStatistics 类定义的 toString 方法返回字符串的表达形式，也提供用于统计元素数量、总和、最小值、最大值以及平均值的 getter 方法(getCount、getSum、getMax、getMin 以及 getAverage)。当 double 型元素的数量达到 100 万时，最小值趋近于 0，最大值趋近于 1，总和约为 50 万，平均值约为 0.5。
 
DoubleSummaryStatistics 类还定义了以下两个有趣的方法：
 
accept 方法用于在汇总信息中记录另一个值，而 combine 方法将两个 DoubleSummaryStatistics 对象合二为一。两种方法在计算结果之前，向类的实例添加数据时使用。
 
我们以运动员薪资跟踪网站 Spotrac 为例进行讨论。本书的源代码包括一个文件，它记录了 2017 赛季美国职棒大联盟(MLB)全部 30 支球队的薪资数据，这些数据均来自 Spotrac。
 
例 3-43 定义了一个名为 Team 的类，包括 id、name(队名)与 salary(薪资)。
 
例 3-43　Team 类包括 id、name 与 salary
 
解析球队工资文件，结果如下：
 
可以通过两种方式计算球队集合的汇总统计信息。第一种方式采用 collect 方法的三参数形式，如例 3-44 所示。
 
例 3-44　传入 Supplier、累加器与组合器的 collect 方法
 
有关这种 collect 方法的讨论请参见范例实现Collector接口。在本例中，collect 方法通过构造函数引用来提供 DoubleSummaryStatistics 的实例，通过 accept 方法将另一个值添加到现有的 DoubleSummaryStatistics 对象，以及通过 combine 方法将两个单独的 DoubleSummaryStatistics 对象合二为一。
 
输出结果如下(为便于阅读，对结果做了处理)：
 
计算汇总信息的另一种方案请参见范例下游收集器。此时，汇总计算如例 3-45 所示。
 
例 3-45　使用 summarizingDouble 方法进行收集
 
其中，Collectors.summarizingDouble 方法的参数是各队的薪资。无论采用哪种方案，结果并无区别。
 
从本质上讲，汇总统计类是一种“糟糕”的统计方法，因为它们仅能统计数量、最大值、最小值、总和、平均值等属性。然而，如果只需要这些属性，那么 Java 标准库应能满足需要。3
 
3当然，读者从本范例中还应学到一点：如果有机会参加 MLB 比赛，那么不妨一试，哪怕只有很短的上场时间。赛后再继续学习 Java 吧！

 
package com.hnedu.stat;
 
/**
 
* 计算在线人数，说明：
 
*
 
* 在访问页面放入：
 
* com.hnedu.stat.OnlineCounter.addUser(Object object)
 
* 一般用ip来作为object的传入值，当然，如果网站统计登陆在线人数，也可用用户名
 
* 来作为object传入值。
 
*
 
* 调用显示在线人数
 
http://www.gaodaima.com/64884.htmljava统计当前在线数_java
 
* com.hnedu.stat.OnlineCounter.getOnlineCount() *
 
*
 
* com.hnedu.stat.OnlineCounter.getOnline()
 
* 返回一个List，里面以String[]形式存放传入的object值和最后访问页面时间。
 
* by crazyren 2003-08-05 email: c_crazyren@hotmail.com
 
*/
 
import java.util.List;
 
import java.util.ArrayList;
 
import javax.servlet.http.HttpSession;
 
public class OnlineCounter {
 
private static List list = new ArrayList();
 
private OnlineCounter() {
 
}
 
public static void addUser(Object object) {
 
//得到用户当前访问时间
 
String nowtime = com.hnedu.util.StringUtils.getTime("mm:ss");
 
//Str数组用来存放用户得ip和访问时间
 
String[] str = new String[2];
 
str[0] = object.toString();
 
str[1] = nowtime;
 
//temp数组用来临时存放从list里面取出的用户ip和访问时间
 
String[] temp = new String[2];
 
//循环list
 
for (int i = 0; i < list.size(); i++) {
 
temp = (String[])list.get(i);
 
//如果从list里面取出的用户ip和str里面存放的ip相同，则更新访问时间
 
if(temp[0].equals(str[0])) {
 
list.set(i,str);
 
return;
 
}
 
//如果用户超过5分钟没有访问，则认为不在线
 
if(subTime(nowtime,temp[1]) > 300) {
 
list.remove(i);
 
}
 
}
 
//添加一个新的在线用户
 
list.add(str);
 
//释放资源
 
str = null;temp = null;
 
}
 
public static int getOnlineCount() {
 
//返回当前在线人数
 
return list.size();
 
}
 
public static List getOnline() {
 
return list;
 
}
 
/** 计算两个时间差，返回相差秒数 */
 
private static int subTime(String src,String des) {
 
int n = 0;
 
java.util.Calendar ca = java.util.Calendar.getInstance();
 
long time1 =
 
com.hnedu.util.StringUtils.compareStringTime(src,des,"mm:ss");
 
ca.setTimeInMillis(time1);
 
n = (ca.get(java.util.Calendar.MINUTE)) * 60;
 
n = n + ca.get(java.util.Calendar.SECOND);
 
return n;
 
}
 
}
 
引用的StringUtils里面的两个方法：
 
/**
 
* 获得当前时间
 
* @param parrten 输出的时间格式
 
* @return 返回时间
 
*/
 
public static String getTime(String parrten)
 
{
 
String timestr;
 
if(parrten==null||parrten.equals(""))
 
{
 
parrten="yyyyMMddHHmmss";
 
}
 
java.text.SimpleDateFormat sdf=new SimpleDateFormat(parrten);
 
java.util.Date cday=new Date();
 
timestr=sdf.format(cday);
 
return timestr;
 
}
 
/**
 
* 比较两个字符串时间的大小
 
* @param t1 时间1
 
* @param t2 时间2
 
* @param parrten 时间格式 :yyyy-MM-dd
 
* @return 返回long =0相等，>0 t1>t2，<0 t1
 
*/
 
public static long compareStringTime(String t1,String t2,String parrten)
 
{
 
SimpleDateFormat formatter = new SimpleDateFormat (parrten);
 
ParsePosition pos = new ParsePosition(0);
 
ParsePosition pos1 = new ParsePosition(0);
 
Date dt1=formatter.parse(t1,pos);
 
Date dt2=formatter.parse(t2,pos1);
 
long l=dt1.getTime()-dt2.getTime();
 
return l;
 
}
 
欢迎大家阅读《java统计当前在线数_java》,跪求各位点评,若觉得好的话请收藏本文，by 搞代码
 
原创文章，转载请注明： 转载自搞代码
 

 
微信 赏一包辣条吧~
 

 
支付宝 赏一听可乐吧~

 
要求1：输出某个英文文本文件中26字母出现的频率，由高到低排序，并显示字母出现的百分比，精确到小数点后两位。
 
思路：分别设存放字母和字母出现次数的数组，遍历文件内容，将字母及出现频率按由高到低的顺序输出
 
源码：
 
import java.io.BufferedReader;
 
import java.io.File;
 
import java.io.FileNotFoundException;
 
import java.io.FileReader;
 
import java.io.IOException;
 
import java.util.Scanner;
 
public class word
 
{
 
static String str="";
 
static String str1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
static char ch1 []=str1.toCharArray();//存放字母的数组
 
public static double num[]=new double[100];//存放字母出现次数的数组
 
public static int sum=0;//出现的字母个数
 
//读取文件内容
 
public static void read()
 
{
 
Scanner scan  =new Scanner(System.in);
 
File file = new File("D:\\h\\halibote\\Harry Potter and the Sorcerer's Stone.txt");
 
int score = 0;
 
StringBuffer result = new StringBuffer();
 
try
 
{
 
FileReader r = new FileReader(file);
 
BufferedReader br = new BufferedReader(r);
 
int i=0;
 
str=br.readLine();
 
while(str!=null)
 
{
 
for(int j=0;j
 
{
 
for(int k=0;k
 
{
 
if(str.charAt(j)==str1.charAt(k))
 
{
 
sum++;
 
num[k]++;
 
}
 
}
 
}
 
str=br.readLine();
 
}
 
br.close();
 
for(int p=0;p
 
{
 
int o=p;
 
for(int q=p;q
 
{
 
if(num[o]
 
{
 
o=q;
 
}
 
}
 
if(o!=p)
 
{
 
char ff=ch1[o];
 
ch1[o]=ch1[p];
 
ch1[p]=ff;
 
double fff=num[o];
 
num[o]=num[p];
 
num[p]=fff;
 
}
 
}
 
for(int k=0;k
 
{
 
num[k]=num[k]/sum*100;
 
System.out.print(ch1[k]);
 
System.out.printf("%.2f",num[k]);
 
System.out.println("%");
 
}
 
}
 
catch (FileNotFoundException e) {
 
e.printStackTrace();
 
} catch (IOException e) {
 
e.printStackTrace();
 
}
 
}
 
public static void main(String[] args)
 
{
 
read();
 
}
 
}
 
要求2：输出单个文件中的前n个最常出现的单词
 
思路：
 
遍历文件，读取所有单词并存入数组
 
对读取的单词进行去重并存入新数组
 
统计单词出现次数并将所统计每个单词的出现次数存入一数组
 
按出现次数由高到低的顺序输出n个单词及出现次数
 
源码
 
import java.io.File;
 
import java.io.InputStreamReader;
 
import java.io.Reader;
 
import java.nio.file.FileVisitResult;
 
import java.nio.file.Files;
 
import java.nio.file.Path;
 
import java.nio.file.Paths;
 
import java.nio.file.SimpleFileVisitor;
 
import java.nio.file.attribute.BasicFileAttributes;
 
import java.util.Scanner;
 
import java.io.BufferedReader;
 
import java.io.BufferedWriter;
 
import java.io.FileInputStream;
 
import java.io.FileNotFoundException;
 
import java.io.FileOutputStream;
 
import java.io.FileReader;
 
import java.io.FileWriter;
 
import java.io.IOException;
 
public class word1
 
{
 
private static String str="";
 
private static Scanner sc=new Scanner(System.in);
 
private static BufferedReader cin=null;
 
private static String a[]=new String[1000000];//存放从文件中读取的所有单词
 
private static String c[]=new String[10000000];//存放去重后单词
 
private static int b[]=new int[1000000];//存放单词出现次数
 
private static int length=0;//单词总个数
 
private static int length1=0;//去重后单词个数
 
private static int nn=0;
 
private static int j=0;
 
static File[] list = new File("D:\\h").listFiles();
 
//读取文件内容
 
public static void Readfile()
 
{
 
File file=new File("D:\\h\\halibote\\Harry Potter and the Sorcerer's Stone.txt");
 
try
 
{
 
InputStreamReader read = new InputStreamReader(new FileInputStream(file),"UTF-8");
 
cin=new BufferedReader(read);
 
str=cin.readLine();
 
cun();
 
cin.close();
 
read.close();
 
}
 
catch(IOException e) {
 
System.out.println("读取失败！");
 
e.printStackTrace();
 
}
 
}
 
//将单词存到数组a
 
public  static void cun() throws IOException
 
{
 
{
 
while(str!=null)
 
{
 
int i=0;
 
str=str.toLowerCase(); //把大写改成小写
 
for(i=0;i
 
{
 
if((str.charAt(i)>96&&str.charAt(i)<123))
 
{
 
a[j]=a[j]+str.charAt(i);
 
}
 
if(str.charAt(i)==' '||str.charAt(i)==','||str.charAt(i)=='.')
 
{
 
if(!a[j].equals(""))
 
{
 
j=j+1;
 
a[j]="";
 
}
 
}
 
}
 
str=cin.readLine();
 
}
 
length=j;
 
}
 
}
 
//去重
 
public static void Statistics()
 
{
 
for(int k=0;k
 
{
 
b[k]=0;
 
}
 
c[0]=a[0];
 
int tt=1;
 
Boolean rt=true;
 
for(int i=1;i
 
{
 
rt=false;
 
for(int j=0;j
 
{
 
if(a[i].equals(c[j]))
 
{
 
rt=true;
 
break;
 
}
 
}
 
if(!rt)
 
{
 
c[tt]=a[i];
 
tt++;
 
}
 
}
 
length1=tt;
 
for(int i=0;i
 
{
 
for(int j=0;j
 
{
 
if(c[i].equals(a[j]))
 
{
 
b[i]++;
 
}
 
}
 
}
 
}
 
//排序
 
public  static void Sorting()
 
{
 
int t3=0;
 
int t2=0;
 
String sr="";
 
for(int i=0;i
 
{
 
t3=i;
 
for(int j=i+1;j
 
{
 
if(b[t3]
 
{
 
t3=j;
 
}
 
}
 
if(t3!=i)
 
{
 
t2=b[i];
 
b[i]=b[t3];
 
b[t3]=t2;
 
sr=c[i];
 
c[i]=c[t3];
 
c[t3]=sr;
 
}
 
}
 
}
 
//显示
 
public  static void show()
 
{
 
for(int k=0;k
 
{
 
System.out.print(c[k]+"\t"+b[k]+"   ");
 
System.out.printf("%.2f",(double)b[k]/length1*100);
 
System.out.print("%");
 
System.out.println("");
 
}
 
}
 
public static void main(String[] args) throws IOException
 
{
 
System.out.println("请输入需要统计的个数：");
 
nn=sc.nextInt();
 
a[0]="";
 
Readfile();
 
Statistics();
 
Sorting();
 
show();
 
}
 
}
 
功能1：输出文件中所有不重复的单词，按照出现次数由多到少排列，出现次数同样多的，以字典序排列
 
思路：只需将输出结果改为单词加出现次数并写入文件，其他与要求2一致
 
源码：
 
import java.io.File;
 
import java.io.InputStreamReader;
 
import java.io.Reader;
 
import java.nio.file.FileVisitResult;
 
import java.nio.file.Files;
 
import java.nio.file.Path;
 
import java.nio.file.Paths;
 
import java.nio.file.SimpleFileVisitor;
 
import java.nio.file.attribute.BasicFileAttributes;
 
import java.util.Scanner;
 
import java.io.BufferedReader;
 
import java.io.BufferedWriter;
 
import java.io.FileInputStream;
 
import java.io.FileNotFoundException;
 
import java.io.FileOutputStream;
 
import java.io.FileReader;
 
import java.io.FileWriter;
 
import java.io.IOException;
 
public class word2
 
{
 
private static String str="";
 
private static Scanner sc=new Scanner(System.in);
 
private static BufferedReader cin=null;
 
private static String a[]=new String[1000000];
 
private static String c[]=new String[10000000];
 
private static int b[]=new int[1000000];
 
private static int length=0;
 
private static int length1=0;
 
private static int nn=0;
 
private static int j=0;
 
static File[] list = new File("D:\\h").listFiles();
 
public static void Readfile()
 
{
 
File file=new File("D:\\h\\halibote\\Harry Potter and the Sorcerer's Stone.txt");
 
try
 
{
 
InputStreamReader read = new InputStreamReader(new FileInputStream(file),"UTF-8");
 
cin=new BufferedReader(read);
 
str=cin.readLine();
 
cun();
 
cin.close();
 
read.close();
 
}
 
catch(IOException e) {
 
System.out.println("读取失败！");
 
e.printStackTrace();
 
}
 
}
 
//将单词存到数组a
 
public  static void  cun() throws IOException
 
{
 
{
 
while(str!=null)
 
{
 
int i=0;
 
str=str.toLowerCase(); //把大写改成小写
 
for(i=0;i
 
{
 
if((str.charAt(i)>96&&str.charAt(i)<123))
 
{
 
a[j]=a[j]+str.charAt(i);
 
}
 
if(str.charAt(i)==' '||str.charAt(i)==','||str.charAt(i)=='.')
 
{
 
if(!a[j].equals(""))
 
{
 
j=j+1;
 
a[j]="";
 
}
 
}
 
}
 
str=cin.readLine();
 
}
 
length=j;
 
}
 
}
 
//去重
 
public static void Statistics()
 
{
 
for(int k=0;k
 
{
 
b[k]=0;
 
}
 
c[0]=a[0];
 
int tt=1;
 
Boolean rt=true;
 
for(int i=1;i
 
{
 
rt=false;
 
for(int j=0;j
 
{
 
if(a[i].equals(c[j]))
 
{
 
rt=true;
 
break;
 
}
 
}
 
if(!rt)
 
{
 
c[tt]=a[i];
 
tt++;
 
}
 
}
 
length1=tt;
 
for(int i=0;i
 
{
 
for(int j=0;j
 
{
 
if(c[i].equals(a[j]))
 
{
 
b[i]++;
 
}
 
}
 
}
 
}
 
//排序
 
public  static void  Sorting()
 
{
 
int t3=0;
 
int t2=0;
 
String sr="";
 
for(int i=0;i
 
{
 
t3=i;
 
for(int j=i+1;j
 
{
 
if(b[t3]
 
{
 
t3=j;
 
}
 
}
 
if(t3!=i)
 
{
 
t2=b[i];
 
b[i]=b[t3];
 
b[t3]=t2;
 
sr=c[i];
 
c[i]=c[t3];
 
c[t3]=sr;
 
}
 
}
 
}
 
//将输出结果写入文本文件
 
public static void Writefile() throws IOException
 
{
 
File file=new File("D:\\h\\halibote\\t1.txt");
 
if(!file.exists())
 
file.createNewFile();
 
FileWriter write = new FileWriter(file,true);
 
BufferedWriter out=new BufferedWriter(write);
 
for(int i=0;i
 
{
 
StringBuffer sb=new StringBuffer();
 
out.write("这是第"+(i+1)+"个: ");
 
out.write(c[i]+"\t"+b[i]);
 
out.write("\r\n");
 
}
 
out.close();
 
}
 
//显示
 
public static void show1()
 
{
 
for(int k=0;k
 
{
 
System.out.print(c[k]+"\t \t\t"+b[k]+"\n");
 
}
 
}
 
public static void main(String[] args) throws IOException
 
{
 
a[0]="";
 
Readfile();
 
Statistics();
 
Sorting();
 
System.out.println("程序中所有不重复的单词！");
 
show1();
 
Writefile();
 
}
 
}

 
importjava.io.BufferedReader;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileReader;importjava.io.IOException;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.Scanner;public classTongJiDanCi {public static void main(String[] args)throws IOException//扔掉很重要
 
{
 
File file= new File("D:/c1.txt");
 
System.out.println("0.统计英文字母个数及其百分比 1.统计英文单词个数");
 
Scanner sc= newScanner(System.in);int value=sc.nextInt();while(true) {switch(value) {case 0:txtString(file);case 1:txtString2(file);default:break;
 
}
 
}
 
}/** 统计字母*/
 
public static void txtString(File file) throwsIOException{try{//IO操作读取文件内容
 
FileReader fr = newFileReader(file);
 
@SuppressWarnings("resource")
 
BufferedReader br= new BufferedReader(fr);//构造一个BufferedReader类来读取文件
 
HashMap hm = new HashMap();//构建了一个新的HashMap对象，强制指定这个HashMap必须是以String为key, 以Integer为值。
 
String line =null;
 
Integer count= 0;//每个字母的个数
 
Integer total = 0;//统计字母总数，作百分比用
 
while ((line=br.readLine())!=null) {char[] ch = line.toCharArray();//将字符串对象中的字符转换为一个字符数组。
 
total = total +ch.length;for (int i = 0; i < ch.length; i++) {
 
ch[i]= Character.toLowerCase(ch[i]);//将大写字符转换为小写，小写字母不变
 
count = hm.get(ch[i]+"");//ch[i]+""的作用是加一个空格后，括号内转化为字符串
 
if (count == null) {
 
count=1;//只出现一次
 
}else{
 
count++;
 
}
 
hm.put(ch[i]+"", count);
 
}
 
}for (String str : hm.keySet()) {//设变量str获取键
 
System.out.println(str+"个数:"+hm.get(str)+" "+hm.get(str)*100.0/total+"%");
 
}
 
System.out.println("总字母个数："+total);//排序输出
 
List> list_Data = new ArrayList>(hm.entrySet());
 
Collections.sort(list_Data,new Comparator>(){public int compare(Map.Entry o1, Map.Entryo2)
 
{//o1 to o2升序 o2 to o1降序
 
returno2.getValue().compareTo(o1.getValue());
 
}
 
});
 
System.out.println("排序输出：");
 
System.out.println(hm);
 
}catch(FileNotFoundException e) {
 
e.printStackTrace();
 
}
 
}/** 统计单词*/
 
public static void txtString2(File file) throwsIOException{
 
FileReader fr= newFileReader(file);
 
BufferedReader br= new BufferedReader(fr);//构造一个BufferedReader类来读取文件
 
StringBuffer sb = newStringBuffer();
 
String line=null;while ((line=br.readLine())!=null){
 
sb.append(line);//将读取出的字符追加到stringbuffer中
 
}
 
fr.close();//关闭读入流
 
String str = sb.toString().toLowerCase(); //将stringBuffer转为字符并转换为小写
 
String[] words = str.split("[^(a-zA-Z)]+"); //非单词的字符来分割，得到所有单词
 
Map map = new HashMap() ;for(String word :words){if(map.get(word)==null){ //若不存在说明是第一次，则加入到map,出现次数为1
 
map.put(word,1);
 
}else{
 
map.put(word,map.get(word)+1); //若存在，次数累加1
 
}
 
}//排序
 
List> list = new ArrayList>(map.entrySet());
 
Comparator> comparator = new Comparator>() {public int compare(Map.Entry left, Map.Entryright) {int i=left.getValue()-right.getValue();if(i==0) {return(right.getKey().compareTo(left.getKey()));
 
}return(left.getValue().compareTo(right.getValue()));
 
}
 
};//集合默认升序
 
Collections.sort(list,comparator);int n=list.size();
 
System.out.println("一共有"+n+"种单词");
 
System.out.println("请输入你要排序前几个单词：");
 
Scanner scanner=newScanner(System.in);
 
n=scanner.nextInt();for(int i=0;i
 
System.out.println(list.get(list.size()-i-1).getKey() +":"+list.get(list.size()-i-1).getValue());
 
}
 
}
 
}