『壹』 java遍历大数据量比较一个内容，怎样写效率会快点

我觉得比较靠谱的就是先对大数据量的数据进行索引，缩小比较的范围，比如原来可能是:
1,2,3,4,5,6,7,8,9,10...
这是原始数据，那么我们可以做索引（当然不同的数据索引方式要重新设计合理的索引方案）
比如
1-5: [1,2,3,4,5]
6-10: [6,7,8,9,10]
.....
此时需要比较2， 直接定位到了 1-5的索引，那么我们的比较次数就变少了，大概就是这个思想，缩小比较范围

『贰』 大数据量 用rownum 分页查询 order by 会导致执行很慢， 怎么办

请查考这两篇文章

《几种分页算法》
http://blog.csdn.net/jww2002/articles/558151.aspx
《海量数据库的查询优化及分页算法方案》
http://blog.csdn.net/chenjinjie/archive/2007/05/28/1628355.aspx

『叁』 关于Java的分页算法，急！

使用分页类，直接调用就可以，代码如下：

package com.godwin.news.util;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;

/**
* 分页类,用于封闭分页显示信息
*
* @author javabs
*
*/
public class Pager {

// 当前页
private int currentPage;
// 总页数
private int totalPage;
// 总记录数
private int totalRecord;
// 每页条数
private int pageSize;
// 是否有下一页
private int hasNext;
private ArrayList keys;
private ArrayList values;
// 查询串
private String queryString;
// 首页
private String firstLink;
// 上一页
private String previousLink;
// 下一页
private String nextLink;
// 尾页
private String lastLink;
// 链接
private String forScriptLink;

public Pager(int pageSize, String queryString) {
keys = new ArrayList();
values = new ArrayList();
setQueryString(queryString);
setPageSize(pageSize);
}

public String getForScriptLink() {
if (keys.contains("toPage"))
removeKey("toPage");
String tmp = getQueryString();
if (tmp.length() == 0)
return "?";
else
return "?" + tmp + "&";
}

public int getCurrentPage() {
return currentPage;
}

public void setCurrentPage(String toPage) {
int tmpage = 1;
try {
tmpage = Integer.parseInt(toPage);
} catch (NumberFormatException e) {
tmpage = 1;
}
if (tmpage < 1)
tmpage = 1;
else if (tmpage > getTotalPage())
tmpage = getTotalPage();
currentPage = tmpage;
}

public String getFirstLink() {
return getQueryStr(1);
}

public int getHasNext() {
int i = 1;
if (getCurrentPage() >= getTotalPage())
i = 0;
return i;
}

public String getLastLink() {
return getQueryStr(getTotalPage());
}

public String getNextLink() {
return getQueryStr(currentPage == totalPage ? currentPage : (currentPage + 1));
}

public int getPageSize() {
return pageSize;
}

public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}

public String getPreviousLink() {
return getQueryStr(currentPage == 1 ? currentPage : currentPage - 1);
}

public void setPreviousLink(String previousLink) {
this.previousLink = previousLink;
}

public String getQueryString() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < keys.size(); i++) {
String key = (String) keys.get(i);
String value = (String) values.get(i);
sb.append("&");
sb.append(key);
sb.append("=");
sb.append(value);
}

return sb.delete(0, 1).toString();
}

public void setQueryString(String queryString) {
if (queryString != null) {
String s[] = queryString.split("&");
for (int i = 0; i < s.length; i++) {
String s1[] = s[i].split("=");
if (s1.length == 2) {
keys.add(s1[0]);
values.add(s1[1]);
} else {
keys.add(s1[0]);
values.add("");
}
}

}
}

public int getTotalPage() {
return totalPage;
}

public void setTotalPage() {
if (totalRecord % pageSize == 0) {
totalPage = totalRecord / pageSize;
totalPage = totalPage == 0 ? 1 : totalPage;
}
else
totalPage = totalRecord / pageSize + 1;
}

public int getTotalRecord() {
return totalRecord;
}

public void setTotalRecord(int totalRecord) {
this.totalRecord = totalRecord;
setTotalPage();
}

public String[] getQueryParameterValues(String key) {
return getQueryParameterValues(key, "UTF-8");
}

public String[] getQueryParameterValues(String key, String decode) {
ArrayList ret = new ArrayList();
for (int i = 0; i < keys.size(); i++)
if (((String) keys.get(i)).equals(key))
try {
ret.add(URLDecoder.decode((String) values.get(i), decode));
} catch (UnsupportedEncodingException e) {
ret.add((String) values.get(i));
}

if (ret.size() == 0)
return null;
String strArr[] = new String[ret.size()];
for (int i = 0; i < ret.size(); i++)
strArr[i] = (String) ret.get(i);

return strArr;
}

