JAVA数据库取数据万用方法
Java千万级别数据处理与优化
Java千万级别数据处理与优化随着互联网的发展,数据规模异常的庞大。
对于Java开发人员来说,面对这种情况,我们需要从性能和优化的角度思考,从而使我们的程序在处理海量数据时更有效率、更加可靠。
一、数据处理1. 数据读取优化数据读取是数据处理的第一步,良好的数据读取优化可以最大限度地提高程序的效率。
在数据读取方面,我们需要注重以下几个方面的优化:(1)缓存读取:对于内存中需要反复读取的数据,我们应该缓存读取,避免多次访问磁盘带来的性能损耗。
(2)文件切割:对于大文件的读取,我们可以将其切割成多个小文件,以便于多线程同时读取,并且有效减少了每个线程读取文件大小的开销。
(3)使用BufferedInputStream和BufferedReader:Java中提供了BufferedInputStream和BufferedReader这两种缓存读取的方式,可以有效地提高文件读取的效率。
2. 数据存储优化在面对千万级别的数据时,数据的存储也是我们需要优化的重要环节。
在数据存储方面,我们需要注重以下几个方面的优化:(1)使用内存存储:对于频繁读写的数据,我们应该尽量使用内存存储,避免频繁的磁盘读写,从而提高程序效率。
(2)使用NoSQL数据库:对于大规模的数据存储,我们可以使用NoSQL数据库来代替传统的关系型数据库,NoSQL数据库对分布式存储的支持更加完善,可以提高数据存储的效率。
(3)批量操作:在实际开发中,我们应该尽量采用批量操作的方式进行数据存储,这样可以有效提高数据处理的效率。
二、数据处理算法1. 分治算法分治算法是一种非常常见的算法,可以用于解决很多常见的数据处理问题。
在数据分析处理过程中,分治算法可以用来将庞大的数据集划分成多个小数据集,然后并行处理每个小数据集,最后合并结果。
通过这种方法,可以有效提高程序的处理效率。
2. MapReduce算法MapReduce算法是一种分布式数据处理算法,可以对千万级别的数据进行优化。
java中的try语句
java中的try语句
嘿,朋友!你知道在 Java 里那个神奇的 try 语句吗?就好像是你出门时带着的一把保护伞。
比如说,你要从一个文件里读取数据(这就好比要从一个神秘的宝箱里拿宝贝),可万一这个文件不存在或者出了啥问题,那可就糟糕啦!这时候 try 语句就闪亮登场啦!
想象一下,你正在写一段代码,要打开一个网络连接来获取信息。
如果网络突然断了,程序不得崩溃啊?但是有了 try 语句,它就会说:“别怕,我来罩着!” 然后把可能出问题的那段代码放在 try 块里。
就像你走在一条充满陷阱的路上,try 语句就是提前给你围起来的保护栏,让你能相对安全地通过。
再比如说,你要调用一个可能会抛出异常的方法,把这调用放在try 里,不就相当于给这个操作穿上了一层防护服嘛!
总之,Java 中的 try 语句简直就是我们的救星,能在代码可能出现意外的时候,帮我们稳住局面,避免整个程序乱套。
你说,这么好用的东西,咱们能不好好利用吗?
我的观点就是:在 Java 编程中,一定要熟练运用 try 语句,它能让我们的代码更健壮,更可靠!。
java从数据库读取千万数据进行遍历生成文件的方法
Java从数据库读取千万数据进行遍历生成文件的方法在实际的开发中,我们经常会遇到需要从数据库中读取大量数据并进行处理的情况。
本文将介绍如何使用Java从数据库读取千万数据,并进行遍历生成文件的方法。
1. 数据库准备首先,我们需要准备一个数据库,并在其中创建一个表来存储需要读取的数据。
假设我们有一个名为user的表,包含以下字段:•id:用户ID,类型为整数•name:用户名,类型为字符串•age:用户年龄,类型为整数2. 导入数据库驱动在Java程序中连接数据库,我们需要导入相应的数据库驱动。
以MySQL为例,我们可以使用mysql-connector-java驱动。
可以在Maven项目的pom.xml文件中添加以下依赖:<dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.26</version></dependency></dependencies>3. 连接数据库在Java程序中连接数据库,需要使用java.sql包中的相关类。
首先,我们需要建立数据库连接,并创建一个Connection对象。
可以编写一个工具类来封装数据库连接的操作,例如:import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class DBUtil {private static final String URL = "jdbc:mysql://localhost:3306/mydb";private static final String USERNAME = "root";private static final String PASSWORD = "123456";public static Connection getConnection() {Connection connection = null;try {Class.forName("com.mysql.cj.jdbc.Driver");connection = DriverManager.getConnection(URL, USERNAME, PASSWORD); } catch (ClassNotFoundException | SQLException e) {e.printStackTrace();}return connection;}}以上代码中,getConnection方法用于获取数据库连接。
Java实现大批量数据导入导出(100W以上) -(二)导出
Java实现⼤批量数据导⼊导出(100W以上) -(⼆)导出使⽤POI或JXLS导出⼤数据量(百万级)Excel报表常常⾯临两个问题:1. 服务器内存溢出;2. ⼀次从数据库查询出这么⼤数据,查询缓慢。
当然也可以分页查询出数据,分别⽣成多个Excel打包下载,但这种⽣成还是很缓慢。
⼤数据量导⼊请参考:那么如何解决呢?我们可以借助XML格式利⽤模板替换,分页查询出数据从磁盘写⼊XML,最终会以Excel多sheet形式⽣成。
亲测2400万⾏数据,⽣成Excel⽂件4.5G,总耗时1.5分钟。
我利⽤StringTemplate模板解析技术对XML模板进⾏填充。
当然也可以使⽤FreeMarker, Velocity等Java模板技术实现。
⾸先引⼊StringTemplate所需Jar包:使⽤技术为 stringTemplatepom.xml:1 <dependency>2<groupId>antlr</groupId>3<artifactId>antlr</artifactId>4<version>2.7.7</version>5</dependency>67<dependency>8<groupId>org.antlr</groupId>9<artifactId>stringtemplate</artifactId>10<version>3.2.1</version>11</dependency>⾸先准备导出Excel模板,然后打开-》另存为-》选择格式为XML,然后⽤⽂本打开XML,提取XML头模板(head.st可通⽤),数据体模板(boday.st):head.st可通⽤:1<?xml version="1.0"?>2<?mso-application progid="Excel.Sheet"?>3<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"4 xmlns:o="urn:schemas-microsoft-com:office:office"5 xmlns:x="urn:schemas-microsoft-com:office:excel"6 xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"7 xmlns:html="/TR/REC-html40">8<DocumentProperties xmlns="urn:schemas-microsoft-com:office:office">9<Created>1996-12-17T01:32:42Z</Created>10<LastSaved>2013-08-02T09:21:24Z</LastSaved>11<Version>11.9999</Version>12</DocumentProperties>13<OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office">14<RemovePersonalInformation/>15</OfficeDocumentSettings>16<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">17<WindowHeight>4530</WindowHeight>18<WindowWidth>8505</WindowWidth>19<WindowTopX>480</WindowTopX>20<WindowTopY>120</WindowTopY>21<AcceptLabelsInFormulas/>22<ProtectStructure>False</ProtectStructure>23<ProtectWindows>False</ProtectWindows>24</ExcelWorkbook>25<Styles>26<Style ss:ID="Default" ss:Name="Normal">27<Alignment ss:Vertical="Bottom"/>28<Borders/>29<Font ss:FontName="宋体" x:CharSet="134" ss:Size="12"/>30<Interior/>31<NumberFormat/>32<Protection/>33</Style>34</Styles>boday.st:1 $worksheet:{2<Worksheet ss:Name="$it.sheet$">3<Table ss:ExpandedColumnCount="$it.columnNum$" ss:ExpandedRowCount="$it.rowNum$" x:FullColumns="1"4 x:FullRows="1" ss:DefaultColumnWidth="54" ss:DefaultRowHeight="14.25">5 $it.rows:{6<Row>7<Cell><Data ss:Type="String">$1$</Data></Cell>8<Cell><Data ss:Type="String">$2$</Data></Cell>9<Cell><Data ss:Type="String">$3$</Data></Cell>10</Row>11 }$12</Table>13</Worksheet>14 }$⽣成⼤数据量Excel类:ExcelGenerator:1package test.exportexcel;23import org.antlr.stringtemplate.StringTemplate;4import org.antlr.stringtemplate.StringTemplateGroup;5import test.exportexcel.bean.Row;6import test.exportexcel.bean.Worksheet;78import java.io.*;9import java.util.ArrayList;10import java.util.List;11import java.util.Random;1213/**14 * 类功能描述:generator big data Excel15 *16 * @author WangXueXing create at 19-4-13 下午10:2317 * @version 1.0.018*/19public class ExcelGenerator {20public static void main(String[] args) throws FileNotFoundException{21 ExcelGenerator template = new ExcelGenerator();22 template.output2();23 }2425/**26 * ⽣成数据量⼤的时候,该⽅法会出现内存溢出27 * @throws FileNotFoundException28*/29public void output1() throws FileNotFoundException{30 StringTemplateGroup stGroup = new StringTemplateGroup("stringTemplate");31 StringTemplate st4 = stGroup.getInstanceOf("test/exportexcel/template/test");32 List<Worksheet> worksheets = new ArrayList<>();3334 File file = new File("/home/barry/data/output.xls");35 PrintWriter writer = new PrintWriter(new BufferedOutputStream(new FileOutputStream(file)));3637for(int i=0;i<30;i++){38 Worksheet worksheet = new Worksheet();39 worksheet.setSheet("第"+(i+1)+"页");40 List<Row> rows = new ArrayList<>();41for(int j=0;j<6000;j++){42 Row row = new Row();43 row.setName1("zhangzehao");44 row.setName2(""+j);45 row.setName3(i+" "+j);46 rows.add(row);47 }48 worksheet.setRows(rows);49 worksheets.add(worksheet);50 }5152 st4.setAttribute("worksheets", worksheets);53 writer.write(st4.toString());54 writer.flush();55 writer.close();56 System.out.println("⽣成excel完成");57 }5859/**60 * 该⽅法不管⽣成多⼤的数据量,都不会出现内存溢出,只是时间的长短61 * 经测试,⽣成2400万数据,2分钟内,4.5G⼤的⽂件,打开⼤⽂件就看内存是否⾜够⼤了62 * 数据量⼩的时候,推荐⽤JXLS的模板技术⽣成excel⽂件,谁⽤谁知道,⼤数据量可以结合该⽅法使⽤63 * @throws FileNotFoundException64*/65public void output2() throws FileNotFoundException{66long startTimne = System.currentTimeMillis();67 StringTemplateGroup stGroup = new StringTemplateGroup("stringTemplate");6869//写⼊excel⽂件头部信息70 StringTemplate head = stGroup.getInstanceOf("test/exportexcel/template/head");71 File file = new File("/home/barry/data/output.xls");72 PrintWriter writer = new PrintWriter(new BufferedOutputStream(new FileOutputStream(file)));73 writer.print(head.toString());74 writer.flush();7576int sheets = 400;77//excel单表最⼤⾏数是6553578int maxRowNum = 60000;7980//写⼊excel⽂件数据信息81for(int i=0;i<sheets;i++){82 StringTemplate body = stGroup.getInstanceOf("test/exportexcel/template/body");83 Worksheet worksheet = new Worksheet();84 worksheet.setSheet(" "+(i+1)+" ");85 worksheet.setColumnNum(3);86 worksheet.setRowNum(maxRowNum);87 List<Row> rows = new ArrayList<>();88for(int j=0;j<maxRowNum;j++){89 Row row = new Row();90 row.setName1(""+new Random().nextInt(100000));91 row.setName2(""+j);92 row.setName3(i+""+j);93 rows.add(row);94 }95 worksheet.setRows(rows);96 body.setAttribute("worksheet", worksheet);97 writer.print(body.toString());98 writer.flush();99 rows.clear();100 rows = null;101 worksheet = null;102 body = null;103 Runtime.getRuntime().gc();104 System.out.println("正在⽣成excel⽂件的 sheet"+(i+1));105 }106107//写⼊excel⽂件尾部108 writer.print("</Workbook>");109 writer.flush();110 writer.close();111 System.out.println("⽣成excel⽂件完成");112long endTime = System.currentTimeMillis();113 System.out.println("⽤时="+((endTime-startTimne)/1000)+"秒");114 }115 }定义JavaBean:WorkSheet.java:1package test.exportexcel.bean;23import java.util.List;45/**6 * 类功能描述:Excel sheet Bean7 *8 * @author WangXueXing create at 19-4-13 下午10:219 * @version 1.0.010*/11public class Worksheet {12private String sheet;13private int columnNum;14private int rowNum;15private List<Row> rows;1617public String getSheet() {18return sheet;19 }20public void setSheet(String sheet) {21this.sheet = sheet;22 }2324public List<Row> getRows() {25return rows;26 }27public void setRows(List<Row> rows) {28this.rows = rows;29 }3031public int getColumnNum() {32return columnNum;33 }34public void setColumnNum(int columnNum) {35this.columnNum = columnNum;36 }3738public int getRowNum() {39return rowNum;40 }41public void setRowNum(int rowNum) {42this.rowNum = rowNum;43 }44 }Row.java:1package test.exportexcel.bean;23/**4 * 类功能描述:Excel row bean5 *6 * @author WangXueXing create at 19-4-13 下午10:227 * @version 1.0.08*/9public class Row {10private String name1;11private String name2;12private String name3;1314public String getName1() {15return name1;16 }17public void setName1(String name1) {1 = name1;19 }2021public String getName2() {22return name2;23 }24public void setName2(String name2) {2 = name2;26 }2728public String getName3() {29return name3;30 }31public void setName3(String name3) {3 = name3;33 }34 }另附实现源码: 此外,⼤数据量并并且Excel列较多时,会出现内存溢出。
mysql jdbc preparedstatement封装的万能改查方法 -回复
mysql jdbc preparedstatement封装的万能改查方法-回复MySQL JDBC PreparedStatement封装的万能改查方法详解在进行数据库操作时,我们经常需要使用到PreparedStatement进行改查操作。
而为了提高代码的复用性和简洁度,我们可以封装一些万能的改查方法,使得代码更加灵活。
下面将一步一步回答你关于MySQL JDBC PreparedStatement封装的万能改查方法的问题。
1. 什么是PreparedStatement?PreparedStatement是Java中的一个接口,它是PreparedStatement 用于预编译SQL语句并可以用于多次执行。
相比于Statement,PreparedStatement具有更高的性能和安全性。
2. 为什么要封装PreparedStatement?封装PreparedStatement可以提高代码的复用性和简洁度。
通过封装,我们可以减少代码的重复编写,同时也能更好地处理和控制SQL语句和参数的传递。
3. 如何封装PreparedStatement的万能改查方法?(1) 创建一个BaseDao类作为公共的数据库操作类,里面封装各种万能改查方法。
(2) 在BaseDao类中,定义一个公共的getConnection方法,用于获取数据库连接。
(3) 在BaseDao类中,定义一个公共的executeUpdate方法,用于执行更新操作。
(4) 在BaseDao类中,定义一个公共的executeQuery方法,用于执行查询操作。
4. executeUpdate方法的封装过程?(1) 在executeUpdate方法中,传入SQL语句和参数。
(2) 获取数据库连接并创建PreparedStatement对象。
(3) 循环遍历参数列表,为SQL语句中的占位符赋值。
(4) 执行SQL语句并返回影响的行数。
(5) 关闭PreparedStatement和数据库连接。
Java线程池+生产者消费者+MySQL读取300万条数据
Java线程池+⽣产者消费者+MySQL读取300万条数据1.1需求数据库300 万条⽤户数据,遍历获取所有⽤户,各种组合关联,获取到⼀个新的json ,存到redis 上。
1.2 难点数据库⽐较多,不可能单线程查询所有的数据到内存。
1.3解决办法多线程读取,⽣产者每次获取200 条数据,消费者去消费。
(这⾥主要是根据MySQL分页去获取下⼀个200 条数据)1.4 代码1.4.1 调⽤⽅法/*** 线程启动*/public void update() {//redis操作类HashRedisUtil redisUtil= HashRedisUtil.getInstance();//⽣产者消费者ProducerConsumer pc = new ProducerConsumer();//数据仓库Storage s = pc.new Storage();ExecutorService service = Executors.newCachedThreadPool();//⼀个线程进⾏查询Producer p = pc.new Producer(s,userMapper);service.submit(p);System.err.println("⽣产线程正在⽣产中。
");//是个线程进⾏修改for(int i=0;i<10;i++){System.err.println("消费线程"+i+"正在消费中。
");service.submit(pc.new Consumer( redisUtil,userMapper,s));}}1.4.2 主要核⼼类package com.ypp.thread;import java.math.BigDecimal;import java.util.Calendar;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Set;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import ng.StringUtils;import org.apache.log4j.Logger;import org.joda.time.LocalDateTime;import com.alibaba.fastjson.JSONObject;import com.ypp.constants.Constants;import erMapper;import er;import erAlis;import erBaseModel;import erVip;import com.ypp.util.HashRedisUtil;import com.ypp.util.JsonUtils;import com.ypp.util.PHPSerializer;public class ProducerConsumer {private static Logger logger = Logger.getLogger(ProducerConsumer.class);//这个page 是核⼼,全局变量,当⽣产者⽣产⼀次,获取200 个⽤户,会把这个page++, 下次获取就是后⼀个200 条⽤户了private static Integer page = 0;//消费者public class Consumer implements Runnable {private HashRedisUtil redisUtil;private UserMapper userMapper;private Storage s = null;public Consumer(HashRedisUtil redisUtil, UserMapper userMapper, Storage s) {super();this.redisUtil = redisUtil;erMapper = userMapper;this.s = s;}public void run() {try {while (true) {User users = s.pop();long bbb = System.currentTimeMillis();// 获取⼀个⽤户的粉丝列表并存到redistry {fansUpdate(users.getToken(), users.getUserId(), redisUtil);} catch (Exception e1) {e1.printStackTrace();}// 获取⼀个⽤户的关注列表,并存到redistry {followUpdate(users.getToken(), users.getUserId(), redisUtil);} catch (Exception e) {e.printStackTrace();}// 获取⼀个⽤户的⿊名单,并存到redistry {blackUpdate(users.getToken(), users.getUserId(), redisUtil);} catch (Exception e) {e.printStackTrace();}// ⽤户基本信息try {userbaseUpdate(users.getToken(), users.getUserId(), redisUtil);} catch (Exception e) {e.printStackTrace();}long ccc = System.currentTimeMillis();System.out.println("⽤户:" + users.getToken() + " 全部总共耗时:" + (ccc - bbb) + "毫秒");Thread.sleep(500);}} catch (InterruptedException e) {e.printStackTrace();}}public List<User> getUserInfo(Integer iThread) {return userMapper.findUserInfo((iThread - 1) * 200 + 1);}/*** ⽤户基本信息修改** @param token* @param myuserId* @param redisUtil* @throws Exception*/private void userbaseUpdate(String token, String myUserId, HashRedisUtil redisUtil) throws Exception {}/*** 更新⼀个⽤户的⿊名单(原来的token改成userID)** @param token* @param string* @param redisUtil* @throws Exception*/private void blackUpdate(String token, String myUserId, HashRedisUtil redisUtil) throws Exception { }/*** 获取⼀个⽤户的关注** @param token* @param string* @param redisUtil* @throws Exception*/private void followUpdate(String token, String myUserId, HashRedisUtil redisUtil) throws Exception { }/*** 获取⼀个⽤户的粉丝列表** @param token* @param userId* @param redisUtil* @throws Exception*/private void fansUpdate(String token, String myUserId, HashRedisUtil redisUtil) throws Exception { }//⽣产者public class Producer implements Runnable {private Storage s = null;private UserMapper mapper ;public Producer( Storage s, UserMapper mapper) {this.s = s;this.mapper = mapper;}public void run() {try {while (true) {System.err.println("当前分页是:"+page+"****************************************");List<User> list= mapper.findUserInfo(page);s.push(list);page++;}} catch (InterruptedException e1) {e1.printStackTrace();}}}//数据仓库public class Storage {BlockingQueue<User> queues = new LinkedBlockingQueue<User>(200);/*** ⽣产** @param p* 产品* @throws InterruptedException*/public void push(List<User> p) throws InterruptedException {for(User user:p){queues.put(user);}}/*** 消费** @return产品* @throws InterruptedException*/public User pop() throws InterruptedException {return queues.take();}}}。
程序员鱼皮 java 后端万用项目模板
程序员鱼皮 java 后端万用项目模板程序员鱼皮 Java 后端万用项目模板概述在 Java 后端开发中,项目模板是一个非常重要的工具。
它可以帮助开发者快速地搭建项目框架、配置环境、引入依赖等,从而节省大量的时间和精力。
本文将介绍程序员鱼皮 Java 后端万用项目模板,包括其特点、使用方法以及常见问题解决方案等。
特点程序员鱼皮 Java 后端万用项目模板具有以下特点:1. 高度可定制化:该项目模板提供了丰富的配置选项,可以根据不同的需求进行定制化设置。
2. 全面覆盖:该项目模板涵盖了常见的后端开发场景,包括 Web 应用、RESTful API、消息队列等。
3. 统一标准:该项目模板遵循了一套统一的代码规范和工程结构标准,使得不同开发者之间可以更加协同地进行开发。
4. 持续更新:该项目模板会持续跟进最新的技术和框架,保证其始终处于最佳状态。
使用方法使用程序员鱼皮 Java 后端万用项目模板非常简单,只需要按照以下步骤进行操作即可:1. 下载项目模板:将程序员鱼皮 Java 后端万用项目模板从官网或者GitHub 上下载到本地。
2. 配置项目信息:根据实际需求修改项目信息,包括项目名称、包名、数据库配置等。
3. 选择开发场景:根据实际需求选择需要使用的开发场景,比如 Web 应用、RESTful API、消息队列等。
4. 运行项目:使用 IDE(比如 IntelliJ IDEA)打开项目,运行主类即可启动应用程序。
常见问题解决方案在使用程序员鱼皮 Java 后端万用项目模板的过程中,可能会遇到一些常见问题。
下面列举了一些常见问题及其解决方案:1. 如何添加新的依赖?答:在 pom.xml 文件中添加新的依赖即可。
具体方法是,在dependencies 标签内添加新的 dependency 标签,并指定 groupId、artifactId 和 version 等信息。
2. 如何修改数据库配置?答:在 application.yml 文件中修改数据库相关配置即可。
java excel导入20万条
java excel导入20万条
在Java中导入20万条Excel数据可以通过以下几种方式来实现:
1. 使用Apache POI库,Apache POI是一个用于读写Microsoft Office文件的开源Java库。
你可以使用Apache POI来读取Excel文件并将数据导入到Java中。
你需要使用XSSFWorkbook和XSSFSheet类来读取Excel文件中的数据。
然后,你可以将读取到的数据存储在Java对象中,或者直接将数据插入到数据库中。
2. 使用JDBC连接Excel文件,你可以使用JDBC(Java Database Connectivity)来连接Excel文件,并通过Java代码将数据导入到数据库中。
首先,你需要使用ODBC(Open Database Connectivity)驱动程序来连接Excel文件,然后使用JDBC来执行插入操作。
3. 使用第三方库,除了Apache POI之外,还有一些其他的第三方库可以用来处理Excel文件,比如JExcelApi、JExcel等。
你可以选择适合你需求的库来实现数据导入操作。
无论你选择哪种方式,都需要注意以下几点:
内存管理,在导入大量数据时,需要注意内存的使用,避免内存溢出的问题。
优化性能,对于大量数据的导入,需要考虑性能优化,比如批量插入、使用索引等方式来提高导入速度。
异常处理,需要处理可能出现的异常情况,比如文件不存在、格式错误等。
总之,导入20万条Excel数据是一个比较大的任务,需要仔细考虑数据量、性能和异常处理等方面的问题,选择合适的方式来实现数据导入操作。
元转万元的注解 java
元转万元的注解java全文共四篇示例,供读者参考第一篇示例:在Java编程中,元和万元是两种不同的货币单位,元是最小的货币单位,一个元等于一元人民币,而万元则是一万元人民币,是千元的计量单位。
在实际的应用中,我们经常需要将元转换为万元,或是反过来,将万元转换为元。
在本文中,我们将介绍如何在Java中实现元和万元之间的相互转换。
一、元转万元我们来看一下如何将元转换为万元。
在Java中,可以使用BigDecimal类来进行精确的数值计算,避免由于浮点运算导致的精度丢失。
以下是一个示例代码:```javaimport java.math.BigDecimal;public class YuanToWan {在上面的代码中,我们首先定义了一个BigDecimal对象yuan,表示要转换的元数值,然后使用divide方法将元除以10000,得到万元的数值。
最后输出转换结果。
三、注意事项在进行元和万元的转换时,需要注意以下几点:1. 使用BigDecimal进行数值计算,在避免精度丢失的也要注意使用适当的精度设置。
2. 在进行元和万元的转换时,要注意单位的换算关系,一万元等于一万元。
3. 可以根据实际需求,将转换功能封装成工具类或方法,方便在项目中使用。
4. 在处理金额时,要注意避免出现负数或非法输入,对输入数据进行合法性检查。
总结在本文中,我们介绍了如何在Java中实现元转万元和万元转元的功能。
通过使用BigDecimal类进行数值计算,可以避免精度丢失的问题,确保计算结果的准确性。
在实际项目中,可以根据具体需求进行功能扩展,或将转换功能封装成工具类,以便在多个模块中重复使用。
希望本文对您有所帮助,谢谢阅读!第二篇示例:在金融领域,经常会涉及到元与万元之间的换算。
元和万元都是人们日常生活中经常使用的货币计量单位,元是较小的单位,万元是较大的单位。
元和万元之间的换算是非常常见的操作,尤其是在金融交易、财务报表、经济分析等领域。
如何提取一个整数中各个位的数字(Java)?
如何提取⼀个整数中各个位的数字(Java)?任意数字的指定位上的数值如何求?⽂章⽬录⽅法解读详细解释⽅法举例⼦(⽔仙花数)⼀、提取各个位数的⽅法?先进⾏整除操作,将要求的数字移动到个位上,在使⽤取余操作,取出最后⼀位上的值。
⼆、⽅法解读1.详细解释⽅法⽅法中第⼀部分(将要求的数字移动到个位上)的意思是:⽤这个整数先整除将要提取的数字所在位的10^(n-1),第⼆部分(在使⽤取余操作,取出最后⼀位上的值):将第⼀部分计算的结果对10取余,即可获得最后⼀位上的值。
既:个位获取: XXX % 10;⼗位获取: XXX /10 % 10;百位获取: XXX / 100 % 10;千位获取: XXXX / 1000 % 10;.............1public class Demo08 {2 public static void main(String[] args) {3 int num = 789456; //操作数4 int gewei = num % 10; //个位:从右往左数第1个数字,⽤操作数整除10^(1-1)在对10取余5 int shiwei = num / 10 % 10; //⼗位:从右往左数第2个数字,⽤操作数整除10^(2-1)在对10取余6 int baiwei = num / 100 % 10; //百位:从右往左数第3个数字,⽤操作数整除10^(3-1)在对10取余7 int qianwei = num / 1000 % 10; //千位:从右往左数第4个数字,⽤操作数整除10^(4-1)在对10取余8 int wanwei = num / 10000 % 10; //万位:从右往左数第5个数字,⽤操作数整除10^(5-1)在对10取余9 int shiwanwei = num / 100000 % 10; //⼗万位:从右往左数第6个数字,⽤操作数整除10^(6-1)在对10取余10 System.out.println("个位:" + gewei);11 System.out.println("⼗位:" + shiwei);12 System.out.println("百位:" + baiwei);13 System.out.println("千位:" + qianwei);14 System.out.println("万位:" + wanwei);15 System.out.println("⼗万位:" + shiwanwei);16 }17}结果输出为:1个位:62⼗位:53百位:44千位:95万位:86⼗万位:778Process finished with exit code 02.举例⼦(⽔仙花数)要求出所有的⽔仙花数。
JAVA导出数据到excel中大数据量的解决方法
JAVA导出数据到excel中⼤数据量的解决⽅法最近在做项⽬功能时,发现有20万以上的数据。
要求导出时直接导出成压缩包。
原来的逻辑是使⽤poi导出到excel,他是操作对象集合然后将结果写到excel中。
使⽤poi等导出时,没有考虑数据量的问题,量⽆法满⾜,有个⼏千⾏jvm就哭了。
更别提⼏万⾏⼏百万⾏数据了。
经过⼀天的研究发现⼀种不会消耗过多内存的⽅法:导出成csv格式⼤数据量的导出成csv格式分为以下⼏步:1.⾸先引⼊需要的jar包⼀下是我maven的配置⽅式<dependency><groupId>org.mvel</groupId><artifactId>mvel2</artifactId><version>2.2.8.Final</version></dependency><dependency><groupId>net.sourceforge.javacsv</groupId><artifactId>javacsv</artifactId><version>2.0</version></dependency>2.以下是具体的执⾏代码,我是⽤的是jdbcTemplatepublic class DownloadVehicleRepair extends AbstractJob {@Autowiredprivate JdbcTemplate jdbcTemplate;@Overrideprotected void executeBusiness(Long aLong) {System.out.println("开始执⾏!!!!!!!!!!");final String fileName = "车辆维修清单.csv";//压缩包⾥⾯的⽂件final String[] header = {"序号", "第三⽅机构代码", "机构名称", "分公司", "合作机构", "单位类别", "主品牌", "品牌名称","被投诉", "涉及欺诈", "⿊名单", "审核状态", "维护时间", "维护⼈员代码"};final String sql = "您需要执⾏sql”;jdbcTemplate.execute(new PreparedStatementCreator() {@Overridepublic PreparedStatement createPreparedStatement(Connection connection) throws SQLException {PreparedStatement pstmt = connection.prepareStatement(sql);return pstmt;}}, new PreparedStatementCallback<Integer>() {@Overridepublic Integer doInPreparedStatement(PreparedStatement preparedStatement) throws SQLException, DataAccessException {ResultSet rs = preparedStatement.executeQuery();try {CsvUtil.writeCsv(RuntimeEnvironmentUtil.getValue(SysConstent.code,SysConstent.path) + "\\VehicleRepairDetail.zip",fileName, header, rs);//RuntimeEnvironmentUtil.getValue()是为了获取你导出到服务器的路径} catch (Exception e) {e.printStackTrace();}return 0;}});System.out.println("导出完成!!!!!!!!!!!");}}3.以下是帮助类public class CsvUtil {// 编码类型public static final Charset CHARSET = Charset.forName("GBK");// 分隔符public static final char DELIMITER = ',';// ⽂件后缀public static final String SUFFIX = ".csv";public static void writeCsv(OutputStream out, String[] header, ResultSet rs)throws IOException, SQLException {CsvWriter writer = null;try {writer = new CsvWriter(out, CsvUtil.DELIMITER, CsvUtil.CHARSET);writeCsv(writer, header, rs);} finally {if (writer != null)writer.close();}}public static void writeCsv(CsvWriter writer, String[] header, ResultSet rs)throws IOException, SQLException {if (header != null)writer.writeRecord(header);ResultSetMetaData md = rs.getMetaData();int columnCount = md.getColumnCount();while (rs.next()) {for (int i = 1; i <= columnCount; i++)writer.write(rs.getString(i));writer.endRecord();}}public static void writeCsv(File file, String[] header, ResultSet rs)throws IOException, SQLException {BufferedOutputStream out = null;FileOutputStream fileOutputStream = null;try {fileOutputStream = new FileOutputStream(file);out = new BufferedOutputStream(fileOutputStream);writeCsv(out, header, rs);} finally {if (out != null) {out.flush();out.close();}if (fileOutputStream != null) {fileOutputStream.close();}}}public static void writeCsv(String csvFilePath, String[] header,ResultSet rs) throws IOException, SQLException {writeCsv(new File(csvFilePath), header, rs);}public static void writeCsv(String zipFilePath, String csvName, String[] header, ResultSet rs) throws IOException, SQLException {FileOutputStream fos = null;BufferedOutputStream bos = null;ZipOutputStream zos = null;try {fos = new FileOutputStream(zipFilePath);bos = new BufferedOutputStream(fos);zos = new ZipOutputStream(bos);zos.putNextEntry(new ZipEntry(csvName));writeCsv(zos, header, rs);} finally {StreamUtil.flush(zos);StreamUtil.close(zos);//StreamUtil.flush(bos);StreamUtil.close(bos);//StreamUtil.flush(fos);StreamUtil.close(fos);}}}public class StreamUtil {public static void flush(Flushable flushable) {if (flushable != null) {try {flushable.flush();} catch (IOException e) {e.printStackTrace();}}}public static void close(Closeable closeable){if(closeable!=null){try {closeable.close();} catch (IOException e) {e.printStackTrace();}}}}4.下⾯是下载时的action@RequestMapping(value = "/downloadVehicleRepair", method = RequestMethod.POST)public ResponseEntity<byte[]> download() throws IOException {String path = RuntimeEnvironmentUtil.getValue(SysConstent.code,SysConstent.path)+"\\VehicleRepairDetail.zip"; File file = new File(path);HttpHeaders headers = new HttpHeaders();String fileName = new String("车辆维修清单.zip".getBytes("UTF-8"), "iso-8859-1");//为了解决中⽂名称乱码问题headers.setContentDispositionFormData("attachment", fileName);headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file), headers, HttpStatus.OK);}总结:以上只是关键代码。
java从数据库读取千万数据进行遍历生成文件的方法
java从数据库读取千万数据进行遍历生成文件的方法在Java中,从数据库读取千万数据进行遍历并生成文件可以分为以下几个步骤:1. 首先,确保你已经正确地连接到数据库。
可以使用Java的JDBC (Java Database Connectivity)来建立与数据库的连接。
具体的连接代码需要根据你所使用的数据库驱动程序而定。
2.创建一个数据库查询,用于检索你所需要的数据。
你可以使用SQL 语句来执行数据库查询。
根据你的需求,可以使用SELECT语句检索指定表中的数据。
3. 执行数据库查询,并获取结果集。
执行查询可以通过使用JDBC的Statement或PreparedStatement对象来实现。
执行查询后,可以使用ResultSet对象来获取查询结果。
4. 遍历结果集并生成文件。
遍历结果集可以使用while循环,通过调用ResultSet对象的next(方法逐行遍历结果。
在遍历过程中,你可以使用JDBC的获取方法(如getString(、getInt()来获取每个列的值,并将结果写入文件。
5.关闭数据库连接和文件输出流。
在处理完所有数据之后,记得关闭数据库连接和文件输出流,以释放资源并保持数据的一致性。
下面是一个示例代码,演示了从数据库读取数据并生成文件的过程:```javaimport java.io.FileWriter;import java.io.IOException;import java.io.PrintWriter;import java.sql.*;public class DatabaseToFilepublic static void main(String[] args)Connection connection = null;Statement statement = null;ResultSet resultSet = null;try//1.建立数据库连接connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "username", "password");//2.创建数据库查询statement = connection.createStatement(;//3.执行查询并获取结果集resultSet = statement.executeQuery("SELECT * FROM my_table");//4.遍历结果集并生成文件FileWriter fileWriter = new FileWriter("output.txt");PrintWriter printWriter = new PrintWriter(fileWriter);while (resultSet.next()String column1 = resultSet.getString("column1"); int column2 = resultSet.getInt("column2");//将数据写入文件printWriter.println(column1 + ", " + column2); }printWriter.close(;fileWriter.close(;} catch (SQLException , IOException e)e.printStackTrace(;} finally//5.关闭数据库连接和结果集tryif (resultSet != null)resultSet.close(;}if (statement != null)statement.close(;}if (connection != null)connection.close(;}} catch (SQLException e)e.printStackTrace(;}}}```上述代码假设你正在使用MySQL数据库,并将数据库连接URL改为你自己的数据库连接信息。
java从数据库读取千万数据进行遍历生成文件的方法
java从数据库读取千万数据进行遍历生成文件的方法(实用版4篇)《java从数据库读取千万数据进行遍历生成文件的方法》篇1Java从数据库读取千万数据进行遍历生成文件的方法可以使用Java的IO流和数据库连接来实现。
以下是一个基本的示例代码,假设我们有一个名为"mytable"的表,包含1000万行数据,我们需要遍历这些数据并将它们写入到文件中:```javaimport java.io.BufferedWriter;import java.io.FileWriter;import java.io.IOException;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class DataGenerator {private static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";private static final String DB_URL ="jdbc:mysql://localhost/mydatabase";private static final String USER = "root";private static final String PASS = "password";public static void main(String[] args) {Connection conn = null;PreparedStatement stmt = null;ResultSet rs = null;BufferedWriter writer = null;try {Class.forName(JDBC_DRIVER);conn = DriverManager.getConnection(DB_URL, USER, PASS);stmt = conn.prepareStatement("SELECT * FROM mytable");rs = stmt.executeQuery();writer = new BufferedWriter(new FileWriter("output.txt"));while (rs.next()) {String data = rs.getString("data"); // 假设数据存储在"data"列中writer.write(data); // 将数据写入文件writer.newLine(); // 换行}} catch (SQLException | ClassNotFoundException | IOException e) { e.printStackTrace();} finally {try {if (rs != null) rs.close();if (stmt != null) stmt.close();if (conn != null) conn.close();if (writer != null) writer.close();} catch (SQLException e) {e.printStackTrace();}}}}```在这个示例中,我们首先加载MySQL驱动程序,然后建立与数据库的连接。
java从数据库读取千万数据的方法
java从数据库读取千万数据的方法Java从数据库读取千万数据的方法引言在现代的软件开发中,大规模数据的处理已经成为了一个常见的需求。
在Java开发中,从数据库读取千万级别的数据是一个挑战性的任务,需要选择合适的方法来保证数据的高效读取和处理。
本文将详细介绍几种常用的方法,并对它们进行比较和评估。
方法一:使用JDBC直接读取JDBC是Java提供的一种与数据库交互的标准接口,可以实现对数据库的连接、查询和操作。
在读取千万级别的数据时,可以使用JDBC来直接读取数据。
具体的步骤如下:1.导入JDBC相关的依赖。
2.建立数据库连接。
3.编写SQL语句,查询数据。
4.执行SQL语句,获取结果集。
5.遍历结果集,处理数据。
使用JDBC直接读取的方法简单直接,但对于大规模的数据处理来说效率较低,容易出现内存溢出等问题。
方法二:使用分页查询另一种常用的方法是使用分页查询,通过限定每次查询的数量,逐页读取数据。
具体的步骤如下:1.设置每页查询的数量。
2.根据每页数量计算总页数。
3.循环查询每一页的数据,直到读取完全部数据。
使用分页查询可以有效减少单次查询的数据量,提高读取数据的效率。
但需要注意分页查询可能会增加数据库的负载,并且在数据量较大时需要进行合理的优化。
方法三:使用多线程并发读取当数据量较大时,可以考虑使用多线程并发读取数据,以提高读取的效率。
具体的步骤如下:1.设置多个线程同时读取数据。
2.将数据划分成多个块,每个线程读取一个块的数据。
3.将读取到的数据进行合并或者按照需要进行处理。
使用多线程并发读取可以充分利用多核处理器的性能,提高读取数据的效率。
但需要注意线程安全的处理,以及对数据库负载的合理控制,同时还需要考虑数据处理的并发问题。
方法四:使用数据库分库分表当数据量达到千万级别时,可以考虑使用数据库的分库分表功能,将数据分散存储在多个数据库或多个表中。
具体的步骤如下:1.根据数据量和需求进行分库分表的策略制定。
Java使用JDBC批量删除千万级数据
Java使⽤JDBC批量删除千万级数据对于千万级表的清理有三种办法;1.drop table 表名:⽤来删除表对象。
风险较⼤,后续不再使⽤,可以使⽤该⽅法。
2.truncate table 表名:清空表中所有数据,表结构还存在。
所有数据不再使⽤,可以使⽤该⽅法3.对于表结构不能删除,且只是按照条件删除表中某个条件数据,建议使⽤如下⽅法。
⾼效删除数据,且不会删除其他条件数据。
⾃动循环查询删除。
import java.sql.*;import java.util.Date;/*** @Author BlueFire* @Date 2020/4/17 -22:13*/public class InsertTest {public static void main(String[] args) throws ClassNotFoundException, SQLException {final String url = "jdbc:mysql://127.0.0.1:3306/mooding?autoReconnect=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai";final String name = "com.mysql.jdbc.Driver";final String user = "root";final String password = "123456";Connection conn = null;Class.forName(name); //指定连接类型conn = DriverManager.getConnection(url, user, password); //获取连接if (conn != null) {System.out.println("获取连接成功");deleteBatch(conn);//批量删除数据} else {System.out.println("获取连接失败");}conn.close();}//批量删除千万条数据public static void deleteBatch(Connection conn) throws SQLException {//数据中需要删除的数据量Long expiredCount = 0L;//已经删除数据量Long totalDeleted = 0L;//要删除表的名字String table = "t_users";//要删除的条件String schoolName = "XX⼤学";// 开始时间Long begin = new Date().getTime();//带有占位符的sqlString sql = "delete from ? where school_name = ? limit 100000 ";PreparedStatement pstmt = conn.prepareStatement(sql);//循环批量删除do {pstmt.setString(1, table);pstmt.setString(2, schoolName);// 返回值代表收到影响的⾏数int result = pstmt.executeUpdate();//已经删除条数totalDeleted += result;//还有条数expiredCount = queryCount(table, schoolName, conn);} while (expiredCount > 0);// 结束时间Long end = new Date().getTime();// 耗时System.out.println("千万条数据删除花费时间 : " + (end - begin) / 1000 + " s");System.out.println("删除完成");}//查询过期记录数量private static long queryCount(String table, String schoolName, Connection conn) throws SQLException {String sql = "SELECT COUNT (*) as cnt FROM ? where school_name = ? ";PreparedStatement pstmt = conn.prepareStatement(sql);pstmt.setString(1, table);pstmt.setString(2, schoolName);ResultSet rs = pstmt.executeQuery(sql);while (rs.next()) {long count = rs.getInt("cnt");return count;}return 0L;} }。
java中的resultset的类型
java中的resultset的类型结果集(ResultSet)是数据中查询结果返回的⼀种对象,可以说结果集是⼀个存储查询结果的对象,但是结果集并不仅仅具有存储的功能,他同时还具有操纵数据的功能,可能完成对数据的更新等。
结果集读取数据的⽅法主要是getXXX() ,他的参数可以使整型表⽰第⼏列(是从1开始的),还可以是列名。
返回的是对应的XXX类型的值。
如果对应那列时空值,XXX是对象的话返回XXX型的空值,如果XXX是数字类型,如Float等则返回0,boolean返回false。
使⽤getString()可以返回所有的列的值,不过返回的都是字符串类型的。
XXX可以代表的类型有:基本的数据类型如整型(int),布尔型(Boolean),浮点型(Float,Double)等,⽐特型(byte),还包括⼀些特殊的类型,如:⽇期类型(java.sql.Date),时间类型(java.sql.Time),时间戳类型 (java.sql.Timestamp),⼤数型(BigDecimal和BigInteger等)等。
还可以使⽤getArray(int colindex/String columnname),通过这个⽅法获得当前⾏中,colindex所在列的元素组成的对象的数组。
使⽤getAsciiStream(int colindex/String colname)可以获得该列对应的当前⾏的ascii流。
也就是说所有的getXXX⽅法都是对当前⾏进⾏操作。
结果集从其使⽤的特点上可以分为四类,这四类的结果集的所具备的特点都是和Statement语句的创建有关,因为结果集是通过Statement 语句执⾏后产⽣的,所以可以说,结果集具备何种特点,完全决定于Statement,当然我是说下⾯要将的四个特点,在Statement创建时包括三种类型。
⾸先是⽆参数类型的,他对应的就是下⾯要介绍的基本的ResultSet对应的Statement。
万物互联操作方法
万物互联操作方法
万物互联是指将各种设备、物品和系统连接在一起,通过互联网进行通信和数据交换。
具体的操作方法如下:
1. 设备连接:首先,需要将各种设备和物品连接到互联网。
这可以通过有线或无线方式进行,例如使用以太网连接、Wi-Fi、蓝牙等。
2. 网络配置:连接设备后,需要对其进行网络配置。
这包括设置设备的网络参数,例如IP地址、子网掩码、网关等,以确保能够正确连接到互联网。
3. 数据传输:一旦设备连接到互联网,就可以开始进行数据传输。
这可以通过常见的通信协议进行,例如HTTP、TCP/IP、MQTT等。
不同的设备可能需要使用不同的协议进行通信。
4. 互联网平台:为了实现万物互联,通常需要使用互联网平台来管理和控制设备。
互联网平台可以提供设备管理、数据存储、数据分析、远程控制等功能。
5. 应用开发:为了实现更高级的功能,可以开发应用程序来与互联网平台进行交互。
这些应用程序可以使用各种编程语言和开发框架进行开发,例如Java、Python、Node.js等。
6. 数据分析和应用:通过收集和分析设备生成的数据,可以提取有价值的信息
并应用于不同的领域。
例如,在智能家居中,可以通过分析传感器数据来实现自动化控制和能耗管理。
总之,万物互联的操作方法主要包括设备连接、网络配置、数据传输、互联网平台和应用开发。
通过这些步骤,可以实现设备之间的互联互通,实现更智能、高效和便捷的生活和工作。
java格式化数字带万方法
java格式化数字带万方法Java是一种功能强大的编程语言,在处理数字格式化方面也提供了很多灵活的方法。
其中一个常见的需求是将较大的数字格式化为以万为单位的形式,这在处理财务数据、统计数据等方面非常常见。
本文将介绍如何使用Java来格式化数字为带万的形式,并提供一些实际应用场景以及指导意义。
在Java中,格式化数字可以使用NumberFormat类来实现。
而在将数字格式化为带万的形式时,我们可以使用NumberFormat的子类,即DecimalFormat类。
DecimalFormat类提供了更灵活的数字格式化选项。
首先,我们需要创建一个DecimalFormat对象,并指定格式化的模式。
要将数字格式化为带万的形式,我们可以使用"0.####万"的模式字符串,其中"####"表示小数部分的位数,"万"表示单位。
接下来,我们需要将需要格式化的数字传递给DecimalFormat对象的format()方法。
这将返回一个格式化后的字符串表示。
例如,我们可以使用以下代码将数字10,000格式化为带万的形式:```javaDecimalFormat df = new DecimalFormat("0.####万");String formattedNumber = df.format(10000);System.out.println(formattedNumber);```输出结果将是"1万"。
在实际应用中,将数字格式化为带万的形式可以提高结果的可读性,并且更贴近真实的数据表达方式。
例如,在财务报告中,我们经常需要显示金额,而将金额格式化为带万的形式可以更好地展示金额的规模。
另外,格式化数字为带万的形式也可以用于统计数据的展示。
例如,在一个电商网站上展示商品销量时,将销量格式化为带万的形式可以更直观地展示销售数据的规模。
Java中List和Map的特性对两组大批量数据进行匹配
Java中List和Map的特性对两组⼤批量数据进⾏匹配在项⽬中遇到⼀个问题:要将通过http⽅式发送过来的⼤批量数据(这个数据保守估计每次请求在10万条左右),要和中的另⼀批数据(中的记录1万条左右)进⾏匹配(匹配:指两组数据中的某⼏个字段值相等),匹配上的数据保存在数据库中,匹配不上的直接扔掉。
或者说:有⼀个List<String> strList,List<Person> personList,strNoList.size是1万,personList.size是10万,然后要从personList中把person的id属性在strList中的person取出来,personList中的person的id可能会相同,两个记录的结构不同。
要实现这个功能,⾸先想到的就是使⽤逐条进⾏⽐较,那么这样就有10W*1W,即10亿次循环。
但是,系统对数据的实时性要求⽐较⾼,这样做显然性能上是有问题的。
于是乎就要找另⼀种⽅式,减少循环次数来提⾼匹配的处理速度,由于之前也没做个这样的事情,于是就想各种办法,同时在OSC社区发帖求助List可以放重复数据,⽽Map为不能放重复数据的key-value结构。
那么就可以把接收到的id相同的person实体数据放⼊⼀个list中,然后⽤该id作为key,list做作为value放⼊map中。
那么现在处理10w条数据则需要10W次for循环。
然后查出数据库中的1W条记录,遍历map,使⽤map.get("key")取出相同id的list,然后将这些list的元素全部添加到⼀个resultList中,遍历这1W条记录需要1W次for循环。
这样,就将⼀个10W*1W次的for循环减⼩到10W+1W次。
下边是关于for循环次数的耗时测试,结果表明减少循环次数能⼤幅度提⾼处理速度所以我们⼀般写代码,双循环匹配是N*M,数据量不⼤可以,数据量⼤了那就。
实现java中list集合中有几十万条数据,每100条为一组取出
实现 java中 list集合中有几十万条数据 ,每 100条为一组取出
解决“java 中 list集合中有几十万条数据,每100条为一组取出来如何实现,求代码!!!”的问题。
int listSize=list.size(); int toIndex=100; Map map = new HashMap(); //用map存起来新的分组后数据 int keyToken = 0; for(int i = 0;i<list.size();i+=100){
if(i+100>listSize){ //作用为toIndex最后没有100条数据则剩余几条newList中就装几条 toIndex=listSiБайду номын сангаасe-i;
} List newList = list.subList(i,i+toIndex); map.put("keyName"+keyToken, newList); keyToken++; }
return map; }
具体解决方案如下:
/** * 实现java 中 list集合中有几十万条数据,每100条为一组取出 * @param list 可穿入几十万条数据的List * @return map 每一Kye中有100条数据的List */ @SuppressWarnings({ "unchecked", "rawtypes" }) public Map groupList(List list){
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
JAVA数据库取数据万用方法
2009-03-21 12:24
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author Administrator
*/
public class DBAccess {
private static String Dr =
"com.microsoft.jdbc.sqlserver.SQLServerDriver";
private static String url =
"jdbc:microsoft:sqlserver://localhost:1433;databaseName=BookShop"; //创建Connection对象
public Connection getConnection() {
Connection conn = null;
try {
Class.forName(Dr);//创建驱动
conn = DriverManager.getConnection(url, "用户名", "密码");//创建数据库连接
} catch (ClassNotFoundException ex) {
Logger.getLogger(DBAccess.class.getName()).log (Level.SEVERE, null, ex);
} catch (SQLException ex) {
Logger.getLogger(DBAccess.class.getName()).log (Level.SEVERE, null, ex);
}
return conn;
}
//查询方法
//传入一个sql语句,返回一个Vector集合
public Vector inquiryFacility(String sql) {
Connection con;
Vector vc = new Vector();
ResultSet rs = null;
PreparedStatement st = null;
//得到数据库连接对象
con = this.getConnection();
//判断是否为空
if (con != null) {
try {
st = con.prepareCall(sql);
//执行sql语句
rs = st.executeQuery();
while (rs.next()) {
ResultSetMetaData rsmd =
rs.getMetaData();
//获得一行中有多少个字段
int numberOfColumns =
rsmd.getColumnCount();
Vector vt = new Vector();
//循环便利每一行的值
for (int i = 1; i <= numberOfColumns; i++) {
//将每一个字段的值加入vt集合中
vt.add(rs.getObject(i) );
}
//将获得的每一行的集合放到vc 集合中
vc.add(vt);
}
} catch (SQLException ex) {
Logger.getLogger(DBAccess.class.getNam e()).log(Level.SEVERE, null, ex);
} finally {
try {
//关闭连接
rs.close();
st.close();
con.close();
} catch (SQLException ex) {
Logger.getLogger(DBAccess.clas
s.getName()).log(Level.SEVERE, null, ex);
}
}
} else {
System.out.println("数据库连接错误");
}
//返回一个Vector对象
return vc;
}
public static void main(String[] args) {
//传入sql语句,获得查询结果
Vector vc = new DBAccess().inquiryFacility("sql语句");
//取出每一行数据
for(int i = 0;i < vc.size(); i++){
//取出每一列数据
for(int j = 0;j <
((Vector)vc.get(i)).size();j++){
System.out.print("\t"+((Vector)vc.get( i)).get(j));
}
System.out.println("");
}
}
}
运行的适合别忘了加载驱动包,上面的驱动是针对SQL server2005来用的,如果你用的是MySQL、oracle请把上面的驱动改掉,取出来的数据是Object类型的,别忘了转换类型!!!这个方法是我自己写的,有什么不足的地方,请把你宝贵的意见提出来!谢谢。