十年网站开发经验 + 多家企业客户 + 靠谱的建站团队
量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决
Java 使用executeUpdate向数据库中创建表格
创新互联长期为上1000家客户提供的网站建设服务,团队从业经验10年,关注不同地域、不同群体,并针对不同对象提供差异化的产品和服务;打造开放共赢平台,与合作伙伴共同营造健康的互联网生态环境。为蒲城企业提供专业的成都做网站、网站制作,蒲城网站改版等技术服务。拥有10多年丰富建站经验和众多成功案例,为您定制开发。
一、创建mysql.ini文件,配置如下
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/select_test
user=root
pass=123456
这样以后修改数据库的配置直接在mysql.ini文件中修改。
二、编写代码
initParam方法: 获得mysql.ini中的数据
createTale方法: 连接数据库,并且executeUpdate执行sql语句。此例的sql文件为创建表语句。
main方法: 传入Sql语句。
class ExecuteDDL {
private String driver;
private String url;
private String user;
private String pass;
Connection conn;
Statement stmt;
public void initParam(String paramFile) throws Exception {
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
}
public void createTale(String sql) throws Exception{
try {
Class.forName(driver);
conn = DriverManager.getConnection(url,user,pass);
stmt = conn.createStatement();
stmt.executeUpdate(sql);
}
finally
{
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ExecuteDDL ed = new ExecuteDDL();
ed.initParam("src/mysql.ini");
ed.createTale("create table student " +
"(id int, " +
"name varchar(50), " +
"num varchar(20) )");
System.out.println("Creating table success!");
}
注意事项:传入的Sql语句最好在MySql测试通过,并且传入的mysql.int文件的路径必须正确。
当执行完毕后,在MySql的select_test数据库中查看该Student表是否已经创建成功了。
三、使用executeUpdate方法,向表中插入数据。
将上面的创建表的Sql语句改为插入数据表的语句,执行executeUpdate方法,其结果就是想表中插入数据。
创建insertSql变量。
private static String insertSql = "insert into student values(1,'XiaoMing','06108787')";
执行插入语句。
ed.createTale(insertSql);
1. 基本数据类型
整形:
byte 1 个字节
short 2 个字节
int 4个字节
long 8个字节
字符:
char 2个字节
浮点数:
float 4个字节
double 8个字节
布尔:
boolean 1个字节
2.java 7 新增二进制整数
以0b或者0B开头
3.java中字符时16位的Unicode编码方式,格式是'\uXXXX',其中xxxx代表一个十六进制整数
4.java中规定了正无穷大、负无穷大和零
正无穷大= 一个正数除以0
负无穷大= 一个负数除以零
0.0 除以0.0 或者 对一个负数开方 得到一个非数
5. 在java中布尔类型只能是true和false
6. 在java中没有多维数组
看似像C语言中的多维数组不是真正的数组,比如 a[3][4] , a[0] a[1] a[2] 是真实存在的,装的是地址,和c语言中动态分配为的数组一样
int [][] b = new int[3][4]
7. Java中带包的编译方法
javac -d . Hello.java 会在当前目录下生成目录树
运行 java 包名字.类名字
8. Java多态中的对象的filed 不具有多态性,如 父类 对象 = new 子类(), 对象.field 是调用的父类的,即使子类中覆盖了该字段。
9. instanceof 运算符
格式: 引用变量名 instanceof 类名(或者接口) 他用于判断前面的对象是否是后面对象的类,子类、实现类的实例,是返回true,否者返回false
10. Java 中基本数据类型和对应封装类之间的转化
int a = 1;
Integer A = new Integer(a);
a = A.intValue();
其他的类型也是这样的。
11.单例(singleton)类 例子
复制代码 代码如下:
class Singleton
{
private static Singleton instance;
private Singleton(){}
public static Singleton getInstance()
{
if(instance == null)
{
instance = new Singleton();
}
return instance;
}
public static void main(String[] args)
{
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
12.final修饰的成员变量初始化问题
类Field: 必须在静态初始块中或声明该FIeld时指定初始值
实例Field:必须在非静态初始块中或声明该FIeld时指定初始值或构造器中声明
13.Final 变量必须显式初始化,系统不会对final变量进行隐式初始化
14.java会使用常量池来管理曾经用过的字符串直接常量,例如:String a = "java"; ,系统把常量字符串“java”存在常量池,当再次执行 String b = "java"; a == b 是true
15.final 方法不可以重写,final类不能被继承
如果用private 方法 和 final private 是一样的
若果是用final修饰的方法在子类中出现,那是子类新定义的,与父类没有关系
16.不可变类:创建后该类的Field是不可改变的。java提供了8个基本变量的包装类和string都是不可改变类。
17.缓存实例的不可改变类
复制代码 代码如下:
class CacheImmutale
{
private static int MAX_SIZE = 10;
private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
private static int pos = 0;
private final String name;
private CacheImmutale(String name)
{
this. name = name;
}
public String getName()
{
return name;
}
public static CacheImmutale valueOf(String name)
{
for(int i = 0; i MAX_SIZE; ++i)
{
if(cache[i] != null cache[i].getName().equals(name))
return cache[i];
}
if(pos == MAX_SIZE)
{
cache[0] = new CacheImmutale(name);
pos = 1;
}
else
{
cache[pos++] = new CacheImmutale(name);
}
return cache[pos -1];
}
public boolean equals(Object obj)
{
if(this == obj)
return true;
if(obj != null obj.getClass() == CacheImmutale.class)
{
CacheImmutale ci = (CacheImmutale)obj;
return name.equals(ci.getName());
}
return false;
}
public int hashCode()
{
return name.hashCode();
}
}
public class CacheImmuteTest
{
public static void main(String[] args)
{
CacheImmutale c1 = CacheImmutale.valueOf("Hello");
CacheImmutale c2 = CacheImmutale.valueOf("Hello");
System.out.println(c1 == c2);
}
}
用缓存实例要看某个对象的使用频率,若重复使用那就利大于弊,若不经常使用那弊就大于利
还有java提供的java.lang.Integer 创建数值在-128-127之间的数采用缓存机制的
Integer in2 = Integer.valueOf(6);
Integer in3= Integer.valueOf(6);
in2 == in3 is true;
18. static 和 abstract 不能同时修饰一个方法,没有类抽象方法
19.一个类可以又一个父类,实现多个接口,接口中Filed是public 、static、final的,方法是public abstract的
20.非静态内部类的方法访问某个变量,搜索顺序为:先内部类中方法内- 内部类 - 外部类中如果都找不到则出现编译错误
复制代码 代码如下:
import java.util.*;
public class DiscernVariable
{
private String prop = "外部类的实例变量";
private class InClass
{
private String prop = "内部类的实例变量";
public void info()
{
String prop = "局部变量";
System.out.println("外部类的field值:" + DiscernVariable.this.prop);
System.out.println("内部类的field值:" + this.prop);
System.out.println("局部变量的值:" + prop);
}
}
public void test()
{
InClass in = new InClass();
in.info();
}
public static void main(String[] args)
{
new DiscernVariable().test();
}
}
21.非静态内部类不能有静态方法、静态Field、静态初始化块
22.在外部类之外访问内部类
访问非静态内部类:outclass.Inclass varname = new outclass().new InClass();
访问静态内部类: outclass.Inclass varname = new outclass.Inclass();
复制代码 代码如下:
import java.util.*;
class Out
{
class In
{
public In()
{
System.out.println("非静态内部类构造器");
}
}
}
public class CreatInnerInstance
{
public static void main(String[] args)
{
Out.In in = new Out().new In();
/*
以上的代码可分开写为:
Out.In in;
Out out = new Out();
in = out.new In();
*/
}
}
class SubClass extends Out.In
{
//显示定义SubClass的构造器
public SubClass(Out out)
{
//通过转入的Out对象显示调用In的构造器
out.super();
}
}
复制代码 代码如下:
import java.util.*;
class StaticOut
{
static class StaticIn
{
public StaticIn()
{
System.out.println("静态内部类构造器");
}
}
}
public class CreatStaticInnerInstance
{
public static void main(String[] args)
{
StaticOut.StaticIn in = new StaticOut.StaticIn();
/*
以上的代码可分开写为:
StaticOut.StaticIn in;
in = new StaticOut.StaticIn();
*/
}
}
class SubClass extends StaticOut.StaticIn
{
//无须创建内部类实例
}
tale软件如何,Tale是一款基于Java的博客Web系统,使用了轻量级 mvc 框架 Blade 开发。特性
设计简洁,界面美观
自定义文章链接
支持多主题(默认主题 pinghsu)
支持插件扩展
支持 Emoji 表情
支持网易云音乐播放
支持附件和数据库备份
部署简单,不依赖 Tomcat
无需数据库,内嵌 Sqlite
首先Map排序需要自己写一堆算法。其次HashMap是无序的,即使已经排序正确了,取值时也不一定就是按顺序取出的。所以直接排序存放是不可行的。
但可以曲线救国的办法,通过SetString keys = map.keySet();取得map的key值集合,然后单独给keys来个排序就简单多了,然后按排序后的keys去遍历取值,就OK了。
所谓缓存,就是将程序或系统经常要调用的对象存在内存中,一遍其使用时可以快速调用,不必再去创建新的重复的实例。这样做可以减少系统开销,提高系统效率。缓存机制的实现有很多中,这里讲一种。
public class CacheImmutale{
//声明要缓存的类名;
private final String className;
//声明10个缓存池
private static CacheImmutale[] cache= new CachImmutale[10];
//记录缓存的位置,最新位置为[pos-1]
private static int pos=0;
//构造器
public CacheImmutale(String className){
this.className=className;
}
//返回方法
public String getName(){
return className;
}
//返回对象实例名,传进要使用的实例名,由该方法去判断缓存池中是否存在
public static CacheImmutale valueOf(String className){
//遍历缓存池,若存在,返回
for(int i=0;i
if(cache[i]!=nullcache[i].getName().equals(className)){
return cache[i];
}
}
//如果缓存池满,则采取先进先出
if(pos==10){
cache[0]=new CacheImmutale(className);
pos=1;
return cache[0];
}
else{
cache[pos++]=new CacheImmutale(className);
return cache[pos-1];
}
}
public boolean equals(Object obj){
if(obj instanceof CacheImmutale){
CacheImmutale c1=(CacheImmutale)obj;
if(className.equals(c1.getName())){
return true;
}
}
return false;
}
public int hashCode(){
return className.hashCode();
}
}