public String getQueryParameter(String key) {
return getQueryParameter(key, "UTF-8");
}

public String getQueryParameter(String key, String decode) {
String value = "";
if (key != "toPage") {
try {
value = URLDecoder.decode(getValue(key), decode);
} catch (UnsupportedEncodingException e) {
value = getValue(key);
}
} else {
int tmpage = 1;
try {
value = getValue(key);
tmpage = Integer.parseInt(value);
} catch (NumberFormatException e) {
tmpage = 1;
} catch (NullPointerException e1) {
tmpage = 1;
}
if (tmpage < 1)
tmpage = 1;
else if (tmpage > getTotalPage())
tmpage = getTotalPage();
value = (new StringBuffer(String.valueOf(tmpage))).toString();
}
return value;
}

public void setQueryParameter(String key, String value) {
if (key.equals("toPage"))
removeKey(key);
keys.add(key);
values.add(value);
}

public String getQueryStr(int toPage) {
setQueryParameter("toPage", (new StringBuffer(String.valueOf(toPage))).toString());
return "?" + getQueryString();
}

private String getValue(String key) {
String ret = "";
for (int i = 0; i < keys.size(); i++) {
if (!((String) keys.get(i)).equals(key))
continue;
ret = (String) values.get(i);
break;
}

return ret;
}

private void removeKey(String key) {
for (int i = 0; i < keys.size(); i++) {
if (!((String) keys.get(i)).equals(key))
continue;
keys.remove(i);
values.remove(i);
break;
}

}

public static void main(String args[]) {
String str = "a=中文aa&b=2&c=3&c=4&c=5";
Pager page = new Pager(2, str);
page.setTotalRecord(10);
page.setCurrentPage("1");
System.out.println(page.getFirstLink());
System.out.println(page.getPreviousLink());
System.out.println(page.getNextLink());
System.out.println(page.getLastLink());
String s = page.getQueryParameter("a");
System.out.println("s: " + s);
}
}

『肆』 java 大数据怎么做

Java是编程语言；
大数据是一个概念，包含的技术较多，比如Hadoop、Spark、Storm等；
学习大数据先要学习Java，Java是基础，而大数据比较核心的两个课程是HADOOP、SPARK。

『伍』 java大数据量分批处理怎么实现

读取数据估计是没办法了，重点可以放在写入的操作上，粗略的认为，你使用框内架进行数据库写容入操作还不如用使用java原生的jdbc进行操作然后使用jdbc 的原生的批处理，我觉得肯定比框架快。我记得我当时插入10w条数据，只用了3秒，不过用的是oracle数据库。进行边读取边插入，这样占用的内存也相对小一些

『陆』 求个java分页最优算法，不用代码，给我个思路就行，不要那种百度一搜就出来的那个

分页不是你这样整的,这样分页的意义就不存在了.
只所以分页不仅仅是因为在一个页面显示那么多内容不太好,更因为对于数据库大数据量的查询.所以没有什么储存查询所有记录的totalV.
根据当前页数和每页的记录数去确定下一页或上一页的记录从m到n.Mysql数据库查询用limit(m,n),Oracle的话用子查询.
而开发中一般都是写个分页组件的,将所有的一切封装到一个标签中,对外只提供请求的几个参数.

『柒』 java怎么在数据超过百万后分页导出

