精华内容
下载资源
问答
  • java web从网页表单输入数据存储到MySQL数据库

    万次阅读 多人点赞 2017-05-22 09:25:01
    最近做的项目中有一个模块需要填写页面上的表单,然后将表单的内容存入到MySQL数据库,下面将代码贴出来。 项目结构: 数据库设计:...import java.sql.Connection; import java.sql.PreparedStatement;import com.Util

    最近做的项目中有一个模块需要填写页面上的表单,然后将表单的内容存入到MySQL数据库,下面将代码贴出来。

    1. 项目结构:
      这里写图片描述
    2. 数据库设计:
      这里写图片描述
      3.各部分代码:
      package com.Interface:
    package com.Interface;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    
    import com.Util.DbUtil;
    import com.model.Literature;
    
    public class LiteratureInterface{
        public boolean addLiterature(Literature literature){
            String ChineseName=literature.getChineseName();
            String EnglishName=literature.getEnglishName();
            String Type=literature.getType();
            String Author=literature.getAuthor();
            String Source=literature.getSource();
            String ChineseAbstract=literature.getChineseAbstract();
            String EnglishAbstract=literature.getEnglishAbstract();
            String ChineseKeyword=literature.getChineseKeyword();
            String EnglishKeyword=literature.getEnglishKeyword();
            String ReforName=literature.getReforName();
            String Incentive=literature.getIncentive();
            String Content=literature.getContent();
    
            DbUtil db=new DbUtil();
            try {
                String sql="INSERT INTO wenxian(ChineseName,EnglishName,Type,Author,Source,ChineseAbstract,EnglishAbstract,ChineseKeyword,EnglishKeyword,ReforName,Incentive,Content) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)";
                Connection conn=db.getCon();
                PreparedStatement ps=conn.prepareStatement(sql);
                ps.setString(1, ChineseName);
                ps.setString(2, EnglishName);
                ps.setString(3, Type);
                ps.setString(4, Author);
                ps.setString(5, Source);
                ps.setString(6, ChineseAbstract);
                ps.setString(7, EnglishAbstract);
                ps.setString(8, ChineseKeyword);
                ps.setString(9, EnglishKeyword);
                ps.setString(10, ReforName);
                ps.setString(11, Incentive);
                ps.setString(12, Content);
                ps.executeUpdate();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return true;
    
        }
    }

    package com.model:

    package com.model;
    
    public class Literature {
        private String ChineseName;
        private String EnglishName;
        private String Type;
        private String Author;
        private String Source;
        private String ChineseAbstract;
        private String EnglishAbstract;
        private String ChineseKeyword;
        private String EnglishKeyword;
        private String ReforName;
        private String Incentive;
        private String Content;
        public String getChineseName() {
            return ChineseName;
        }
        public void setChineseName(String chineseName) {
            ChineseName = chineseName;
        }
        public String getEnglishName() {
            return EnglishName;
        }
        public void setEnglishName(String englishName) {
            EnglishName = englishName;
        }
        public String getAuthor() {
            return Author;
        }
        public void setAuthor(String author) {
            Author = author;
        }
        public String getSource() {
            return Source;
        }
        public void setSource(String source) {
            Source = source;
        }
        public String getChineseAbstract() {
            return ChineseAbstract;
        }
        public void setChineseAbstract(String chineseAbstract) {
            ChineseAbstract = chineseAbstract;
        }
        public String getEnglishAbstract() {
            return EnglishAbstract;
        }
        public void setEnglishAbstract(String englishAbstract) {
            EnglishAbstract = englishAbstract;
        }
        public String getChineseKeyword() {
            return ChineseKeyword;
        }
        public void setChineseKeyword(String chineseKeyword) {
            ChineseKeyword = chineseKeyword;
        }
        public String getEnglishKeyword() {
            return EnglishKeyword;
        }
        public void setEnglishKeyword(String englishKeyword) {
            EnglishKeyword = englishKeyword;
        }
        public String getReforName() {
            return ReforName;
        }
        public void setReforName(String reforName) {
            ReforName = reforName;
        }
        public String getIncentive() {
            return Incentive;
        }
        public void setIncentive(String incentive) {
            Incentive = incentive;
        }
        public String getContent() {
            return Content;
        }
        public void setContent(String content) {
            Content = content;
        }
        public String getType() {
            return Type;
        }
        public void setType(String type) {
            Type = type;
        }
    
    }
    

    package com.Util:

    package com.Util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
       public class DbUtil {
    
        private String url="jdbc:mysql://localhost:3306/db-jsp";
        private String user="root";
        private String password="123";
        private String driver="com.mysql.jdbc.Driver";
    
        public Connection getCon() throws Exception{
                     Class.forName(driver);
                    Connection con=DriverManager.getConnection(url, user, password);
                    return con;
    
        }
    
    
        public static void getClose(Connection con) throws SQLException{
            if(con!=null){
                con.close();
            }
    
        }
    
    
    
    
    
    
    }

    package com.web:

    package com.web;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import com.Interface.LiteratureInterface;
    import com.Util.DbUtil;
    import com.model.Literature;
    
    public class PublishServlet extends HttpServlet {
        DbUtil db=new DbUtil();
    
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
    
        /**
         * Constructor of the object.
         */
        public PublishServlet() {
            super();
        }
    
        /**
         * Destruction of the servlet. <br>
         */
        public void destroy() {
            super.destroy(); // Just puts "destroy" string in log
            // Put your code here
        }
    
        /**
         * The doGet method of the servlet. <br>
         *
         * This method is called when a form has its tag value method equals to get.
         * 
         * @param request the request send by the client to the server
         * @param response the response send by the server to the client
         * @throws ServletException if an error occurred
         * @throws IOException if an error occurred
         */
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
    
    
        }
    
        /**
         * The doPost method of the servlet. <br>
         *
         * This method is called when a form has its tag value method equals to post.
         * 
         * @param request the request send by the client to the server
         * @param response the response send by the server to the client
         * @throws ServletException if an error occurred
         * @throws IOException if an error occurred
         */
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            request.setCharacterEncoding("UTF-8");  
            response.setContentType("text/html;charset=UTF-8");
    
            String ChineseName=request.getParameter("ChineseName");
            String EnglishName=request.getParameter("EnglishName");
            String Type=request.getParameter("Type");
            String Author=request.getParameter("Author");
            String Source=request.getParameter("Source");
            String ChineseAbstract=request.getParameter("ChineseAbstract");
            String EnglishAbstract=request.getParameter("EnglishAbstract");
            String ChineseKeyword=request.getParameter("ChineseKeyword");
            String EnglishKeyword=request.getParameter("EnglishKeyword");
            String ReforName=request.getParameter("ReforName");
            String Incentive=request.getParameter("Incentive");
            String Content=request.getParameter("Content");
    
            Literature literature=new Literature();
            literature.setChineseName(ChineseName);
            literature.setEnglishName(EnglishName);
            literature.setType(Type);
            literature.setAuthor(Author);
            literature.setSource(Source);
            literature.setChineseAbstract(ChineseAbstract);
            literature.setEnglishAbstract(EnglishAbstract);
            literature.setChineseKeyword(ChineseKeyword);
            literature.setEnglishKeyword(EnglishKeyword);
            literature.setReforName(ReforName);
            literature.setIncentive(Incentive);
            literature.setContent(Content);
    
            LiteratureInterface literatureInter=new LiteratureInterface();
            literatureInter.addLiterature(literature);
    
            request.getRequestDispatcher("main.jsp").forward(request, response);
        }
    
        /**
         * Initialization of the servlet. <br>
         *
         * @throws ServletException if an error occurs
         */
        public void init() throws ServletException {
            // Put your code here
        }
    
    }
    

    index.jsp:

    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
    
        <title>My JSP 'index.jsp' starting page</title>
        <meta http-equiv="pragma" content="no-cache">
        <meta http-equiv="cache-control" content="no-cache">
        <meta http-equiv="expires" content="0">    
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="This is my page">
        <!--
        <link rel="stylesheet" type="text/css" href="styles.css">
        -->
      </head>
    
      <body>
       <form action="PublishServlet" method="post">
       <table>
           <tr>
              <td>文献中文名称:</td>
              <td><input type="text" name="ChineseName" value="${param.ChineseName}"></td>
           </tr>
           <tr>
              <td>文献英文名称:</td>
              <td><input type="text" name="EnglishName" value="${param.EnglishiName}"></td>
           </tr>
           <tr>
              <td>文献类型:</td>
              <td>
                 <select name="Type">
                    <option value="">请选择</option>
                    <option value="学术论文">学术论文</option>
                    <option value="硕士学位论文">硕士学位论文</option>
                    <option value="博士学位论文">博士学位论文</option>
                    <option value="教材">教材</option>
                    <option value="专著">专著</option>
                    <option value="网文">网文</option>
                    <option value="报告">报告</option>
                    <option value="文档">文档</option>
                 </select>
              </td>
           </tr>
           <tr>
              <td>作者:</td>
              <td><input type="text" name="Author" value="${param.Author}"></td>
           </tr>
           <tr>
              <td>文献来源:</td>
              <td><input type="text" name="Source" value="${param.Source}"></td>
           </tr>
           <tr>
              <td>中文摘要:</td>
              <td><input type="text" name="ChineseAbstract" value="${param.ChineseAbstract}"></td>
           </tr>
           <tr>
              <td>英文摘要:</td>
              <td><input type="text" name="EnglishAbstract" value="${param.EnglishAbstract}"></td>
           </tr>
           <tr>
              <td>中文关键词:</td>
              <td><input type="text" name="ChineseKeyword" value="${param.ChineseKeyword}"></td>
           </tr>
           <tr>
              <td>英文关键词:</td>
              <td><input type="text" name="EnglishKeyword" value="${param.EnglishKeyword}"></td>
           </tr>
           <tr>
              <td>参考文献:</td>
              <td><input type="text" name="ReforName" value="${param.ReforName}"></td>
           </tr>
           <tr>
              <td>收集动机(因做哪个项目收集此文献):</td>
              <td><input type="text" name="Incentive" value="${param.Incentive}"></td>
           </tr>
           <tr>
              <td>内容:</td>
              <td><textarea name="Content" >${param.Content}</textarea></td>
           </tr>
           <tr>
              <td>
               <input type="submit" value="提交">
              </td>
           </tr>
    
       </table>
    
       </form>
      </body>
    </html>
    

    main.jsp:

    <%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
    
        <title>My JSP 'main.jsp' starting page</title>
    
        <meta http-equiv="pragma" content="no-cache">
        <meta http-equiv="cache-control" content="no-cache">
        <meta http-equiv="expires" content="0">    
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="This is my page">
        <!--
        <link rel="stylesheet" type="text/css" href="styles.css">
        -->
    
      </head>
    
      <body>
        This is my JSP page. <br>
      </body>
    </html>
    

    administrator.jsp:

    <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
    
        <title>My JSP 'guanliyuan.jsp' starting page</title>
    
        <meta http-equiv="pragma" content="no-cache">
        <meta http-equiv="cache-control" content="no-cache">
        <meta http-equiv="expires" content="0">    
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="This is my page">
        <!--
        <link rel="stylesheet" type="text/css" href="styles.css">
        -->
    
      </head>
    
      <body>
         <form action="PublishServlet" method="post">
       <table>
           <tr>
              <td>文献中文名称:</td>
              <td><input type="text" name="ChineseName" value="${param.ChineseName}"></td>
           </tr>
           <tr>
              <td>文献英文名称:</td>
              <td><input type="text" name="EnglishName" value="${param.EnglishiName}"></td>
           </tr>
           <tr>
              <td>作者:</td>
              <td><input type="text" name="Author" value="${param.Author}"></td>
           </tr>
           <tr>
              <td>文献来源:</td>
              <td><input type="text" name="Source" value="${param.Source}"></td>
           </tr>
           <tr>
              <td>中文摘要:</td>
              <td><input type="text" name="ChineseAbstract" value="${param.ChineseAbstract}"></td>
           </tr>
           <tr>
              <td>英文摘要:</td>
              <td><input type="text" name="EnglishAbstract" value="${param.EnglishAbstract}"></td>
           </tr>
           <tr>
              <td>中文关键词:</td>
              <td><input type="text" name="ChineseKeyword" value="${param.ChineseKeyword}"></td>
           </tr>
           <tr>
              <td>英文关键词:</td>
              <td><input type="text" name="EnglishKeyword" value="${param.EnglishKeyword}"></td>
           </tr>
           <tr>
              <td>参考文献:</td>
              <td><input type="text" name="ReforName" value="${param.ReforName}"></td>
           </tr>
           <tr>
              <td>收集动机(因做哪个项目收集此文献):</td>
              <td><input type="text" name="Incentive" value="${param.Incentive}"></td>
           </tr>
           <tr>
              <td>内容:</td>
              <td><textarea name="Content" >${param.Content}</textarea></td>
           </tr>
           <tr>
              <td>
               <input type="submit" value="提交">
              </td>
           </tr>
    
       </table>
    
       </form>
      </body>
    </html>
    

    配置文件web.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="3.0" 
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
        http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
      <display-name></display-name>
      <servlet>
        <description>This is the description of my J2EE component</description>
        <display-name>This is the display name of my J2EE component</display-name>
        <servlet-name>PublishServlet</servlet-name>
        <servlet-class>com.web.PublishServlet</servlet-class>
      </servlet>
    
    
    
      <servlet-mapping>
        <servlet-name>PublishServlet</servlet-name>
        <url-pattern>/PublishServlet</url-pattern>
      </servlet-mapping>
    
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
    </web-app>
    

    4.运行项目,首界面:
    这里写图片描述
    点击提交后,再刷新数据库:
    这里写图片描述

    展开全文
  • Java 线程局部存储

    千次阅读 2011-09-19 23:03:40
    Java中对线程局部存储进行支持的类是: public class ThreadLocal extends Object 其文档解释为: 该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物,因为访问某个变量(通过其

    一,简介和应用

    Java中对线程局部存储进行支持的类是:

    public class ThreadLocal<T> extends Object

    其文档解释为:

    该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物,因为访问某个变量(通过其 getset 方法)的每个线程都有自己的局部变量,它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段,它们希望将状态与某一个线程(例如,用户 ID 或事务 ID)相关联。

    解释下这段话:

      1,该类提供“线程局部存储技术”。即尽管表面上,访问的都是这个类的get()方法和set()方法,但是不同的线程设置的和获取的数据是不同的。

      2,该类往往是作为其他类的private static字段存在,用以保持一个与线程本身有关的变量的。


    方法摘要
     T get()
              返回此线程局部变量的当前线程副本中的值。
    protected  T initialValue()
              返回此线程局部变量的当前线程的“初始值”。
     void remove()
              移除此线程局部变量当前线程的值。
     void set(T value)
              将此线程局部变量的当前线程副本中的值设置为指定值。

    例如,任务类Task被作为线程池的任务执行,线程池的线程执行任务需要统计执行的线程数,因此,这个数可以作为线程局部存储的数据。


    public class Task implements Runnable{


        private static final ThreadLocal threadLocal = new ThreadLocal();

        public void run() {

            Integer in = (Integer)threadLocal.get();

            if(in == null){
                //线程里没有该数据,说明是第一次执行
                threadLocal.set(new Integer(1));

            }else{
                //线程中有该数据,则应该进行更新
                threadLocal.set(in+1);

            }

            //执行任务的时候打印下目前已经有多少任务是由该线程执行的

            System.out.println(threadLocal.get().toString()+"  tasks are run by this thread. ");

       }

    }


    二,实现原理

      这种机制的实现其实很简单。类ThreadLocal中有个内部类ThreadLocalMap 其是 ThreadLocal 和 所设定的值的Key-Value键值对。 例如对于上述例子,第一次则对应的为 threadLocal -- Integer(1)。但是该ThreadLocalMap的实例,则存储于线程中,是线程类的成员变量。

     因此

    1.   public T get() {  
    2.         Thread t = Thread.currentThread();  
    3.         ThreadLocalMap map = getMap(t);  
    4.         if (map != null)  
    5.             return (T)map.get(this);  
    6.   
    7.         // Maps are constructed lazily.  if the map for this thread  
    8.         // doesn't exist, create it, with this ThreadLocal and its  
    9.         // initial value as its only entry.  
    10.         T value = initialValue();  
    11.         createMap(t, value);  
    12.         return value;  
    13.     }
    14.   
    15.  ThreadLocalMap getMap(Thread t) {
    16.         return t.threadLocals;
    17.    }   

    如上源代码所示,get()方法先调用getMap(Thread t)方法获取线程的成员变量threadLocals,然后从这个threadLocals中以本ThreadLocal 实例为参数获取其值。

    对应的set()方法:

    1.     public void set(T value) {  
    2.         Thread t = Thread.currentThread();  
    3.         ThreadLocalMap map = getMap(t);  
    4.         if (map != null)  
    5.             map.set(this, value);  
    6.         else  
    7.             createMap(t, value);  
    8.     } 
    也是从线程中获取其成员变量然后去设置它的(如果没有则创建它,并设置第一个ThreadLocal-值 的映射)。


    因此,实际上这个类都是从线程的成员变量中获取自己这个类的实例对应的值的。因此尽管类的参数相同,都是自己,但是不同线程导致数据来源不同,因此设置和获取都是线程自己的成员变量。




    展开全文
  • Java虚拟机运行时数据

    万次阅读 2019-12-13 14:55:00
    Java虚拟机在执行Java程序的过程中,会把它所管理的内存划分若干个不同的数据区域,这些区域被赋予不同的用途,它们有着各自创建和销毁时间,有的区域是随着虚拟机进程启动而存在的,有的区域则是依赖用户线程...

    目录

    •写在前面

    •程序计数器

    •java虚拟机栈和本地方法栈

    •java堆

    •方法区


    •写在前面

    Java虚拟机运行时数据区是我们深入了解JVM的必经之路,那这是什么样的一个区域呢?Java虚拟机在执行Java程序的过程中,会把它所管理的内存划分若干个不同的数据区域,这些区域被赋予不同的用途,它们有着各自创建和销毁时间,有的区域是随着虚拟机进程启动而存在的,有的区域则是依赖用户线程的启动和结束而建立和销毁的。它是类似一种模型规范,Java虚拟机的构建需要依照这个进行。我们可以把它大致的画成一个图,大概是长这样的。

    关于线程隔离和线程共享的部分,接下来对几个数据区单独讲解的时候会详细说到,这里你只要大概了解他们存在隶属的单个线程的还是整个区域的。

    •程序计数器

    首先我们来谈一谈程序计数器,程序计数器这东西,它其实在不同的虚拟机中有不同的实现,毕竟相对于对程序独立计数的算法,往往有很多更加优化高效的算法可以使用,所以我们在这里提到的程序计数器的概念,是在虚拟机的内存模型中的,具体实现因不同虚拟机而异。在概念模型中,程序计数器是一块较小的内存空间,它可以看做是当前线程所执行的字节码的行号指示器,字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

    为了方便理解,我这里打开一个编译后的字节码文件,贴出来,你就会发现十六进制下,他们是一个寻址执行的过程(自己也可以去找一个class文件看看,记得别直接用记事本啥的打开哦会乱码的,可以使用winhex这个小工具打开)。

    由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的,在任何一个确定的时刻,一个处理器只能执行一条线程中的指令,因此,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各条线程之间计数器互不影响,独立储存,所以说程序计数器是“线程私有”的内存区。

    要强调一下的是,线程在执行一个java方法,这个程序计数器记录的是正在执行的虚拟机字节码指令地址,就是上图我标记的内存偏移地址(指令地址),但如果执行的是一个native方法,则程序计数器为空,也就是undefined。而且程序计数器这块内存是唯一一个在java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

    •java虚拟机栈和本地方法栈

    和程序计数器一样,java虚拟机栈同样也是线程私有的,它的生命周期和线程相同,虚拟机栈描述的是java方法执行的内存模型,这个模型大概这么描述:每个方法在执行的同时都会创建一个栈帧用于储存局部变量表、操作数栈、动态链接、方法出口等信息,每个方法从条用直至执行完成的过程,就是对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

    进一步了解,局部变量表存放了编译期可知的各种基本数据类型(就是boolean、int、float之类的这些)、对象引用(就是我们所说的reference类型,它是指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄或者其他与此对象相关的位置)、returnAddress类型(指向了一条字节码指令的地址)。

    基本数据类型中,long和double类型是64位长度,所以在局部变量表中占用2个空间,其余的数据只占一个。局部变量变所需的内存空间在编译期间就完成了分配,当进入一个方法是,这个方法需要在帧中分配多大的局部变量空间是确定的,方法运行期间不会改变局部变量表的大小。

    对于java虚拟机栈,规定了两种异常状况,第一种是如果线程请求的栈深度大于虚拟机所允许的深度,将抛出Stack OverflowError异常。第二种是如果虚拟机栈可以动态扩展,而扩展是无法申请足够的内存,就会抛出OutOfMemoryError异常。

    本地方法栈,之所以和虚拟机栈放在一起讲,是因为两个发挥的作用非常相似,它们之间的差别不过是虚拟机栈为虚拟机执行的java方法工作,而本地方发展执行的是Native方法工作(java方法和native方法东西挺多了,有兴趣看我另一篇文章,专门讲这两个东西)

    •java堆

    java堆应该是我们打交道最大的一块内存,和目前为止上面讲到的区域不同的是,java堆是一块所有线程共享的一块内存区域。在虚拟机启动时创建。这个内存的唯一目的就是用来存放对象实例,几乎所有的对象实例都放在这里分配内存,我们翻阅java虚拟机规范的时候,里面是这样描述的:所有对象的实例以及数组都要在堆上分配,但随着JIT编译器的发展与逃逸分析技术逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化,所有的对象都是分配在堆上也渐渐变得不那么绝对。

    正因为我们创建的所有实例都放在堆上分配,所以,虚拟机在进行垃圾回收的时候,主要也是针对java堆进行的,所以java堆也被成为GC堆。从内存回收的角度来看,由于现在收集器基本都采用分带收集算法,所以java堆还可以细分为新生代和老年代,更进一步就是一个E区和两个S区,关于分代涉及到GC算法,可以查阅我的另一篇文章,专门对GC算法进行详细的讲解。从内存分配的角度来看,线程共享的java堆中可能划分出多个线程私有的分配缓冲区,不过无论如何划分,都与存放内容没有关系,无论哪个区域,存放的都是对象实例

    •方法区

    同java堆一样,方法区也是线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。你去查案java虚拟机规范的时候会发现,里面把方法区描述为堆的一个逻辑部分,但它却又一个别名叫做Non-Heap(非堆),目的就是和java堆区分开。特别说明的是,方法区和java堆一样不需要连续的内存和可以选择固定大小或者可以扩展外,还可以不识闲垃圾回收。换一种确切的说法就是垃圾回收行为在这个区域是比较少出现的,但并非数据进入方法区就永久存在了(方法区已经被用来做永久代),这区域的内存回收目标主要是针对常量池的回收和对类型的卸载,一般来说这个区域的回收效果很难达到预期,毕竟里面存的都是些“老东西”,尤其是类型的卸载,条件相当的苛刻,但不管怎么说,还是需要进行垃圾回收的。

    在方法区中有一个特别的部分,叫做运行时常量池。我们编译出来的Class文件中,除了有类的版本、字段、方法、接口等描述信息外,还有一项信息就叫做常量池,用来存放编译器生成的各种字面量和符号引用,这部分内容将在类加载进入方法区的运行时常量池中存放。

    我们知道的,java虚拟机对Class文件的每一部分的格式都有严格的规定,每一个字节用于储存哪种数据都必须符合规范上的要求才能被虚拟机认可、装载和执行(上面的那个class文件的内容,你不要觉得它乱,其实它有着严格的格式)。但对于运行时常量池,java虚拟机规范中没有做任何细节的要求,不同的提供商的虚拟机有着不同的实现方式。不过一般来说,除了保存Class文件中描述的符号引用外,还会把翻译出来的直接引用也储存在运行时常量池中。运行时常量池相对于Class文件常量的另一个重要特征是具备动态性,java语言并不要求常量一定只要编译器才能产生,也就是并非预置入Class文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性用到比较多的是String类的intern()方法。

    展开全文
  • 数据存储之SharedPreferences

    千次阅读 2016-03-07 22:57:48
    在Android系统中提供了多张存储技术,这些存储技术可以讲数据保存在各种存储介质上。例如SharedPreferences可以将数据保存在应用软件的私有存储区,这些存储区中的数据只能被写入这些数据的软件读取。除此之外,...

    在Android系统中提供了多张存储技术,这些存储技术可以讲数据保存在各种存储介质上。例如SharedPreferences可以将数据保存在应用软件的私有存储区,这些存储区中的数据只能被写入这些数据的软件读取。除此之外,Android系统还支持文件存储、SQLite数据库、OBB文件、云存储等


    SharedPreferences的基本用法

    SharedPreferences处理的就是一个key-value对。

    它是一个轻量级的存储类,特别适合用于保存软件配置参数。使用SharedPreferences保存数 据,其背后是用xml文件存放数据,使用简易的键值对存储。

    //文件命名为demo,私有模式
    SharedPreferences sharedPreferences = getSharedPreferences("demo", Context.MODE_PRIVATE);
    Editor editor = sharedPreferences.edit();//获取编辑器
    editor.putString("name", "hello");
    editor.putInt("age", 6);
    editor.commit();//提交修改

    这样,我们就把信息存储到了/data/data/<packagename>/shared_prefs/demo.xml文件里面,现在你打开这个文件,就可以看到内容已经被存储。如下:

    <?xml version='1.0' encoding='utf-8' standalone='yes' ?>
    <map>
    <string name="name">hello</string>
    <int name="age" value="6" />
    </map>

    getSharedPreferences(name,mode) 方法的第一个参数用于指定该文件的名称,最好定义为一个静态字符串,另外,名称如上面所示,不用带后缀名,后缀名会由系统自动加上。方法的第二个参数指定 文件的操作模式,共有四种操作模式,这四种模式想必大家都有一定的了解。这里简单说一下:

    Type Commens
    MODE_PRIVATE 默认模式,在创建的文件只能该应用能够使用(或所有的应用程序共享同一个用户标识号)。
    MODE_APPEND 如果文件已经存在,在文件内容后面添加。
    MODE_WORLD_READABLE 允许其他应用读该应用创建的文件。
    MODE_WORLD_WRITEABLE 允许其他应用写该应用创建的文件。

    所以,如果你希望SharedPreferences背后使用的xml文件能被其他应用读和写,可以指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。

    另外Activity还提供了另一个getPreferences(mode)方法操作SharedPreferences,这个方法默认使用当前类不带包名的类名作为文件的名称。

    如果我们的模式设置为Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限,我们其他的应用是可以访问的,下面是其他应用访问的代码(假如上面代码的包名为cn.test.demo):

    try{
     Context context = createPackageContext("cn.test.demo",  Context.CONTEXT_IGNORE_SECURITY);
    } catch (NameNotFoundException e){
     e.printStackTrace();
    }

    CreatePackageContext这个方法有两个参数:
    1.packageName 包名,要得到Context的包名
    2.flags 标志位,有CONTEXT_INCLUDE_CODECONTEXT_IGNORE_SECURITY两个选项。

    CONTEXT_INCLUDE_CODE的意思是包括代码,也就是说可以执行这个包里面的代码。
    CONTEXT_IGNORE_SECURITY的意思 是忽略安全警告,如果不加这个标志的话,有些功能是用不了的,会出现安全警告。

    CreatePackageContext方法在找不到包名的时候会报NameNotFoundException异常,所以我们要捕获它。


    数据的存储位置和格式

    文件存放在/data/data/<packagename> /shared_prefs目录下

    存取复杂类型的数据

    不建议使用,但是确实可以存储复杂类型的数据。

    如果想用SharedPreferences存取更加复杂的数据类型(对象图像等),就需要对这些数据进行编码,通常会将复杂类型的数据转换成Base64格式的编码,然后将转换后的数据以字符串的形式保存在xml文件中。

    效果图

    这里写图片描述

    说明

    本例将一个Product对象和一个图像保存在xml文件中,并在程序重新运行后从xml文件装载Product和图像。

    Code

    Product.java

    
    import java.io.Serializable;
    
    /**
     * MyApp
     *
     * @author Mr.Yang on 2016-02-21  17:08.
     * @version 1.0
     * @desc  必须可序列化,需要实现Serializable
     */
    public class Product implements Serializable
    {
        public String name;
        public int price;
    }
    

    我们使用了存放在res/drawable中的图片,下面的代码将该图像保存在base64.xml文件中。

    将该图像保存在base64.xml文件中。

     try {
                SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
                SharedPreferences.Editor editor = sharedPreferences.edit();
    
                // 读取和压缩R.drawable.item10,并将其压缩结果保存在ByteArrayOutputStream中
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                BitmapFactory.decodeResource(getResources(), R.drawable.item10).compress(Bitmap.CompressFormat.JPEG, 50, baos);
                // 对压缩后的字节进行Base6编码
                String imageBase64 = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT));
                // 保存转换后的Base64格式字符串
                editor.putString("image", imageBase64);
                editor.commit();
                // 关闭输出流
                baos.close();
    
                Toast.makeText(this, "onClick_Save_Image 成功", Toast.LENGTH_LONG).show();
    
            } catch (Exception e) {
    
            }

    读取并显示在ImageView上

     try {
                SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
                // 读取Base64格式的图片数据
                String imageBase64 = sharedPreferences.getString("image", "");
                // 对Base64格式的字符串进行解码,还原成字节数组
                byte[] imageBytes = Base64.decode(imageBase64.getBytes(), Base64.DEFAULT);
                ByteArrayInputStream bais = new ByteArrayInputStream(imageBytes);
                // 在控件上显示图像
                ImageView imageView = (ImageView) findViewById(R.id.image);
                imageView.setImageDrawable(Drawable.createFromStream(bais, "image"));
                // 关闭输入流
                bais.close();
    
                Toast.makeText(this, "onClick_Read_Image 成功", Toast.LENGTH_LONG).show();
    
    
            } catch (Exception e) {
    
            }

    将Product保存到base64.xml中

      try {
                Product product = new Product();
    
                product.name = "如来神掌";
                product.price = 1500;
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                // 将Product对象保存到ObjectOutputStream中
                oos.writeObject(product);
    
                SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
                SharedPreferences.Editor editor = sharedPreferences.edit();
                // 将Product对象转换成byte数组,并将其进行Base64编码
                String productBase64 = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT));
                // 将编码后的字符串保存到base64.xml中
                editor.putString("product", productBase64);
                editor.commit();
                // 输出流关闭
                oos.close();
    
                Toast.makeText(this, "onClick_Save_Serializable_Object 成功", Toast.LENGTH_LONG).show();
            } catch (Exception e) {
    
            }

    从base64.xml中读取Product对象

     try {
                SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
                // 读取Product对象的Base64格式的字符串
                String base64Product = sharedPreferences.getString("product", "");
    
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                //将base64格式字符串还原成byte数组
                byte[] productBytes = Base64.decode(base64Product.getBytes(), Base64.DEFAULT);
                ByteArrayInputStream bais = new ByteArrayInputStream(productBytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                // 将byte数组转换成Product对象
                Product product = (Product) ois.readObject();
                Toast.makeText(this,
                        "name:" + product.name + "\nprice:" + product.price,
                        Toast.LENGTH_LONG).show();
                // 关闭输入流
                ois.close();
    
            } catch (Exception e) {
    
            }

    设置数据文件的访问权限

     /**
         * MODE_WORLD_READABLE  MODE_WORLD_READABLE
         * "This constant was deprecated in API level 17.
         * Creating world-readable files is very dangerous,
         * and likely to cause security holes in applications.
         * It is strongly discouraged; instead,
         * applications should use more formal mechanism for interactions
         * such as ContentProvider, BroadcastReceiver, and Service.
         * There are no guarantees that this access mode will remain on a file,
         * such as when it goes through a backup and restore.
         * File creation mode: allow all other applications to have read access to the created file."
         */
        private void createDiffPermissionSpFile() {
    
            int[] modes = new int[]{Activity.MODE_PRIVATE, Activity.MODE_APPEND,
                    Activity.MODE_WORLD_READABLE,
                    Activity.MODE_WORLD_READABLE};
    
            for (int i = 0; i < modes.length; i++) {
    
                SharedPreferences sharedPreferences = getSharedPreferences("data" + String.valueOf(i + 1), modes[i]);
                SharedPreferences.Editor editor = sharedPreferences.edit();
                editor.putString("name", "不同的访问权限");
                editor.commit();
    
            }
        }

    观察生成的文件的权限,同linux文件系统

    可以保存设置的Activity:PreferenceActivity

    概述

    Android SDK提供了更加方便的方法来实现配置界面,并且可以透明的保存配置信息,这就是PreferenceActivity.

    PreferenceActivity是Activity的子类,该类封装了SharedPreference,因此PreferenceActivity的所有子类都会拥有保存key-value的能力。

    通过PreferenceActivity生成的XML文件在data/data/<工程名>/shared_prefs/下,名字为“<工程名>_Preference.xml。

    在PreferenceActivity中,所有的修改都会自动更新该XML文件,不需要我们手动去设置大量的监听。

    PreferenceActivity提供了一些常用的控件,可以满足大多数配置界面的要求, PreferenceActivity既可以从xml文件中创建,也可以通过代码的方式创建。

    比较常用的控件有3个:

    • CheckBoxPreference:对应<CheckBoxPreference>标签,相当于CheckBox
    • EditTextPreference:对应<EditTextPreference>标签。单击该控件会弹出一个带有EditText的对话框
    • ListPreference:对应<ListPreference>标签,单击该控件会弹出一个带ListView的对话框。

    效果图

    这里写图片描述

    PreferenceActivity在API11之后就废弃了,建议使用PreferenceFragment。

    res目录下创建一个xml子目录,建立preference_setting.xml

    <?xml version="1.0" encoding="utf-8"?>
    <PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android" >
    
        <PreferenceCategory android:title="我的位置源" >
            <CheckBoxPreference
                android:key="wireless_network"
                android:summary="使用无线网络查看应用程序(例如Google地图)中的位置"
                android:title="使用无线网络" />
            <CheckBoxPreference
                android:key="gps_satellite_setting"
                android:summary="定位时,精确到街道级别(取消选择可节约电量)"
                android:title="启用GPS卫星设置" />
        </PreferenceCategory>
    
    
        <PreferenceCategory android:title="个人信息设置" >
            <CheckBoxPreference
                android:key="yesno_save_individual_info"
                android:title="是否保存个人信息" />
    
            <EditTextPreference
                android:key="individual_name"
                android:summary="请输入真实姓名"
                android:title="姓名" />
    
            <PreferenceScreen
                android:key="other_individual_msg"
                android:summary="是否工作、手机"
                android:title="其他个人信息" >
                <CheckBoxPreference
                    android:key="is_an_employee"
                    android:title="是否工作" />
    
                <EditTextPreference
                    android:key="mobile"
                    android:summary="请输入真实的手机号"
                    android:title="手机" />
            </PreferenceScreen>
        </PreferenceCategory>
    
    </PreferenceScreen>

    PreferenceActivityDemo

    package com.turing.base.activity.dataStore.sharedPreference;
    
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.preference.Preference;
    import android.preference.PreferenceActivity;
    import android.preference.PreferenceScreen;
    
    import com.turing.base.R;
    
    /**
     *   3.0版本以后就需要使用PreferenceFragment,这里用过时的也没关系
     */
    public class PreferenceActivityDemo extends PreferenceActivity implements Preference.OnPreferenceChangeListener {
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // 改变保存数据的xml使用的名称,默认是<package_name>_preferences.xml
            getPreferenceManager().setSharedPreferencesName("setting");
            // 从xml文件中加载布局
            addPreferencesFromResource(R.xml.preference_setting);
            // 获取"姓名"列表项对应的Preference对象
            Preference individualNamePreference = findPreference("individual_name");
            // 获得指向setting.xml文件的SharedPreferences对象
            SharedPreferences sharedPreferences = individualNamePreference.getSharedPreferences();
            // 设置列表项的Summary
            individualNamePreference.setSummary(sharedPreferences.getString("individual_name", ""));
            //设置"姓名"列表项是否可用
            if (sharedPreferences.getBoolean("yesno_save_individual_info", false))
                individualNamePreference.setEnabled(true);
            else
                individualNamePreference.setEnabled(false);
            // 设置包含onPreferenceChange事件的对象实例
            individualNamePreference.setOnPreferenceChangeListener(this);
    
            //mobile
    
            // 获取"mobile"列表项对应的Preference对象
            Preference mobilePreference = findPreference("mobile");
            // 获得指向setting.xml文件的SharedPreferences对象
            SharedPreferences mobileSP = mobilePreference.getSharedPreferences();
            // 设置列表项的Summary
            mobilePreference.setSummary(mobileSP.getString("mobile", ""));
            // 设置包含onPreferenceChange事件的对象实例
            mobilePreference.setOnPreferenceChangeListener(this);
    
        }
    
        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            // 设置"姓名"列表项中Summary的值
            preference.setSummary(String.valueOf(newValue));
            // 必须返回为true,否则无法保存设置的值
            return true;
        }
    
        /**
         * 状态改变后的自动文件存储 需要继承PreferenceActivity的类和实现OnPreferenceChangeListener接口,
         * 重写onPreferenceTreeClick方法进行业务逻辑处理
         * @param preferenceScreen
         * @param preference
         * @return
         */
        @Override
        public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,Preference preference) {
            // 判断选中的是否为"是否保存个人信息"列表项的复选框
            if ("yesno_save_individual_info".equals(preference.getKey())) {
                // 设置姓名为可选或者不可选
                findPreference("individual_name").setEnabled(!findPreference("individual_name").isEnabled());
            }
            return super.onPreferenceTreeClick(preferenceScreen, preference);
        }
    }
    展开全文
  • Java EE数据持久化框架 • 【第1章 MyBatis入门】

    万次阅读 多人点赞 2021-04-15 20:07:36
    狭义的讲就是将内存中的数据存储到数据库或其他介质的过程。 Dao层将数据存储到数据库中 Java如何实现数据持久化? JDBC编程操作: 代码重复繁琐、开发效率低 Mybatis、Hibernate等框架技术 企业级应用开发...
  • JAVA使用JDBC技术操作SqlServer数据库执行存储过程: 1.新建SQLSERVER数据库:java_conn_test 2.新建表:tb_User 3.分别新建三个存储过程: 1>带参数的新增用户存储过程: CREATE PROCEDURE [dbo].[p_Insert_User]...
  • java 中变量存储位置的区别

    千次阅读 2013-09-04 20:37:10
    1.寄存器:最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.  2. 栈:存放基本类型的变量数据和对象的引用,但对象本身不存放在栈中,而是存放在堆(new 出来的对象)或者常量池中(字符串常量对象...
  • 在网上偶然看到一篇关于 Java 常用的数据结构的文章,分析的十分透彻,特此记下,以为参阅 :) 线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构...
  • java语言与java技术

    千次阅读 2012-10-03 17:52:36
    本文叙述了Java语言的出现背景、主要特点、发展历程以及Java技术的应用,指出Java是当今IT产业和人类文明的创新和希望。 1.Java语言的出现 自从1946年世界上第一台电子计算机问世以来,计算模式的发展经历了三...
  • Android数据存储几种方式用法总结

    千次阅读 2016-12-11 12:16:11
    Android数据存储几种方式用法总结 1、概述  Android提供了5种方式来让用户保存持久化应用程序数据。根据自己的需求来做选择,比如数据是否是应用程序私有的,是否能被其他程序...
  • Java基础:什么是数据结构

    千次阅读 2018-02-27 16:11:38
    数据结构往往同高效的检索算法和索引技术有关。(来源于百度百科)2、存储数据的方式1、变量变量声明格式: 数据类型 变量名示例:int age变量赋值:int age = 22;注意事项:需要注意值和类型的匹配...
  • Java2核心技术第7版全两卷.pdf中文高清

    千次下载 热门讨论 2012-09-14 14:22:28
     本书是java 2技术权威指南,全面覆盖java 2技术的高级主题,包括:多线程、集合框架、网络api、数据库编程、分布式对象等,深入探究了swing、java 2d api、javabean、java安全模式、xml、注释、元数据等主题,同时...
  • Java Socket 发送/接收数据

    万次阅读 2018-11-28 13:52:53
    在上一篇了解过 Java Socket 的两种形式(TCP、UDP)后,本文将继续介绍如何利用 Java Socket 发送和接收数据及其内部原理的实现。 Java Socket 的目的在于实现与其他程序的信息交互,包括发送和接收信息两种主要...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些...Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
  • Java 常见的数据结构

    万次阅读 2017-10-01 10:39:33
    Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类: 枚举(Enumeration) 位集合(BitSet) 向量(Vector) 栈(Stack) 字典(Dictionary) 哈希表(Hashtable) 属性...
  • 2017 最新java面试题(技术面试)

    万次阅读 多人点赞 2017-09-05 08:36:05
    技术交流群:365814763   1、servlet执行流程 客户端发出http请求,web服务器将请求转发到servlet容器,servlet容器解析url并根据web.xml找到相对应的servlet,并将request、response对象传递给找到的servlet,...
  • Java并发技术学习总结

    千次阅读 2018-06-28 14:40:06
    这篇总结主要是基于我Java并发技术系列的文章而形成的的。主要是把重要的知识点用自己的话说了一遍,可能会有一些错误,还望见谅和指点。谢谢 更多详细内容可以查看我的专栏文章:Java并发技术指南 ...
  • 目录: 1. 背景 ...4. SXSSF、EasyExcel大数据量方案实现 5. SXSSF、EasyExcel大数据量方案对比 6. 性能优化策略 7. 业界其他方案 8. demo下载地址   背景 • 项目背景 XXXXXXXX项目,数据...
  • 23个java数据处理框架

    万次阅读 2019-04-22 16:15:26
    目前,编程人员面对的最大挑战就是复杂性,硬件...根据外媒的一项调查报告,以下列出了Java程序员在过去12个月内一直使用的一些工具或框架,或许会对你有意义。 先来看看大数据的概念。根据维基百科,大数据是...
  • Java ASM 技术简介

    万次阅读 多人点赞 2017-11-23 22:10:53
    什么是ASMASM 是一个 Java ...Java class 被存储在严格格式定义的 .class 文件里,这些类文件拥有足够的元数据来解析类中的所有元素:类名称、方法、属性以及 Java 字节码(指令)。ASM 从类文件中读入信息后,能够改变
  • 基于java社会化海量数据采集爬虫框架搭建 标签: java网络 2016-01-31 19:43 163人阅读 评论(0) 收藏 举报  分类: java(60) 计算机网络(23)  随着BIG DATA大数据概念逐渐升温,...
  • 本来计划要写Android内存优化的,觉得有必要在此之前介绍一下Java虚拟机的相关知识,Java虚拟机也并不是三言两语能够介绍完的,因此开了Java虚拟机系列,这一篇文章我们来学习Java虚拟机的结构原理与运行时数据区域...
  • Java核心技术卷】I/O详析

    千次阅读 多人点赞 2019-09-09 08:34:27
    文章目录概述Java io基本概念关于流流的分类Java io框架一、以字节为单位的输出流的框架图(1)框架图图示(2)OutputStream详解(3)OutputStream子类(4)引申:打印流二、以字节为单位的输入流的框架图(1)框架...
  • java有哪些技术领域

    千次阅读 2018-12-07 23:10:36
    数据访问中间件:解决应用访问数据库的共性问题。 分布式系统-dubbo-spring cloud:一定是有多个节点组成的系统,一般一个节点就是一台服务器,节点之间是相互连通协作的,这些连通的节点上部署了我们的组件,共同...
  • Java开发关键技术

    千次阅读 2017-08-05 16:32:37
    1、servlet技术 Servlet(Server Applet),全称Java Servlet。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据,生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口,广义的Servlet是...
  • JAVA_API1.6文档(中文)

    万次下载 热门讨论 2010-04-12 13:31:34
    java.util.prefs 此包允许应用程序存储并获取用户和系统首选项和配置数据java.util.regex 用于匹配字符序列与正则表达式指定模式的类。 java.util.spi java.util 包中类的服务提供者类。 java.util.zip 提供...
  • JAVA最新技术

    千次阅读 2018-08-22 16:24:17
    在生活中使用过好的JAVA技术、或遇见还未学习的,记录一下留着以后慢慢消化 一、Spring Boot 二、Mybits 轻量级数据库框架 三、Redis 键值对数据缓存 四、Zookeeper 分布式应用程序协调服务, 数据一致性、广播...
  • Java基础问题整理

    万次阅读 多人点赞 2020-04-07 11:44:14
    备注:针对基本问题做一些基本的总结,不是详细解答!...4.HashMap1.7与HashMap1.8的区别,从数据结构上、Hash值的计算上、链表数据的插入方法、内部Entry类的实现上分析? 5.Hash1.7是基于数组...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • Java 技术书籍大全

    千次阅读 多人点赞 2019-08-11 20:38:49
    本文档目前已收录 277本 Java相关领域经典技术书籍,从初级开发者到资深架构师,涵盖 Java 从业者的各个阶段。 涵盖领域:Java入门书籍,Java基础及进阶书籍,框架与中间件,架构设计,设计模式,数学与算法,JVM...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 295,438
精华内容 118,175
关键字:

java用户数据存储技术

java 订阅