海量日志数据提取某日访问百度次数最多的那个IP的Java实现

最新推荐文章于 2022-10-29 10:55:37 发布
最新推荐文章于 2022-10-29 10:55:37 发布
阅读量3.6k 收藏 7
点赞数
分类专栏： j2EE 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/psyuhen/article/details/12061225
版权
j2EE 同时被 2 个专栏收录
42 篇文章 0 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏

海量日志数据提取某日访问百度次数最多的那个IP的Java实现

 

前几天在网上看到july的一篇文章《教你如何迅速秒杀掉：99%的海量数据处理面试题》,里面说到百度的一个面试题目，题目如下：

海量日志数据，提取出某日访问百度次数最多的那个IP。

 

 

july里面的分析如下。

1、  分而治之/hash映射：针对数据太大，内存受限，只能是：把大文件化成(取模映射)小文件，即16字方针：大而化小，各个击破，缩小规模，逐个解决

2、  hash统计：当大文件转化了小文件，那么我们便可以采用常规的hash_map(ip，value)来进行频率统计。

3、  堆/快速排序：统计完了之后，便进行排序(可采取堆排序)，得到次数最多的IP。

 

我的分析：

1、  见july的1st.

2、  见july的2nd.

3、  不用排序，直接在统计的时候，计算出次数最多的IP：在第2步的时候，求出ip的次数，实际上呢，次数最大的那个只可能是一个值，因此在计算每个IP次数的时候，与这个最大值作比较，计算完即可知道最大值的IP是….

 

 

1      机器配置：

CPU:I3-2330M  2.20GHZ

MEM:4G(3.16G可用)

OS:win7  32位

2      生成海量数据的大文件：

2.1     总数据为1亿个IP数据，生成规则：以10.开头，其他是0-255的随机数。

 

