分页_分页查询 - CSDN
分页 订阅
分页(英语:Paging),是一种操作系统里存储器管理的一种技术,可以使电脑的主存可以使用存储在辅助存储器中的数据。操作系统会将辅助存储器(通常是磁盘)中的数据分区成固定大小的区块,称为“页”(pages)。当不需要时,将分页由主存(通常是内存)移到辅助存储器;当需要时,再将数据取回,加载主存中。相对于分段,分页允许存储器存储于不连续的区块以维持文件系统的整齐。分页是磁盘和内存间传输数据块的最小单位。 展开全文
分页(英语:Paging),是一种操作系统里存储器管理的一种技术,可以使电脑的主存可以使用存储在辅助存储器中的数据。操作系统会将辅助存储器(通常是磁盘)中的数据分区成固定大小的区块,称为“页”(pages)。当不需要时,将分页由主存(通常是内存)移到辅助存储器;当需要时,再将数据取回,加载主存中。相对于分段,分页允许存储器存储于不连续的区块以维持文件系统的整齐。分页是磁盘和内存间传输数据块的最小单位。
信息
外文名
Paging
领    域
计算机
定    义
一种操作系统里存储器管理的技术
中文名
分页
性    质
磁盘和内存间传输数据块最小单位
学    科
计算机
分页简介
分页(英语:Paging),是一种操作系统里存储器管理的一种技术,可以使电脑的主存可以使用存储在辅助存储器中的数据。操作系统会将辅助存储器(通常是磁盘)中的数据分区成固定大小的区块,称为“页”。当不需要时,将分页由主存(通常是内存)移到辅助存储器;当需要时,再将数据取回,加载主存中。相对于分段,分页允许存储器存储于不连续的区块以维持文件系统的整齐。分页是磁盘和内存间传输数据块的最小单位。分页/虚拟内存能有助“大大地”降低整体及额外非必要的 I/O 次数,提高系统整体运作性能。因为这能有助提高 RAM 的读取命中率,也透过其内部的高效率算法来达到 I/O 数据流的预缓存工作,通过与之相关的等等手段也能很好地提高了 CPU 的使用效率,而拥有大物理内存的用户更可能考虑利用如Ramdisk、Supercache、SoftPerfect RAM Disk等模拟出硬盘分区来同时将虚拟内存/系统临时文件等设置其上以进一步加强系统性能,及达至保障硬盘的措施。分页是虚拟内存技术中的重要部分。
收起全文
精华内容
参与话题
  • 分页查询

    万次阅读 多人点赞 2014-02-22 19:57:17
    分页查询,就是将将过多的结果在有限的界面上分好多页来显示,这个是很多网站常用的功能,也是最基本的功能,今天简单总结一下。  分页以前听人们说都是一项技术,但是我觉的不尽然。我认为分页是将数据库的数据...

             分页查询,就是将将过多的结果在有限的界面上分好多页来显示,这个是很多网站常用的功能,也是最基本的功能,今天简单总结一下。


              分页以前听人们说都是一项技术,但是我觉的不尽然。我认为分页是将数据库的数据,利用一些特殊的sql语句来进行查询,显示理所应当显示的内容,更恰当的说可以是对SQL语句的灵活运用,对逻辑思维的简单使用。


             一,一般人们将分页查询分为两类:逻辑分页,物理分页,我们先从理论上理解一下:

                 1,逻辑分页概述:就是用户第一次访问时,将数据库的所有记录全部查询出来,添加到一个大的集合中,然后存放在session对象,然后通过页码计算出当前页需要显示的数据内容,存储到一个小的list的集合中,并将之存储到request对象中,跳转到JSP页面,进行遍历显示。 当用户第二次访问时,只要不关闭浏览器,我们还会从session中获取数据,来进行显示。为什么叫逻辑分页呢?因为此种方法是在内存的session对象中进行计算分页显示的,而不是真正的将我们数据库进行分页的。

            来看它的一些缺点吧:

                  a,如果需要查询的数据量过大,session将耗费大量的内存;

                  b,因为是在session中获取数据,如果第二次或者更多此的不关闭浏览器访问,会直接访问session,从而不能保证数据是最新的。

            小结:这种分页很少使用。但是在数据量小,不会被修改的数据,使用逻辑分页会提高程序的执行效率。

     

               2,物理分页概述:使用数据库自身所带的分页机制,例如,Oracle数据库的rownum,或者Mysql数据库中的limit等机制来完成分页操作。因为是对数据库实实在在的数据进行分页条件查询,所以叫物理分页。每一次物理分页都会去连接数据库。

                优点:数据能够保证最新,由于根据分页条件会查询出少量的数据,所以不会占用太多的内存。

                缺点:物理分页使用了数据库自身带的机制,所以这样的SQL语句不通用,导致不能进行数据库的移植。

               小结:在实际中物理分页还是使用的较多的。

     


      二,看一下逻辑分页查询的应用:


    	public class PageQueryUserServlet extends HttpServlet {
    	
    		@Override
    		protected void doGet(HttpServletRequest request, HttpServletResponse response)
    				throws ServletException, IOException {
    			
    			//获取页码
    			int pageno = Integer.parseInt(request.getParameter("pageno")==null?"1":request.getParameter("pageno")); 
    			
    			
    			//从session中获取大List集合
    			HttpSession session = request.getSession();
    			List<User> bigList = (List<User>)session.getAttribute("bigList");
    			
    			//如果第一次访问
    			if(bigList == null){
    				
    				//创建大List集合
    				bigList = new ArrayList<User>();
    				
    				//如果大List集合不存在,则连接数据库
    				Connection conn = null;
    				PreparedStatement ps= null;
    				ResultSet rs = null;
    				try {
    					conn = DBUtil.getConnection();
    					String sql = "select usercode,username,orgtype from t_user order by regdate desc";
    					ps = conn.prepareStatement(sql);
    					
    					//执行查询语句返回查询结果集
    					rs = ps.executeQuery();
    					
    					//遍历结果集封装javabean对象并存储到大List集合中
    					while(rs.next()){
    						User user = new User();
    						user.setUsercode(rs.getString("usercode"));
    						user.setUsername(rs.getString("username"));
    						user.setOrgtype(rs.getString("orgtype"));
    						bigList.add(user);
    					}
    					
    					//将大List集合存储到session中
    					session.setAttribute("bigList", bigList);
    					
    				} catch (Exception e) {
    					e.printStackTrace();
    				} finally{
    					DBUtil.close(conn, ps, rs);
    				}
    			}
    			
    			
    			//如果从session中可以获取到大List集合,则通过页码计算得出小List集合
    			List<User> smallList = new ArrayList<User>();
    			
    			//计算开始标识=页数大小*(页码-1)
    			int beginIndex = Const.PAGE_SIZE * (pageno-1);
    			
    			//结束标识=页数大小*页码,如果超过了总数据条数,则表示为最后一页,写为总结条数即可
    			int endIndex = Const.PAGE_SIZE * pageno > bigList.size() ? bigList.size() : Const.PAGE_SIZE * pageno;
    			
    			for(int i=beginIndex;i<endIndex;i++){
    				smallList.add(bigList.get(i));
    			}
    			
    			//将小List集合存储到request对象中
    			request.setAttribute("userList", smallList);
    			
    			//转发
    		}
    		
    
    }



              三,好,物理分页和逻辑分页的计算方法差不多,只不过一个是session中一个是在数据库中,这里物理分页总结一下多条件查询分页显示的过程,这里也将分页对象进行封装了:

                先看一下分页对象的编写:

    	/**
    	 * 分页对象
    	 * @author Administrator
    	 */
    	public class Page<T> {
    		/**
    		 * 页码
    		 */
    		private int pageno;
    		
    		/**
    		 * 每页显示的记录条数
    		 */
    		private int pagesize;
    		
    		/**
    		 * 数据集合(需要显示在网页中的数据)
    		 */
    		private List<T> dataList;
    		
    		/**
    		 * 总记录条数
    		 */
    		private int totalsize;
    		
    		
    		public Page(String pageno) {
    			this.pageno = (pageno == null ? 1 : Integer.parseInt(pageno));
    			this.pagesize = Const.PAGE_SIZE;
    			this.dataList = new ArrayList<T>();
    		}
    		
    		public int getPageno(){
    			return pageno;
    		}
    		
    		public int getPagesize(){
    			return pagesize;
    		}
    		
    		public List<T> getDataList(){
    			return dataList;
    		}
    		
    		public void setTotalsize(int totalsize){
    			this.totalsize = totalsize;
    		}
    		
    		public int getTotalsize(){
    			return totalsize;
    		}
    		
    		public int getPagecount(){
    			return totalsize%pagesize == 0 ? totalsize/pagesize : totalsize/pagesize + 1;
    		}
    		
    		/**
    		 * 通过业务SQL语句获取分页SQL语句
    		 * @param sql 业务SQL
    		 * @return 分页SQL语句
    		 * 这是非常核心的,通过多次嵌套,嵌套出分页sql语句的编写
    		 */
    		public String getSql(String sql){
    			return "select t1.* from (select t.*,rownum as linenum from ("+sql+") t where rownum<=" + pageno*pagesize + ") t1 where t1.linenum>" + (pageno-1)*pagesize;
    		}
    	}
    

     有了这个分页对象,我就可以利用它了,看我们动态参数分页查询的过程,重点看注释步骤:

    	/**
    	 * 动态参数查询,难度最大的是SQL语句动态拼接。(因为查询提交内容不定,查询提交个数不定)
    	 * @author Administrator
    	 */
    	public class PageQueryInvServlet extends HttpServlet {
    	
    		@Override
    		protected void doPost(HttpServletRequest request, HttpServletResponse response)
    				throws ServletException, IOException {
    			
    			//解决请求体的中文乱码问题
    			//request.setCharacterEncoding("GB18030");
    			
    			//创建分页对象
    			Page<Investor> page = new Page<Investor>(request.getParameter("pageno"));
    			
    			//获取查询提交的数据
    			String invregnum = request.getParameter("invregnum");
    			String invname = request.getParameter("invname");
    			String startdate = request.getParameter("startdate");
    			String enddate = request.getParameter("enddate");
    			
    			//拼接业务SQL,注意其中的技巧,where 1=1,另外这里使用StringBuilder提高拼接的效率
    			StringBuilder sql = new StringBuilder("select i.invregnum,i.invname,i.regdate,u.username,i.cty from t_invest i join t_user u on i.usercode=u.usercode where 1=1");
    			StringBuilder totalsizeSql = new StringBuilder("select count(*) as totalsize from t_invest i join t_user u on i.usercode=u.usercode where 1=1");
    			//创建list集合用来绑定下标和内容,利用的list下标和值对应关系的特点
    			List<String> paramList = new ArrayList<String>();
    			
    			//动态参数拼接动态SQL语句
    			if(StringUtil.isNotEmpty(invregnum)){
    				sql.append(" and i.invregnum = ?");
    				totalsizeSql.append(" and i.invregnum = ?");
    				paramList.add(invregnum); 
    			}
    			
    			if(StringUtil.isNotEmpty(invname)){
    				sql.append(" and i.invname like ?");
    				totalsizeSql.append(" and i.invname like ?");
    				paramList.add("%" + invname + "%"); 
    			}
    			
    			if(StringUtil.isNotEmpty(startdate)){
    				sql.append(" and i.regdate >= ?");
    				totalsizeSql.append(" and i.regdate >= ?");
    				paramList.add(startdate); 
    			}
    			
    			if(StringUtil.isNotEmpty(enddate)){
    				sql.append(" and i.regdate <= ?");
    				totalsizeSql.append(" and i.regdate <= ?");
    				paramList.add(enddate); 
    			}
    			
    			//调用获取分页SQL
    			String pageSql = page.getSql(sql.toString());
    			
    			//连接数据库查询数据
    			Connection conn = null;
    			PreparedStatement ps = null;
    			ResultSet rs = null;
    			try {
    				conn = DBUtil.getConnection();
    				ps = conn.prepareStatement(pageSql);
    				
    				//给?赋值(重点),这里list的巧妙使用
    				for(int i=0;i<paramList.size();i++){
    					ps.setString(i+1, paramList.get(i));
    				}
    				
    				//执行查询语句,返回查询结果集
    				rs = ps.executeQuery();
    				
    				//遍历结果集,每遍历一次,封装Investor对象,将其添加到List集合中
    				while(rs.next()){
    					Investor inv = new Investor();
    					inv.setInvregnum(rs.getString("invregnum"));
    					inv.setInvname(rs.getString("invname"));
    					inv.setRegdate(rs.getString("regdate"));
    					inv.setUsername(rs.getString("username"));
    					inv.setCty(rs.getString("cty"));
    					
    					page.getDataList().add(inv);
    				}
    				
    				//查询总记录条数,并且设置到分页对象中
    				ps = conn.prepareStatement(totalsizeSql.toString());
    				
    				//给?赋值
    				for(int i=0;i<paramList.size();i++){
    					ps.setString(i+1, paramList.get(i));
    				}
    				
    				rs = ps.executeQuery();
    				
    				if(rs.next()){
    					page.setTotalsize(rs.getInt("totalsize"));
    				}
    				
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally{
    				DBUtil.close(conn, ps, rs);
    			}
    			
    			//将分页对象存储到request范围中
    			request.setAttribute("pageObj", page);
    			
    			//转发
    		     
    		}
    		
    	}
    



              分页查询将数据量分成几批显示到页面上。就像我们的书本,这不过这里的动态,可能因为查询条件的不同,页面的内容就不同,所以灵活应用,弄清楚查询条件,编写好分页查询语句,那么什么问题都解决了。

    展开全文
  • JS实现分页功能

    万次阅读 2018-10-28 23:33:58
    为了方便浏览通常将服务器响应回来的大量数据做分页 从实现方式上来说分页基本分为两种方式: 1.查询所有数据返回给客户,通过显示指定区间实现分页,这种方法一般是指JS分页 2.通过客户发送的请求,构造sql语句...

    为了方便浏览通常将服务器响应回来的大量数据做分页

    从实现方式上来说分页基本分为两种方式:

    1.查询所有数据返回给客户,通过显示指定区间实现分页,这种方法一般是指JS分页

    2.通过客户发送的请求,构造sql语句,查询表中的一段数据。

    ------------------------------------------------------------------------------------------------------------------

    JS实现分页功能代码

    html:

    <table width="950" cellpadding="0" cellspacing="0" class="table2" align="center">
      
        <tr align="center">
            <th class="td2" height="33" width="150">id</th>
            <th class="td2" >用户名</th>
            <th class="td2" >联系方式</th>
            <th class="td2" >性别</th>
        </tr>


        <tbody id="adminTbody">

        <c:forEach items="${user }" var="user">
        <tr>
        <td>${user.id}</td>
        <td>${user.username}</td>
        <td>${user.tel}</td>
        <td>${user.sex}</td>
       
        </tr>
        </c:forEach>


        </tbody>
    </table>


    <div id="barcon" class="barcon" >
        <div id="barcon1" class="barcon1"></div>
            <div id="barcon2" class="barcon2">
                <ul>
                    <li><a href="###" id="firstPage">首页</a></li>
                    <li><a href="###" id="prePage">上一页</a></li>
                    <li><a href="###" id="nextPage">下一页</a></li>
                    <li><a href="###" id="lastPage">尾页</a></li>
                    <li><select id="jumpWhere">
                    </select></li>
                    <li><a href="###" id="jumpPage" οnclick="jumpPage()">跳转</a></li>
                </ul>
            </div>
    </div>

    js:需要引入jquery

    <script src="http://libs.baidu.com/jquery/1.11.1/jquery.min.js"></script>     
     

    <script>

    $(function(){
        
        goPage(1,10);
        var tempOption="";
        for(var i=1;i<=totalPage;i++)
        {
            tempOption+='<option value='+i+'>'+i+'</option>'
        }
        $("#jumpWhere").html(tempOption);
    })
     
     
    var pageSize=0;//每页显示行数
    var currentPage_=1;//当前页全局变量,用于跳转时判断是否在相同页,在就不跳,否则跳转。
    var totalPage;//总页数
    function goPage(pno,psize){
        var itable = document.getElementById("adminTbody");
        var num = itable.rows.length;//表格所有行数(所有记录数)
     
         pageSize = psize;//每页显示行数
        //总共分几页 
        if(num/pageSize > parseInt(num/pageSize)){   
                totalPage=parseInt(num/pageSize)+1;   
           }else{   
               totalPage=parseInt(num/pageSize);   
           }   
        var currentPage = pno;//当前页数
         currentPage_=currentPage;
        var startRow = (currentPage - 1) * pageSize+1; 
        var endRow = currentPage * pageSize;
            endRow = (endRow > num)? num : endRow;    
           //遍历显示数据实现分页
        /*for(var i=1;i<(num+1);i++){    
            var irow = itable.rows[i-1];
            if(i>=startRow && i<=endRow){
                irow.style.display = "";    
            }else{
                irow.style.display = "none";
            }
        }*/
     
        $("#adminTbody tr").hide();
        for(var i=startRow-1;i<endRow;i++)
        {
            $("#adminTbody tr").eq(i).show();
        }
        var tempStr = "共"+num+"条记录 分"+totalPage+"页 当前第"+currentPage+"页";
         document.getElementById("barcon1").innerHTML = tempStr;
         
        if(currentPage>1){
            $("#firstPage").on("click",function(){
                goPage(1,psize);
            }).removeClass("ban");
            $("#prePage").on("click",function(){
                goPage(currentPage-1,psize);
            }).removeClass("ban");   
        }else{
            $("#firstPage").off("click").addClass("ban");
            $("#prePage").off("click").addClass("ban");  
        }
     
        if(currentPage<totalPage){
            $("#nextPage").on("click",function(){
                goPage(currentPage+1,psize);
            }).removeClass("ban")
            $("#lastPage").on("click",function(){
                goPage(totalPage,psize);
            }).removeClass("ban")
        }else{
            $("#nextPage").off("click").addClass("ban");
            $("#lastPage").off("click").addClass("ban");
        }   
        
        $("#jumpWhere").val(currentPage);
    }
     
     
    function jumpPage()
    {
        var num=parseInt($("#jumpWhere").val());
        if(num!=currentPage_)
        {
            goPage(num,pageSize);
        }
    }
     
    </script>

    css:简单样式

    .table2{
            border:#C8C8C8 solid;   
            border-width:1px 0px 0px 1px; 
            background: #F3F0F0;
            margin-top:25px;
        }
        
        .td0{
            border:#C8C8C8 solid;  
            border-width:0 0 1px 0;
        }
        
        .td2{
            border:#C8C8C8 solid;   
            border-width:0 1px 1px 0 ;
        }
        
        .barcon {
            width: 1000px;
            margin: 0 auto;
            text-align: center;
         }
     
        .barcon1 {
            font-size: 17px;
            float: left;
            margin-top: 20px;
        }
     
        .barcon2 {
            float: right;
        }
     
        .barcon2 ul {
            margin: 20px 0;
            padding-left: 0;
            list-style: none;
            text-align: center;
        }
     
        .barcon2 li {
            display: inline;
        }
     
        .barcon2 a {
            font-size: 16px;
            font-weight: normal;
            display: inline-block;
            padding: 5px;
            padding-top: 0;
            color: black;
            border: 1px solid #ddd;
            background-color: #fff;
        }
     
        .barcon2 a:hover{
            background-color: #eee;
        }
     
        .ban {
            opacity: .4;
        }

    --------------------------------------------------------------------------------------------------

    只要将forEach替换成你的就可以,其他的全部复制粘贴

    展开全文
  • Web页面分页的几种方式

    万次阅读 2018-07-20 16:19:31
    JavaWeb分页显示内容之分页查询的三种思路(数据库分页查询)  转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/6134851.html  在开发过程中,经常做的一件事,也是最基本的事,就是从数据库中查询数据,...

    JavaWeb分页显示内容之分页查询的三种思路(数据库分页查询)

        转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/6134851.html

        在开发过程中,经常做的一件事,也是最基本的事,就是从数据库中查询数据,然后在客户端显示出来。当数据少时,可以在一个页面内显示完成。然而,如果查询记录是几百条、上千条呢?直接一个页面显示完全的话,表格得多长啊。。。。。。这时,我们可以用分页技术。

        何为分页?效果图如下:

        

         这里总共查询了100条记录,如果一次性显示的话表格会很多行,用户体验不佳。而我们采用分页显示的话,一页显示10条记录,共十页。用户可以自行翻阅,记录少,清晰显示。

         下面谈谈分页效果的实现,思路有三种:

        其一:纯JS实现分页。一次性查询记录并加载到html的table中。然后通过选择性地显示某些行来达到分页显示的目的。这是一种伪分页,障眼法而已。只能用于数据少的情况下。一旦数据多了,十几万条数据加载到html中会变得很慢。而且不实时,一次加载完后数据就写死在页面了,若数据库中有变化,浏览器端显示的仍是上次加载过来的数据。

         首先:用table来显示查询出来的记录们,全部显示。

    复制代码

    <table width="500" id="idData">
                <%
                        String user_id, user_name, user_sex, user_phone, user_age;
                        while (sqlRst.next()) {
                            user_id = sqlRst.getString(1);
                            user_name = sqlRst.getString(2);
                            user_sex = sqlRst.getString(3);
                            user_phone = sqlRst.getString(4);
                            user_age = sqlRst.getString(5);
                %>
                <tr>
                    <td><%=user_id%></td>
                    <td><%=user_name%></td>
                    <td><%=user_sex%></td>
                    <td><%=user_phone%></td>
                    <td><%=user_age%></td>
                </tr>
                <%
                    }
                %>            
            </table>        
            <br/>
            
        <table width="60%" align="right">
            <tr><td><div id="changePages" name="changePages"></div></td></tr>
        </table>

    复制代码

        然后,在JS中修改table中某些行显示,某些行隐藏。

       

    复制代码

    <script type="text/javascript">
        function goPage(pno,psize){
        var itable = document.getElementById("idData");//获取table
        var num = itable.rows.length;//得到记录总数
        var totalPage = 0;
        var pageSize = psize;//一页显示pageSize条记录
        //计算总页数
        if(num/pageSize > parseInt(num/pageSize)){   
                totalPage=parseInt(num/pageSize)+1;   
           }else{   
               totalPage=parseInt(num/pageSize);   
           }   
         //当前页数
        var currentPage = pno;
        //获取当前页第一条、最后一条记录的行号
        var startRow = (currentPage - 1) * pageSize+1;
           var endRow = currentPage * pageSize;
           endRow = (endRow > num)? num : endRow;
        //修改table中当前页对应的行的属性为显示,非本页的记录为隐藏
        for(var i=1;i<(num+1);i++){    
            var irow = itable.rows[i-1];
            if(i>=startRow && i<=endRow){
                irow.style.display = "block";    
            }else{
                irow.style.display = "none";
            }
        }
        
        //分页页码列表
        var tempStr = "共"+num+"条记录 分"+totalPage+"页 当前第"+currentPage+"页";
        if(currentPage>1){
            tempStr += "<a href=\"#\" onClick=\"goPage("+(1)+","+psize+")\">首页</a>";
            tempStr += "<a href=\"#\" onClick=\"goPage("+(currentPage-1)+","+psize+")\"><上一页</a>"
        }else{
            tempStr += "首页";
            tempStr += "<上一页";    
        }
    
        if(currentPage<totalPage){
            tempStr += "<a href=\"#\" onClick=\"goPage("+(currentPage+1)+","+psize+")\">下一页></a>";
            tempStr += "<a href=\"#\" onClick=\"goPage("+(totalPage)+","+psize+")\">尾页</a>";
        }else{
            tempStr += "下一页>";
            tempStr += "尾页";    
        }
        document.getElementById("changePages").innerHTML = tempStr;   
    }
        </script>

    复制代码

     

         其二:一次查询,分批显示。

         就是说,我们可以执行一个数据库查询操作,得到结果集rs。然后,通过指针的移动来显示当前页面的记录。这样,就可以以   rs.absolute(当前页面号*每页记录数)定位到当前页的第一条记录,然后通过while循环显示n条记录(n为每页显示记录数)。在跳页时,只需修改currentPage,即可在重定位到下一页时把当前页面号改掉,重新定位记录指针,通过while遍历显示n条记录。与JS选择性显示不同,这里是选择性遍历。与JS分页不同的是,这里分页每次跳页修改的是遍历的指针,每次跳页都要进行一次全面查询。同样地,不适合大数据量查询。这里比JS分页优化的地方在于——实时性。每次跳页都会查询一次数据库,保证数据的实时性。

         参考代码:

        

    复制代码

              <%    
                int intPageSize = 10;             //一页显示的记录数 
                        int intRowCount;                 //记录总数 
                        int intPageCount;                 //总页数 
                        String strPage;                    //从表单或URL传送的待显示页码
                        int intPage;                     //待显示页码 ,由strPage转换成的整数
    

    复制代码

               
            //---计算记录总数的第一种方法:查询出所有记录,移动结果集指针到最后一条,获取最后一条记录的行号
              //查询所有数据
                ResultSet sqlRst = sqlStmt.executeQuery("select * from user");
                //获取记录总数 
                sqlRst.last();                    //光标在最后一行
                intRowCount = sqlRst.getRow();    //获得当前行号,即总记录数
                //记算总页数 
                intPageCount = (int)Math.ceil(intRowCount/(intPageSize*1.0));

    复制代码

    
     

     

    //将记录指针定位到待显示页的第一条记录上 
                        sqlRst.absolute((intPage - 1) * intPageSize + 1);
                        //显示数据 
                        int i=0;
                        String user_id, user_name, user_sex, user_phone, user_age;
                        while (i < intPageSize && !sqlRst.isAfterLast()) {
                            user_id = sqlRst.getString(1);
                            user_name = sqlRst.getString(2);
                            user_sex = sqlRst.getString(3);
                            user_phone = sqlRst.getString(4);
                            user_age = sqlRst.getString(5);
                %>
                <tr>
                    <td><%=user_id%></td>
                    <td><%=user_name%></td>
                    <td><%=user_sex%></td>
                    <td><%=user_phone%></td>
                    <td><%=user_age%></td>
                </tr>
                <%
                            sqlRst.next();//移动记录指针指向下一条记录
                            i++;//统计当前页已显示多少条记录
                        }
                %>

    复制代码

        其三:在服务端分页。跳到第n页才查询、显示第n页内容。要点就是根据客户端表格的“页面”计算出数据库要查询的当前页面的第一条记录的位置。优点:实时性:跳页才查询。数据量小:只加载当前页的记录进行显示。

        重点在于两条语句:select count(*) from ...:查询得到记录总条数

                                 select * from .. limit pageNo,rowsCount:查询从第pageNo条开始的rowsCount条数据。

       

    复制代码

        int pages=0;            //待显示页面
        int count=0;            //总条数
        int totalpages=0;        //总页数
        int limit=10;            //每页显示记录条数    
        //计算记录总数的第二种办法:使用mysql的聚集函数count(*)
        ResultSet sqlRst = sqlStmt.executeQuery("select count(*) from user");
        if(sqlRst.next()){
            count = sqlRst.getInt(1);//结果为count(*)表,只有一列。这里通过列的下标索引(1)来获取值
        }    
        //由记录总数除以每页记录数得出总页数
        totalpages = (int)Math.ceil(count/(limit*1.0));
        //获取跳页时传进来的当前页面参数
        String strPage = request.getParameter("pages");
        //判断当前页面参数的合法性并处理非法页号(为空则显示第一页,小于0则显示第一页,大于总页数则显示最后一页)
        if (strPage == null) { 
            pages = 1;
        } else {
            try{
                pages = java.lang.Integer.parseInt(strPage);
            }catch(Exception e){
                pages = 1;
            }
            
            if (pages < 1){
                pages = 1;
            }
            
            if (pages > totalpages){
                pages = totalpages;
            }                            
        }
        //由(pages-1)*limit算出当前页面第一条记录,由limit查询limit条记录。则得出当前页面的记录
        sqlRst = sqlStmt.executeQuery("select * from user order by user_id limit " + (pages - 1) * limit + "," + limit);
        while (sqlRst.next()){//遍历显示}

    复制代码

        跳页的实现:跳页是通过重定向来实现的,通过向当前网页传进待显示的pages,在跳转后根据pages重新算出页面显示的第一条,查limit条显示。

       

    复制代码

    <form name="f1" method="POST" action="index.jsp" onSubmit="return checknum()">
                <table border="0" align="center" >
                    <tr>
                        <td>第<%=pages%>页 共<%=totalpages%>页 <a href="index.jsp?pages=1">首页</a></td>
                        <td><a href="index.jsp?pages=<%=(pages<1)?pages:(pages-1) %>"> 上一页</a></td>
                        <td><a href="index.jsp?pages=<%=(pages>=totalpages)?totalpages:(pages+1)%>"> 下一页</a></td>
                        <td><a href="index.jsp?pages=<%=totalpages%>">最后一页</a></td>
                        <td>转到第:<input type="text" name="page" size="8">页<input type="submit" value="GO" name="cndok"></td>
                    </tr>
                </table> 
     </form>

    复制代码

       

       附:常见数据库分页查询语句

    复制代码

    1.oracle数据库分页
        select * from (select a.*,rownum rc from 表名 where rownum<=endrow) a where a.rc>=startrow
    
    2.DB2数据库分页
        Select * from (select rownumber() over() as rc,a.* from (select * from 表名 order by列名) as a) where rc between startrow and endrow
    
    3.SQL Server 2000数据库分页
        Select top pagesize * from 表名 where 列名 not in(select top pagesize*page 列名 from 表名 order by列名) order by列名
    
    4.SQL Server 2005数据库分页
        Select * from (select 列名,row_number() over(order by 列名1) as 别名from 表名) as t where t.列名1>=startrow and t.列名1<=endrow
    
    5.MySQL数据库分页
        Select * from 表名 limit startrow,pagesize
        (Pagesize为每页显示的记录条数)
    
    6.PostgreSQL数据库分页
        Select * from 表名 limit pagesize,offset startrow
        (Pagesize为每页显示的记录条数)

    复制代码

    展开全文
  • Java中如何实现分页功能

    万次阅读 2017-10-19 09:01:33
    内容多了,我们就会想要去做分页,既能提升用户体验,又减少页面体积,提升加载速度。那么Java中怎么实现分页功能呢?今天华清Java学院就和大家分享一下Java中如何实现分页功能。 Java实现分页功能的具体思路: ...
    华清远见成都中心 2017-10-11 14:48

    内容多了,我们就会想要去做分页,既能提升用户体验,又减少页面体积,提升加载速度。那么Java中怎么实现分页功能呢?今天华清Java学院就和大家分享一下Java中如何实现分页功能

    Java实现分页功能的具体思路:

    这里先说下Java实现分页的具体思路,主要就是利用了jquery.pagination这个插件,这个插件的原理就是你只要给他一个必选的总条数参数,然后在回调函数去操作数据就可以了,后台只需要返回数据即可。

    Java实现分页功能的具体案例:

    开发框架:后台springMVC,前端jquery,jquery.pagination, bootstrap。

    ①效果图:

    Java中如何实现分页功能

    这里只说关于分页的内容,第一步当然是引入jquery.pagination, bootstrap的地址

    Java中如何实现分页功能

    这里pagination的js文件我是下载到了本地

    ②编写函数:

    $('#Pagination').pagination(${total},

    {

    num_edge_entries: 2,

    num_display_entries: 4,

    callback: PageCallback,

    items_per_page:2,

    prev_text:'上一页',

    next_text:'下一页'

    }

    total是后台取的数据总条数

    ③编写回调函数

    Java中如何实现分页功能

    这里回调函数的作用是发送ajax请求取得后台数据,用jquery显示在表格里面

    后台代码:

    @RequestMapping(value="/fenye2",method = RequestMethod.POST, produces = "text/html;charset=UTF-8")

    public void fenYe2(int yehao,String key,HttpServletResponse resp, Model m){

    List<Student> list=studentService.fen(yehao*2, key);

    int total=list.size();

    m.addAttribute("total",total);

    JsonArray jsonArray=new JsonArray();

    for (int i = 0; i < list.size(); i++) {

    JsonObject jsonObject=new JsonObject();

    jsonObject.addProperty("id", list.get(i).getId());

    jsonObject.addProperty("name", list.get(i).getName());

    jsonObject.addProperty("sex", list.get(i).isSex());

    jsonObject.addProperty("age", list.get(i).getAge());

    jsonObject.addProperty("teacher", list.get(i).getTeacher().getName());

    jsonArray.add(jsonObject);

    }

    try {

    resp.getWriter().write(jsonArray.toString());

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    前台代码

    Java中如何实现分页功能

    展开全文
  • 网页中实现分页功能的几种方法

    万次阅读 2018-02-10 16:12:19
    当我们在做一些类似于贴吧展示帖子这种项目的时候,由于帖子的数量比较多,就会用到分页的技术。这里我将介绍几种几种方式来实现分页的技术。首先我们先来了解一下分页功能的核心技术点:1. 首先先规定每一页显示...
  • 分页高级查询步骤

    千次阅读 2013-11-12 18:43:27
    1.定义bean类  public class User {  private String name;  private String password;  private String sex;  private int age;  //set get 方法,此处省略不写  }
  • 高级查询及分页总结

    2019-06-22 14:24:09
    一、子查询 案例: select * from Student where Birthday>( select Birthday from Student Where StudentName='张玲' ...提示:将子查询和比较运算符联合使用,必须保证子查询返回的值不能多于一个。...
  • 分页与高级查询

    2017-08-31 19:00:59
    JSP页面*" pageEncoding="UTF-8" isELIgnored="false"%> String path = request.getContextPath();
  • 1)把pageSize和currentPage封装到ProductQueryObject中 public class ProductQueryObject { private String name; private BigDecimal minSalePrice; private BigDecimal maxSalePrice; //------------------...
  • 分页&高级查询

    2020-06-10 17:00:17
    分页1、使用的是分页插件,导包2、applicationContext里面配置3、写query的类(这个类装前台分页和高级查询时传入的数据)4、写一个page类:返回的数据(这是前台分页需要的数据)5、mapper层6、mapper映射层7、...
  • 内存分页机制

    千次阅读 2018-09-28 10:07:26
    为什么要分页 在保护模式中,内存访问使用分段机制——即&amp;quot;段基址:段内偏移地址&amp;quot;的方式,为加强段内存的安全性和可管理性还引入了段描述符的概念对段内存加强管理。但仅仅这样还是不够的...
  • mybatis的4种分页方式

    万次阅读 多人点赞 2018-11-07 10:41:11
    今天我们就来进行基于mybatis和MySql进行分页功能的实现。常见的数据分页有哪几种实现??基于数组的分页实现?基于sql语句的分页实现?还是通过拦截器进行数据分页功能?还是通过RowBounds参数进行物理分页?几种都...
  • 分页的实现
  • redis实现分页查询

    万次阅读 2019-12-22 14:08:08
    人工智能,零基础入门!... redis中的一个数据类型:list list用于存放类似粉丝列表、文章...list类型实现数据分页查询,通过lrange命令,读取某个闭区间内的元素,如下: # 0开始位置 3结束位置 lrange mylist 0 3 ...
  • Hive实现分页的方法

    万次阅读 2017-05-04 20:55:22
    hive没有像MySQL那样的limit start,end那样的写法实现分页,所以需要使用别的方式来实现分页。 以下是我想到的两种方式: 一、借助唯一标识字段 如果分页的表有唯一标识的字段,可以通过这个字段来实现分页: 获取...
  • word删除分页符的两种方法

    万次阅读 2018-03-26 10:26:34
    2.分别将插入点定位到分页符前面,按“Delete”键删除分页符。方法二:用“替换”命令删除。1.打开word文档,单击“开始”菜单下的“替换”命令,在弹出的“查找和替换”对话框中单击“查找内容”右侧的输入框,单击...
  • MySql实现分页查询的SQL,mysql实现分页查询的sql语句

    万次阅读 多人点赞 2016-05-23 14:44:19
    摘要:MySql数据库实现分页查询的SQL语句写法! 一:分页需求: 客户端通过传递start(页码),limit(每页显示的条数)两个参数去分页查询数据库表中的数据,那我们知道MySql数据库提供了分页的函数limit m,n,...
  • 利用itextPdf,并且实现页面分页

    万次阅读 2017-03-28 15:27:54
    参考,并解决了中文乱码:http://www.cnblogs.com/mvilplss/p/5646675.html
  • 分页计算公式

    万次阅读 2018-05-27 11:36:21
    limit start pageSize;start:就是当前页的起始索引,pageSize就是每页的条数currentPage:就是当前页公式:start=(currentPage-1)*pageSize
  • layui的分页实例详解

    万次阅读 2018-09-20 17:43:07
    layui的分页实例详解 layui分页官方地址:https://www.layui.com/doc/modules/laypage.html 第一步 页面引入layui的css和js 这不就不用演示了吧 第二步 在html中写入样式 第三步 写js代码 目前就是简单的把...
1 2 3 4 5 ... 20
收藏数 451,110
精华内容 180,444
关键字:

分页