用过POI的人都知道，在POI以前的版本中并不支持大数据量的处理，如果数据量过多还会常报OOM错误，
这时候调整JVM的配置参数
也不是一个好对策（注：
jdk在32位系统中支持的内存不能超过2个G，而在64位中没有限制，但是在64位的系统中，性能并不是太好
）,好在POI3.8版本新出来了一个SXSSFWorkbook对象，它就是用来解决大数据量以及超大数据量的导入导出操作的，但是SXSSFWorkbook只支持.xlsx格式，不支持.xls格式的Excel文件。
这里普及一下，在POI中使用HSSF对象时，excel 2003最多只允许存6553数据，一般用来处理较少的数据量，这时对于百万级别数据，Excel肯定
容纳不了，而且在计算机性能稍低的机器上测试，就很容易导致堆溢出。当我升级到XSSF对象时，它可以直接支持excel2007以上版本，因为它采用
ooxml格式。这时excel可以支持1048576条数据，单个sheet表就支持近104
万条数据了,虽然这时导出100万数据能满足要求，但使用XSSF测试后发现偶尔还是会发生堆溢出，所以也不适合百万数据的导出。现在我们知道excel2007及以上版本可以轻松实现存储百万级别的数据，但是系统中的大量数据是如何能够快速准确的导入到excel中这好像是个难题，对于一般的web系统，我们为了解决成本，基本都是使用的入门级web服务器tomcat，既然我们不推荐调整JVM的大小，那我们就要针对我们的代码来解决我们要解决的问题。在POI3.8之后新增加了一个类，
SXSSFWorkbook
，采用当数据加工时不是类似前面版本的对象，它可以控制excel数据占用的内存，他通过控制在内存中的行数来实现资源管理，即当创建对象超过了设定的行数，它会自动刷新内存，将数据写入文件，
这样导致打印时，占用的CPU，和内存很少。但有人会说了，我用过这个类啊，他好像并不能完全解决，当数据量超过一定量后还是会内存溢出的，而且时间还很长。对你只是用了这个类，但是你并没有针对你的需求进行相应的设计，仅仅是用了，所以接下来我要说的问题就是，如何通过SXSSFWorkbook以及相应的写入设计来实现百万级别的数据快速写入。
我先举个例子，以前我们[数据库
中存在大量的数据，我们要查询，怎么办？我们在没有经过设计的时候是这样来处理的，先写一个集合，然后执行jdbc，将返回的结果赋值给list，然后再返回到页面上，但是当数据量大的时候，就会出现数据无法返回，内存溢出的情况，于是我们在有限的时间和空间下，通过分页将数据一页一页的显示出来，这样可以避免了[大数据
量数据对内存的占用，也提高了用户的体验，在我们要导出的百万数据也是一个道理，内存突发性占用，我们可以限制导出数据所占用的内存，
这里我先建立一个list容器，list中开辟10000行的存储空间，每次存储10000行，用完了将内容清空，然后重复利用
，这样就可以有效控制内存，所以我们的设计思路就基本形成了，所以分页数据导出共有以下3个步骤：
1、求数据库中待导出数据的行数
2、根据行数求数据提取次数
3、按次数将数据写入文件

『捌』 java 大数据 指多少条数据

我想你问的是在数据库中的表要有多少条才能算大数据。其实您清楚，如果表中的数据超过千万以上，再好索引也会导致查询变慢。现在的海量数据一般都是PT级的，数据存放也不仅限于传统的关系型数据库。

『玖』 请教大数据量查询怎么分页查询

有些绑定控件自带分页功能的。如果没有就只能手写分页功能了。

『拾』 Java如何处理大数据的

文件读取：首先是一个文件上传，数据入库，10-200万条不等，这里主要考虑到一次性读取，JVM分配出来的栈内存不一定会够（个人对内存这一块还是处于一知半解的状态，所以比较谨慎，若诸位大神有好的认知，希望评论留下地址分享一下），是依行读取数据，设定一个批量值，当读取的数据达到一定量之后，执行批量入库操作，清空集合，再接着读取。
//读取文件内容
while((s = br.readLine())!=null){
//判断是否达到单次处理量
if(num%leadingNum==0&&num!=0){
int a = stencDao.insertBatch(listBean);
if(a!=leadingNum){
flag = false;
}
//清空集合
listBean.clear();
}
String value = s.trim();
//将读取到的内容放入集合中
if(!value.equals("")){
StencilCustomer bean = new StencilCustomer();
bean.setCustomerPhone(value);
bean.setLinkStencilId(id);
listBean.add(bean);
num ++;
}
}
数据处理：这里的思路也是将数据小化然后处理，这里使用了多线程，设定单个线程处理量，然后开启多个线程处理，这里需要考虑你的服务器的承载能力，如果线程开得太多了，处理不过来，会出现蹦死的情况。例如200万数据，我开了20个线程，单个线程处理600条。
//建立一个线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
minTaskNumber, maxTaskNumber, 3L, TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(minTaskNumber),
new ThreadPoolExecutor.DiscardOldestPolicy());
//当正在执行的线程数达到最大执行线程数的时候等待
boolean flag = true;
while(flag){
Thread.sleep(1000);//休眠2ms查询一次
int c = threadPool.getActiveCount();//线程池中活动中的线程数量
if(c<maxTaskNumber){
flag = false;
}
}
上面的代码是我对线程池的一个控制，控制服务器一直最大线程执行，Thread.sleep(1000);用while的时候，这个休眠最好不要去掉，去掉之后很影响执行效率