/**
	 * 生成大文件
	 * @param ipFile
	 * @param numberOfLine
	 */
	public void gernBigFile(File ipFile,long numberOfLine){
		BufferedWriter bw = null;
		FileWriter fw = null;
		long startTime = System.currentTimeMillis();
		try{
			fw = new FileWriter(ipFile,true);
			bw = new BufferedWriter(fw);
			
			SecureRandom random = new SecureRandom();
			for (int i = 0; i < numberOfLine; i++) {
				bw.write("10."+random.nextInt(255)+"."+random.nextInt(255)+"."+random.nextInt(255)+"\n");
				if((i+1) % 1000 == 0){
					bw.flush();
				}
			}
			bw.flush();
			
			long endTime = System.currentTimeMillis();
			System.err.println(DateUtil.convertMillsToTime(endTime - startTime));
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			try{
				if(fw != null){
					fw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(bw != null){
					bw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}



/*
		 * 1、第一次生成1亿(实际上最多为16581375)的ip地址，需要时间为3分多钟不到4分钟。
		 */
		TooMuchIpFile tooMuchIpFile = new TooMuchIpFile();
		File ipFile = new File("e:/ipAddr.txt");
		try {
			ipFile.createNewFile();
		} catch (IOException e) {
			e.printStackTrace();
		}
		tooMuchIpFile.gernBigFile(ipFile, 100000000);


  

 

2.2     运行结果：

生成1亿行的Ip地址，大约耗时：3分多钟，大小1.27 GB (1,370,587,382字节)

 

 

3      分割大文件，

根据july的分析，取每个IP的hashCode，与1000取模，把IP散列到不同的文件中去。

 

3.1     第一种方法：

一边取每个IP的散列值，再模1000，得到一个值，然后写到此值对应的文件中去。大约耗时超过2个多小时，实在是太慢了，没跑完就直接断掉了。

 

/**
	 * 大文件分割为小文件
	 * @param ipFile
	 * @param numberOfFile
	 */
	public void splitFile(File ipFile,int numberOfFile){
		BufferedReader br = null;
		FileReader fr = null;
		BufferedWriter bw = null;
		FileWriter fw = null;
		long startTime = System.currentTimeMillis();
		try{
			fr = new FileReader(ipFile);
			br = new BufferedReader(fr);
			String ipLine = br.readLine();
			while(ipLine != null){
				int hashCode = ipLine.hashCode();
				hashCode = hashCode < 0 ? -hashCode : hashCode;
				int fileNum = hashCode % numberOfFile;
				File file = new File("e:/tmp/ip/"+ fileNum + ".txt");
				if(!file.exists()){
					file.createNewFile();
				}
				fw = new FileWriter(file,true);
				bw = new BufferedWriter(fw);
				bw.write(ipLine + "\n");
				bw.flush();
				fw.close();
				bw.close();
				ipLine = br.readLine();
			}
			
			long endTime = System.currentTimeMillis();
			System.err.println(DateUtil.convertMillsToTime(endTime - startTime));
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			try{
				if(fr != null){
					fr.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(br != null){
					br.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(fw != null){
					fw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(bw != null){
					bw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


 

 

3.2     第二种方法：

与第一次方法基本相同，不同的是减少流对象的创建，只是创建文件时，创建流对象，但还是需要每次都要判断文件存在与否。大约耗时超过1个多小时，也实在是慢呀，没等它运行完就断了。

/**
	 * 大文件分割为小文件
	 * @param ipFile
	 * @param numberOfFile
	 */
	public void splitFile2(File ipFile,int numberOfFile){
		BufferedReader br = null;
		FileReader fr = null;
		BufferedWriter bw = null;
		FileWriter fw = null;
		long startTime = System.currentTimeMillis();
		try{
			fr = new FileReader(ipFile);
			br = new BufferedReader(fr);
			String ipLine = br.readLine();
			while(ipLine != null){
				int hashCode = ipLine.hashCode();
				hashCode = hashCode < 0 ? -hashCode : hashCode;
				int fileNum = hashCode % numberOfFile;
				File file = new File("e:/tmp/ip/"+ fileNum + ".txt");
				if(!file.exists()){
					file.createNewFile();
					fw = new FileWriter(file,true);
					bw = new BufferedWriter(fw);
					bwMap.put(fileNum, bw);
				}else{
					bw = bwMap.get(fileNum);
				}
				bw.write(ipLine + "\n");
				bw.flush();
				ipLine = br.readLine();
			}
			for(int fn : bwMap.keySet()){
				bwMap.get(fn).close();
			}
			bwMap.clear();
			long endTime = System.currentTimeMillis();
			System.err.println(DateUtil.convertMillsToTime(endTime - startTime));
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			try{
				if(fr != null){
					fr.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(br != null){
					br.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(fw != null){
					fw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(bw != null){
					bw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


 

3.3     第三种方法：

与第二种方法基本相同，在此基础上，优化一边取值，一边写文件的过程，而是先写到内存中，当达到1000后，再一起写入文件中。大约耗时52多分钟，这个是实际运行完的，在中午去吃饭的时候让它自己跑完的。

/**
	 * 大文件分割为小文件
	 * @param ipFile
	 * @param numberOfFile
	 */
	public void splitFile3(File ipFile,int numberOfFile){
		BufferedReader br = null;
		FileReader fr = null;
		BufferedWriter bw = null;
		FileWriter fw = null;
		long startTime = System.currentTimeMillis();
		try{
			fr = new FileReader(ipFile);
			br = new BufferedReader(fr);
			String ipLine = br.readLine();
			while(ipLine != null){
				int hashCode = ipLine.hashCode();
				hashCode = hashCode < 0 ? -hashCode : hashCode;
				int fileNum = hashCode % numberOfFile;
				File file = new File("e:/tmp/ip/"+ fileNum + ".txt");
				if(!file.exists()){
					file.createNewFile();
					fw = new FileWriter(file,true);
					bw = new BufferedWriter(fw);
					bwMap.put(fileNum, bw);
					dataMap.put(fileNum, new LinkedList<String>());
				}else{
					List<String> list = dataMap.get(fileNum);
					list.add(ipLine + "\n");
					if(list.size() % 1000 == 0){
						BufferedWriter writer = bwMap.get(fileNum);
						for(String line : list){
							writer.write(line);
						}
						writer.flush();
						list.clear();
					}
				}
				ipLine = br.readLine();
			}
			for(int fn : bwMap.keySet()){
				List<String> list = dataMap.get(fn);
				BufferedWriter writer = bwMap.get(fn);
				for(String line : list){
					writer.write(line);
				}
				list.clear();
				writer.flush();
				writer.close();
			}
			bwMap.clear();
			long endTime = System.currentTimeMillis();
			System.err.println(DateUtil.convertMillsToTime(endTime - startTime));
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			try{
				if(fr != null){
					fr.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(br != null){
					br.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(fw != null){
					fw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(bw != null){
					bw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


 

3.4     第四种方法：

在第三种方法基础上作进一步优化，不同的是，把创建1000个流对象放到循环外面。大约耗时13分钟35秒。这个方法实在比第三种方法快了4倍左右，但在我觉得，这时间还是有点说不过去呀。

/**
	 * 大文件分割为小文件
	 * @param ipFile
	 * @param numberOfFile
	 */
	public void splitFile4(File ipFile,int numberOfFile){
		BufferedReader br = null;
		FileReader fr = null;
		BufferedWriter bw = null;
		FileWriter fw = null;
		long startTime = System.currentTimeMillis();
		try{
			fr = new FileReader(ipFile);
			br = new BufferedReader(fr);
			String ipLine = br.readLine();
			//先创建文件及流对象方便使用
			for(int i=0;i<numberOfFile;i++){
				File file = new File("e:/tmp/ip1/"+ i + ".txt");
				bwMap.put(i, new BufferedWriter(new FileWriter(file,true)));
				dataMap.put(i, new LinkedList<String>());
			}
			while(ipLine != null){
				int hashCode = ipLine.hashCode();
				hashCode = hashCode < 0 ? -hashCode : hashCode;
				int fileNum = hashCode % numberOfFile;
				List<String> list = dataMap.get(fileNum);
				list.add(ipLine + "\n");
				if(list.size() % 1000 == 0){
					BufferedWriter writer = bwMap.get(fileNum);
					for(String line : list){
						writer.write(line);
					}
					writer.flush();
					list.clear();
				}
				ipLine = br.readLine();
			}
			for(int fn : bwMap.keySet()){
				List<String> list = dataMap.get(fn);
				BufferedWriter writer = bwMap.get(fn);
				for(String line : list){
					writer.write(line);
				}
				list.clear();
				writer.flush();
				writer.close();
			}
			bwMap.clear();
			long endTime = System.currentTimeMillis();
			System.err.println(DateUtil.convertMillsToTime(endTime - startTime));
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			try{
				if(fr != null){
					fr.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(br != null){
					br.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(fw != null){
					fw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(bw != null){
					bw.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


 

 

3.5     第五种方法：

使用多线程，未成功实现优化。只是给出思路如下：读取1亿数据的文件，循环读取每个IP，计算其散列值，取模1000，之后把其放到对应的队列中，当其队列超过1000时，启动一个服务线程把数据写入文件中。（也即主线程只负责计算，由其他线程负责写）

 

 

3.6     运行结果：

1、第一次分割1亿数据的大文件，实在是太慢，运行差不多一小时，才分割出300W数据，耗时超过2个钟头

2、第二次分割1亿数据的大文件，经过优化后，虽然比第一次有提升，但是还是很慢，耗时超过1个钟头.

3、第三次分割1亿数据的大文件，经过优化后，虽然比第二次有提升，但是还是很慢,需耗时52.0分3.6秒

4、第四次分割1亿数据的大文件，经过优化后，耗时13.0分35.10400000000004秒

4      统计

各个文件中出现次数最多的IP（可能有多个）:

采用的方法是一边统计各个IP出现的次数，一边算次数出现最大那个IP。

 

/**
	 * 统计，找出次数最多的IP
	 * @param ipFile
	 */
	public void read(File ipFile){
		BufferedReader br = null;
		FileReader fr = null;
		long startTime = System.currentTimeMillis();
		try{
			fr = new FileReader(ipFile);
			br = new BufferedReader(fr);
			String ipLine = br.readLine();
			while(ipLine != null){
				ipLine = ipLine.trim();
				Integer count = ipNumMap.get(ipLine);
				if(count == null){
					count = 0;
				}
				count ++;
				ipNumMap.put(ipLine, count);
				
				if(count >= ipMaxNum){
					if(count > ipMaxNum){
						keyList.clear();
					}
					keyList.add(ipLine);
					ipMaxNum = count;
				}
				ipLine = br.readLine();
			}
			long endTime = System.currentTimeMillis();
			System.err.println(ipFile.getName()+":"+DateUtil.convertMillsToTime(endTime - startTime));
			totalTime += (endTime - startTime);
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			try{
				if(fr != null){
					fr.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
			try{
				if(br != null){
					br.close();
				}
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


 

4.1     运行结果：

1、从1000个文件中查询Ip次数最多的Ip，10.164.143.57:24,3.0分18.748999999999995秒

2、从1000个文件中查询Ip次数最多的Ip，10.164.143.57:24,3.0分27.366000000000014秒

3、从1000个文件中查询Ip次数最多的Ip，10.164.143.57:24,2.0分42.781000000000006秒

 

 

5      以上代码的公共变量

public final Map<Integer,BufferedWriter> bwMap = new HashMap<Integer,BufferedWriter>();//保存每个文件的流对象
public final Map<Integer,List<String>> dataMap = new HashMap<Integer,List<String>>();//分隔文件用
private Map<String,Integer> ipNumMap = new HashMap<String, Integer>();//保存每个文件中的每个IP出现的次数
	private List<String> keyList = new LinkedList<String>();//保存次数出现最多的IP
	private int ipMaxNum = 0;//次数出现最多的值
	private long totalTime = 0;//计算统计所耗的时间


 

 

6      Main

public static void main(String[] args) {
/*
	 * 1、第一次生成1亿(实际上最多为16581375)的ip地址，需要时间为3分多钟不到4分钟。
	 */
		/*TooMuchIpFile tooMuchIpFile = new TooMuchIpFile();
		File ipFile = new File("e:/ipAddr.txt");
		try {
			ipFile.createNewFile();
		} catch (IOException e) {
			e.printStackTrace();
		}
		tooMuchIpFile.gernBigFile(ipFile, 100000000);*/

	
//		System.err.println("128.128.80.226".hashCode()%1000);
//		System.err.println("128.128.80.227".hashCode());
//		System.err.println("10.128.80.227".hashCode());
//		System.err.println("10.0.80.227".hashCode());
		
		
		/*
		 * 1、第一次分割1亿数据的大文件，实在是太慢，运行差不多一小时，才分割出300W数据，耗时超过2个钟头
		 * 2、第二次分割1亿数据的大文件，经过优化后，虽然比第一次有提升，但是还是很慢，耗时超过1个钟头.
		 * 3、第三次分割1亿数据的大文件，经过优化后，虽然比第二次有提升，但是还是很慢,需耗时52.0分3.6秒
		 * 4、第四次分割1亿数据的大文件，经过优化后，耗时13.0分35.10400000000004秒
	 */
		TooMuchIpFile tooMuchIpFile = new TooMuchIpFile();
		File ipFile = new File("e:/ipAddr.txt");
		tooMuchIpFile.splitFile4(ipFile, 1000);
		
		
		/*
		 * 1、从1000个文件中查询Ip次数最多的Ip，10.164.143.57:24,3.0分18.748999999999995秒
		 * 2、从1000个文件中查询Ip次数最多的Ip，10.164.143.57:24,3.0分27.366000000000014秒
		 * 3、从1000个文件中查询Ip次数最多的Ip，10.164.143.57:24,2.0分42.781000000000006秒
		 */
//		TooMuchIpFile tooMuchIpFile = new TooMuchIpFile();
//		File ipFiles = new File("e:/tmp/ip1/");
//		for (File ipFile : ipFiles.listFiles()) {
//			tooMuchIpFile.read(ipFile);
//			tooMuchIpFile.ipNumMap.clear();
//		}
//		System.err.println("======================出现次数最多的IP==================");
//		for(String key: tooMuchIpFile.keyList){
//			System.err.println(key + ":" + tooMuchIpFile.ipMaxNum);
//		}
//		System.err.println(DateUtil.convertMillsToTime(tooMuchIpFile.totalTime));
	}


 

psyuhen
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
提取出某日访问网站次数最多的那K个IP
03-25
NULL 博文链接：https://yueyemaitian.iteye.com/blog/1180299
分治法+Hash处理海量日志数据
03-20 198
海量日志数据，提取出某日访问百度次数最多的那个IP。首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最...
百度面试题——海量日志数据，提取出某日访问百度次数最多的那个IP
weixin_45221012的博客
04-08 1007
海量日志数据，找出访问次数最多的IP 分而治之，化整为零 Counter统计函数 sorted排序函数 hash函数：相同的字符串，经过hash计算得出结果肯定是相同的； 不同的字符串，经过hash计算结果相同的可能性极小。
JAVA-如何从海量日志中提取出某日访问百度次数最多的IP
qq_30942697的博客
10-29 473
JAVA-如何从海量日志中提取出某日访问百度次数最多的IP
海量数据处理方案——转载总结
Zeroowt的博客
05-16 512
转载于:公众号大数据梦想家 海量日志数据，提取出某日访问百度次数最多的那个IP 首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。 搜索引擎会通过日志文件把用户每次检索使用的所
【算法】--海量日志数据，提取出某日访问次数最多的那个IP
怀揣梦想 努力前行
10-29 1683
转自 https://github.com/yoghurtjia/-python-BAT-/blob/master/most_common_ip.py 海量日志数据，提取出某日访问次数最多的那个IP 解决思路：因为问题中提到了是海量数据，所以我们想把所有的日志数据读入内存，再去排序，找到出现次数最多的，显然行不通了。这里我们假设内存足够，我们可以仅仅只用几行代码，就可以求出最终的结果    代...
c语言如何对海量数据进行处理
08-25
1. 给定a、b两个文件，各存放50亿个url，每个url...4. 海量日志数据，提取出某日访问百度次数最多的那个IP。（利用hash分而治之，然后上归并，堆） 5. 在2.5亿个整数中找出不重复的整数，内存不足以容纳这2.5亿个整数。
iOS实现百度外卖头像波浪的效果
09-01
对于现在很多人来说,叫外卖就成了不可或缺的习惯。某日瞬间发现百度外卖的APP波浪效果很是吸引人，相比较其他的外卖APP，颜值略高些.(淘宝也有波浪的效果)，遂就思考如何实现这种"浪"的效果，下面来一起看看。
基于Java的砂石矿山管理系统的设计与实现+毕业论文
07-09
员工加班时长查询,查询某个员工从某月某日到某月某日的总加班时长. 5.其他账目登记 输入账款(给一个输入框填写账目名称,例如油款)(另给一个输入框输入价格,例如75000元)、时间， 支付状态（已付账，未付账）
毕业设计 基于Apache Echarts的天气监测数据可视化系统设计与实现
最新发布
11-14
2、基于express的数据分析服务端 3、mysql数据库服务 4、服务提供商: ​ 项目部署：腾讯云服务器 ​ 数据集来源：心知天气，高德开放平台 ​ 地图服务：高德地图，Axhub 数据可视化设计 2）数据可视化 0、时钟 ...
海量日志数据，提取出某日访问百度次数最多的那个IP。
yxccc的博客
12-17 3330
题目: 海量日志数据，提取出某日访问百度次数最多的那个IP。算法思想：分而治之+Hash 1.IP地址最多有2^32=4G种取值情况，所以不能完全加载到内存中处理；2.可以考虑采用“分而治之”的思想，按照IP地址的hash(ip)%1024,把海量IP日志分别存储到1024个小文件中。这样，每个小文件最多包含4MB个IP地址；3.对于每个小文件，可以构建一个ip为key，出现次数为value的H
算法：海量日志数据，提取出某日访问百度次数最多的那个IP
热门推荐
踏雁寻花
03-05 1万+
首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。 或者如下阐述（雪域
提取出某日访问百度次数最多的IP
甜咖啡的专栏
05-03 3385
问题描述：海量日志数据，提取出某日访问百度次数最多的那个IP。 方法1: 计数法     假设一天之内某个IP访问百度的次数不超过40亿次,则访问次数可以用unsigned表示.用数组统计出每个IP地址出现的次数,  即可得到访问次数最大的IP地址.     IP地址是32位的二进制数,所以共有N=2^32=4G个不同的IP地址, 创建一个unsigned count[N];的数
解题笔记（9）——提取某日访问次数最多的那个IP
wuzhekai的专栏
07-22 3668
问题描述：从海量数据日志中，提取出某日访问次数最多的那个IP。        思路：对于海量数据的处理，主要采取的策略就是分而治之，即缩减问题的规模，将一个大的问题划分成若干等价的小问题。然后解决这些小问题，最后将获得的小问题解综合起来，得出原问题的解。用到比较多的技术主要有散列
提取出某日访问百度次数最多的那个IP
分享专栏一一一每天进步一点点
08-12 7501
问题描述：海量日志数据，提取出某日访问百度次数最多的那个IP。 方法: 计数法     假设一天之内某个IP访问百度的次数不超过40亿次,则访问次数可以用unsigned表示.用数组统计出每个IP地址出现的次数,  即可得到访问次数最大的IP地址.     IP地址是32位的二进制数,所以共有N=2^32=4G个不同的IP地址, 创建一个unsigned count[N];的数组
海量日志提取访问次数最多的ＩＰ
雪雪
03-11 819
方法: 计数法 假设一天之内某个IP访问百度的次数不超过40亿次,则访问次数可以用unsigned表示.用数组统计出每个IP地址出现的次数,即可得到访问次数最大的IP地址. IP地址是32位的二进制数,所以共有N=2^32=4G个不同的IP地址, 创建一个unsigned count[N];的数组,即可统计出每个IP的访问次数,而sizeof(count) == 4G*4=...
用Java实现输入某年某月某日，判断这一天是今年的哪一天。
03-07
可以使用Java中的Calendar类来实现。具体实现方法可以参考以下代码： ``` import java.util.Calendar; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

psyuhen

你的鼓励是我最大的动力谢谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值